2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-08-29 00:18:39 +00:00
|
|
|
* Copyright 2003-2005 Red Hat, Inc. All rights reserved.
|
|
|
|
* Copyright 2003-2005 Jeff Garzik
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; see the file COPYING. If not, write to
|
|
|
|
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* libata documentation is available via 'make {ps|pdf}docs',
|
2017-05-16 12:16:37 +00:00
|
|
|
* as Documentation/driver-api/libata.rst
|
2005-08-29 00:18:39 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_LIBATA_H__
|
|
|
|
#define __LINUX_LIBATA_H__
|
|
|
|
|
|
|
|
#include <linux/delay.h>
|
2008-05-19 17:17:51 +00:00
|
|
|
#include <linux/jiffies.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/interrupt.h>
|
2005-11-11 00:21:38 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
2007-10-16 09:14:12 +00:00
|
|
|
#include <linux/scatterlist.h>
|
2007-01-20 07:00:28 +00:00
|
|
|
#include <linux/io.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/ata.h>
|
|
|
|
#include <linux/workqueue.h>
|
2006-04-11 17:12:34 +00:00
|
|
|
#include <scsi/scsi_host.h>
|
2006-09-28 18:29:01 +00:00
|
|
|
#include <linux/acpi.h>
|
2007-12-05 07:43:06 +00:00
|
|
|
#include <linux/cdrom.h>
|
libata: implement cross-port EH exclusion
In libata, the non-EH code paths should always take and release
ap->lock explicitly when accessing hardware or shared data structures.
However, once EH is active, it's assumed that the port is owned by EH
and EH methods don't explicitly take ap->lock unless race from irq
handler or other code paths are expected. However, libata EH didn't
guarantee exclusion among EHs for ports of the same host. IOW,
multiple EHs may execute in parallel on multiple ports of the same
controller.
In many cases, especially in SATA, the ports are completely
independent of each other and this doesn't cause problems; however,
there are cases where different ports share the same resource, which
lead to obscure timing related bugs such as the one fixed by commit
213373cf (ata_piix: fix locking around SIDPR access).
This patch implements exclusion among EHs of the same host. When EH
begins, it acquires per-host EH ownership by calling ata_eh_acquire().
When EH finishes, the ownership is released by calling
ata_eh_release(). EH ownership is also released whenever the EH
thread goes to sleep from ata_msleep() or explicitly and reacquired
after waking up.
This ensures that while EH is actively accessing the hardware, it has
exclusive access to it while allowing EHs to interleave and progress
in parallel as they hit waiting stages, which dominate the time spent
in EH. This achieves cross-port EH exclusion without pervasive and
fragile changes while still allowing parallel EH for the most part.
This was first reported by yuanding02@gmail.com more than three years
ago in the following bugzilla. :-)
https://bugzilla.kernel.org/show_bug.cgi?id=8223
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Reported-by: yuanding02@gmail.com
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2010-09-06 15:57:14 +00:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-25 19:33:09 +00:00
|
|
|
/*
|
|
|
|
* Define if arch has non-standard setup. This is a _PCI_ standard
|
|
|
|
* not a legacy or ISA standard.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_ATA_NONSTANDARD
|
2006-08-10 07:59:10 +00:00
|
|
|
#include <asm/libata-portmap.h>
|
2006-09-25 19:33:09 +00:00
|
|
|
#else
|
2016-09-22 14:49:50 +00:00
|
|
|
#define ATA_PRIMARY_IRQ(dev) 14
|
|
|
|
#define ATA_SECONDARY_IRQ(dev) 15
|
2006-09-25 19:33:09 +00:00
|
|
|
#endif
|
2006-08-10 07:59:10 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2006-01-18 00:34:42 +00:00
|
|
|
* compile-time options: to be removed as soon as all the drivers are
|
|
|
|
* converted to the new debugging mechanism
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#undef ATA_DEBUG /* debugging output */
|
|
|
|
#undef ATA_VERBOSE_DEBUG /* yet more debugging output */
|
|
|
|
#undef ATA_IRQ_TRAP /* define to ack screaming irqs */
|
|
|
|
#undef ATA_NDEBUG /* define to disable quick runtime checks */
|
|
|
|
|
|
|
|
|
|
|
|
/* note: prints function name for you */
|
|
|
|
#ifdef ATA_DEBUG
|
2008-07-20 20:06:19 +00:00
|
|
|
#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef ATA_VERBOSE_DEBUG
|
2008-07-20 20:06:19 +00:00
|
|
|
#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ## args)
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
|
|
|
#define VPRINTK(fmt, args...)
|
|
|
|
#endif /* ATA_VERBOSE_DEBUG */
|
|
|
|
#else
|
|
|
|
#define DPRINTK(fmt, args...)
|
|
|
|
#define VPRINTK(fmt, args...)
|
|
|
|
#endif /* ATA_DEBUG */
|
|
|
|
|
2008-07-20 20:06:19 +00:00
|
|
|
#define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __func__, ## args)
|
2005-11-14 19:14:16 +00:00
|
|
|
|
2011-04-15 22:52:00 +00:00
|
|
|
#define ata_print_version_once(dev, version) \
|
|
|
|
({ \
|
|
|
|
static bool __print_once; \
|
|
|
|
\
|
|
|
|
if (!__print_once) { \
|
|
|
|
__print_once = true; \
|
|
|
|
ata_print_version(dev, version); \
|
|
|
|
} \
|
|
|
|
})
|
|
|
|
|
2006-01-18 00:34:42 +00:00
|
|
|
/* NEW: debug levels */
|
|
|
|
#define HAVE_LIBATA_MSG 1
|
|
|
|
|
|
|
|
enum {
|
|
|
|
ATA_MSG_DRV = 0x0001,
|
|
|
|
ATA_MSG_INFO = 0x0002,
|
|
|
|
ATA_MSG_PROBE = 0x0004,
|
|
|
|
ATA_MSG_WARN = 0x0008,
|
|
|
|
ATA_MSG_MALLOC = 0x0010,
|
|
|
|
ATA_MSG_CTL = 0x0020,
|
|
|
|
ATA_MSG_INTR = 0x0040,
|
|
|
|
ATA_MSG_ERR = 0x0080,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define ata_msg_drv(p) ((p)->msg_enable & ATA_MSG_DRV)
|
|
|
|
#define ata_msg_info(p) ((p)->msg_enable & ATA_MSG_INFO)
|
|
|
|
#define ata_msg_probe(p) ((p)->msg_enable & ATA_MSG_PROBE)
|
|
|
|
#define ata_msg_warn(p) ((p)->msg_enable & ATA_MSG_WARN)
|
|
|
|
#define ata_msg_malloc(p) ((p)->msg_enable & ATA_MSG_MALLOC)
|
|
|
|
#define ata_msg_ctl(p) ((p)->msg_enable & ATA_MSG_CTL)
|
|
|
|
#define ata_msg_intr(p) ((p)->msg_enable & ATA_MSG_INTR)
|
|
|
|
#define ata_msg_err(p) ((p)->msg_enable & ATA_MSG_ERR)
|
|
|
|
|
|
|
|
static inline u32 ata_msg_init(int dval, int default_msg_enable_bits)
|
|
|
|
{
|
|
|
|
if (dval < 0 || dval >= (sizeof(u32) * 8))
|
|
|
|
return default_msg_enable_bits; /* should be 0x1 - only driver info msgs */
|
|
|
|
if (!dval)
|
|
|
|
return 0;
|
|
|
|
return (1 << dval) - 1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* defines only for the constants which don't work well as enums */
|
|
|
|
#define ATA_TAG_POISON 0xfafbfcfdU
|
|
|
|
|
|
|
|
enum {
|
|
|
|
/* various global constants */
|
|
|
|
LIBATA_MAX_PRD = ATA_MAX_PRD / 2,
|
2007-07-06 23:13:52 +00:00
|
|
|
LIBATA_DUMB_MAX_PRD = ATA_MAX_PRD / 4, /* Worst case */
|
2005-04-16 22:20:36 +00:00
|
|
|
ATA_DEF_QUEUE = 1,
|
2006-05-15 11:58:02 +00:00
|
|
|
/* tag ATA_MAX_QUEUE - 1 is reserved for internal commands */
|
2006-05-15 12:03:48 +00:00
|
|
|
ATA_MAX_QUEUE = 32,
|
2006-05-15 11:58:02 +00:00
|
|
|
ATA_TAG_INTERNAL = ATA_MAX_QUEUE - 1,
|
2008-05-19 17:17:51 +00:00
|
|
|
ATA_SHORT_PAUSE = 16,
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-12-12 03:21:52 +00:00
|
|
|
ATAPI_MAX_DRAIN = 16 << 10,
|
|
|
|
|
2008-01-23 15:05:14 +00:00
|
|
|
ATA_ALL_DEVICES = (1 << ATA_MAX_DEVICES) - 1,
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ATA_SHT_EMULATED = 1,
|
|
|
|
ATA_SHT_THIS_ID = -1,
|
2005-10-22 04:19:33 +00:00
|
|
|
ATA_SHT_USE_CLUSTERING = 1,
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-06-30 20:01:32 +00:00
|
|
|
/* struct ata_taskfile flags */
|
|
|
|
ATA_TFLAG_LBA48 = (1 << 0), /* enable 48-bit LBA and "HOB" */
|
|
|
|
ATA_TFLAG_ISADDR = (1 << 1), /* enable r/w to nsect/lba regs */
|
|
|
|
ATA_TFLAG_DEVICE = (1 << 2), /* enable r/w to device reg */
|
|
|
|
ATA_TFLAG_WRITE = (1 << 3), /* data dir: host->dev==1 (write) */
|
|
|
|
ATA_TFLAG_LBA = (1 << 4), /* enable LBA */
|
|
|
|
ATA_TFLAG_FUA = (1 << 5), /* enable FUA */
|
|
|
|
ATA_TFLAG_POLLING = (1 << 6), /* set nIEN to 1 and use polling */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* struct ata_device stuff */
|
2006-04-02 09:51:52 +00:00
|
|
|
ATA_DFLAG_LBA = (1 << 0), /* device supports LBA */
|
|
|
|
ATA_DFLAG_LBA48 = (1 << 1), /* device supports LBA48 */
|
2006-04-02 14:30:40 +00:00
|
|
|
ATA_DFLAG_CDB_INTR = (1 << 2), /* device asserts INTRQ when ready for CDB */
|
2006-05-15 12:03:38 +00:00
|
|
|
ATA_DFLAG_NCQ = (1 << 3), /* device supports NCQ */
|
2006-11-11 11:10:45 +00:00
|
|
|
ATA_DFLAG_FLUSH_EXT = (1 << 4), /* do FLUSH_EXT instead of FLUSH */
|
libata: reimplement ACPI invocation
This patch reimplements ACPI invocation such that, instead of
exporting ACPI details to the rest of libata, ACPI event handlers -
ata_acpi_on_resume() and ata_acpi_on_devcfg() - are used. These two
functions are responsible for determining whether specific ACPI method
is used and when.
On resume, _GTF is scheduled by setting ATA_DFLAG_ACPI_PENDING device
flag. This is done this way to avoid performing the action on wrong
device device (device swapping while suspended).
On every ata_dev_configure(), ata_acpi_on_devcfg() is called, which
performs _SDD and _GTF. _GTF is performed only after resuming and, if
SATA, hardreset as the ACPI spec specifies. As _GTF may contain
arbitrary commands, IDENTIFY page is re-read after _GTF taskfiles are
executed.
If one of ACPI methods fails, ata_acpi_on_devcfg() retries on the
first failure. If it fails again on the second try, ACPI is disabled
on the device. Note that successful configuration clears ACPI failed
status.
With all feature checks moved to the above two functions,
do_drive_set_taskfiles() is trivial and thus collapsed into
ata_acpi_exec_tfs(), which is now static and converted to return the
number of executed taskfiles to be used by ata_acpi_on_resume(). As
failures are handled properly, ata_acpi_push_id() now returns -errno
on errors instead of unconditional zero.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-05-14 18:28:16 +00:00
|
|
|
ATA_DFLAG_ACPI_PENDING = (1 << 5), /* ACPI resume action pending */
|
|
|
|
ATA_DFLAG_ACPI_FAILED = (1 << 6), /* ACPI on devcfg has failed */
|
2007-09-23 04:14:13 +00:00
|
|
|
ATA_DFLAG_AN = (1 << 7), /* AN configured */
|
2017-06-04 12:42:24 +00:00
|
|
|
ATA_DFLAG_TRUSTED = (1 << 8), /* device supports trusted send/recv */
|
2008-02-21 04:25:50 +00:00
|
|
|
ATA_DFLAG_DMADIR = (1 << 10), /* device requires DMADIR */
|
2007-09-11 18:41:59 +00:00
|
|
|
ATA_DFLAG_CFG_MASK = (1 << 12) - 1,
|
2006-04-02 09:51:52 +00:00
|
|
|
|
2007-09-11 18:41:59 +00:00
|
|
|
ATA_DFLAG_PIO = (1 << 12), /* device limited to PIO mode */
|
|
|
|
ATA_DFLAG_NCQ_OFF = (1 << 13), /* device limited to non-NCQ mode */
|
2007-10-25 09:30:36 +00:00
|
|
|
ATA_DFLAG_SLEEPING = (1 << 15), /* device is sleeping */
|
2007-11-27 10:28:58 +00:00
|
|
|
ATA_DFLAG_DUBIOUS_XFER = (1 << 16), /* data transfer not verified */
|
2008-09-21 09:54:08 +00:00
|
|
|
ATA_DFLAG_NO_UNLOAD = (1 << 17), /* device doesn't support unload */
|
2010-04-05 01:33:13 +00:00
|
|
|
ATA_DFLAG_UNLOCK_HPA = (1 << 18), /* unlock HPA */
|
2013-08-25 06:22:50 +00:00
|
|
|
ATA_DFLAG_NCQ_SEND_RECV = (1 << 19), /* device supports NCQ SEND and RECV */
|
2016-10-17 18:27:29 +00:00
|
|
|
ATA_DFLAG_NCQ_PRIO = (1 << 20), /* device supports NCQ priority */
|
2016-10-17 18:27:30 +00:00
|
|
|
ATA_DFLAG_NCQ_PRIO_ENABLE = (1 << 21), /* Priority cmds sent to dev */
|
2007-11-27 10:28:52 +00:00
|
|
|
ATA_DFLAG_INIT_MASK = (1 << 24) - 1,
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-27 10:28:52 +00:00
|
|
|
ATA_DFLAG_DETACH = (1 << 24),
|
|
|
|
ATA_DFLAG_DETACHED = (1 << 25),
|
2006-05-31 09:27:29 +00:00
|
|
|
|
2012-06-25 08:13:08 +00:00
|
|
|
ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */
|
2012-09-07 14:40:01 +00:00
|
|
|
ATA_DFLAG_DEVSLP = (1 << 27), /* device supports Device Sleep */
|
2012-11-26 05:55:25 +00:00
|
|
|
ATA_DFLAG_ACPI_DISABLED = (1 << 28), /* ACPI for the device is disabled */
|
2016-04-04 09:44:03 +00:00
|
|
|
ATA_DFLAG_D_SENSE = (1 << 29), /* Descriptor sense requested */
|
2016-04-25 10:45:56 +00:00
|
|
|
ATA_DFLAG_ZAC = (1 << 30), /* ZAC device */
|
2012-06-25 08:13:08 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
ATA_DEV_UNKNOWN = 0, /* unknown device */
|
|
|
|
ATA_DEV_ATA = 1, /* ATA device */
|
|
|
|
ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */
|
|
|
|
ATA_DEV_ATAPI = 3, /* ATAPI device */
|
|
|
|
ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_DEV_PMP = 5, /* SATA port multiplier */
|
|
|
|
ATA_DEV_PMP_UNSUP = 6, /* SATA port multiplier (unsupported) */
|
|
|
|
ATA_DEV_SEMB = 7, /* SEMB */
|
|
|
|
ATA_DEV_SEMB_UNSUP = 8, /* SEMB (unsupported) */
|
2014-11-05 12:08:21 +00:00
|
|
|
ATA_DEV_ZAC = 9, /* ZAC device */
|
2016-04-25 10:45:51 +00:00
|
|
|
ATA_DEV_ZAC_UNSUP = 10, /* ZAC device (unsupported) */
|
|
|
|
ATA_DEV_NONE = 11, /* no device */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-06 09:36:23 +00:00
|
|
|
/* struct ata_link flags */
|
2008-08-13 11:19:09 +00:00
|
|
|
ATA_LFLAG_NO_HRST = (1 << 1), /* avoid hardreset */
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_LFLAG_NO_SRST = (1 << 2), /* avoid softreset */
|
|
|
|
ATA_LFLAG_ASSUME_ATA = (1 << 3), /* assume ATA class */
|
|
|
|
ATA_LFLAG_ASSUME_SEMB = (1 << 4), /* assume SEMB class */
|
|
|
|
ATA_LFLAG_ASSUME_CLASS = ATA_LFLAG_ASSUME_ATA | ATA_LFLAG_ASSUME_SEMB,
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_LFLAG_NO_RETRY = (1 << 5), /* don't retry this link */
|
2007-09-23 04:14:13 +00:00
|
|
|
ATA_LFLAG_DISABLED = (1 << 6), /* link is disabled */
|
2008-06-03 17:33:55 +00:00
|
|
|
ATA_LFLAG_SW_ACTIVITY = (1 << 7), /* keep activity stats */
|
2010-09-01 15:50:06 +00:00
|
|
|
ATA_LFLAG_NO_LPM = (1 << 8), /* disable LPM on this link */
|
2012-06-22 06:41:41 +00:00
|
|
|
ATA_LFLAG_RST_ONCE = (1 << 9), /* limit recovery to one reset */
|
2015-04-25 17:52:37 +00:00
|
|
|
ATA_LFLAG_CHANGED = (1 << 10), /* LPM state changed on this link */
|
2016-01-08 00:03:33 +00:00
|
|
|
ATA_LFLAG_NO_DB_DELAY = (1 << 11), /* no debounce delay on link resume */
|
2007-08-06 09:36:23 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* struct ata_port flags */
|
2006-04-02 09:51:52 +00:00
|
|
|
ATA_FLAG_SLAVE_POSS = (1 << 0), /* host supports slave dev */
|
2005-04-16 22:20:36 +00:00
|
|
|
/* (doesn't imply presence) */
|
2006-04-02 09:51:52 +00:00
|
|
|
ATA_FLAG_SATA = (1 << 1),
|
2015-12-04 17:12:49 +00:00
|
|
|
ATA_FLAG_NO_LOG_PAGE = (1 << 5), /* do not issue log page read */
|
2006-04-02 09:51:52 +00:00
|
|
|
ATA_FLAG_NO_ATAPI = (1 << 6), /* No ATAPI support */
|
|
|
|
ATA_FLAG_PIO_DMA = (1 << 7), /* PIO cmds via DMA */
|
|
|
|
ATA_FLAG_PIO_LBA48 = (1 << 8), /* Host DMA engine is LBA28 only */
|
2006-05-31 09:27:25 +00:00
|
|
|
ATA_FLAG_PIO_POLLING = (1 << 9), /* use polling PIO if LLD
|
|
|
|
* doesn't handle PIO interrupts */
|
|
|
|
ATA_FLAG_NCQ = (1 << 10), /* host supports NCQ */
|
2009-01-19 19:56:43 +00:00
|
|
|
ATA_FLAG_NO_POWEROFF_SPINDOWN = (1 << 11), /* don't spindown before poweroff */
|
|
|
|
ATA_FLAG_NO_HIBERNATE_SPINDOWN = (1 << 12), /* don't spindown before hibernation */
|
2006-05-31 09:27:25 +00:00
|
|
|
ATA_FLAG_DEBUGMSG = (1 << 13),
|
2009-07-27 01:24:35 +00:00
|
|
|
ATA_FLAG_FPDMA_AA = (1 << 14), /* driver supports Auto-Activate */
|
2007-01-25 10:40:05 +00:00
|
|
|
ATA_FLAG_IGN_SIMPLEX = (1 << 15), /* ignore SIMPLEX */
|
2007-02-07 21:46:00 +00:00
|
|
|
ATA_FLAG_NO_IORDY = (1 << 16), /* controller lacks iordy */
|
2007-05-14 18:28:15 +00:00
|
|
|
ATA_FLAG_ACPI_SATA = (1 << 17), /* need native SATA ACPI layout */
|
2007-08-15 07:57:11 +00:00
|
|
|
ATA_FLAG_AN = (1 << 18), /* controller supports AN */
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_FLAG_PMP = (1 << 19), /* controller supports PMP */
|
2013-08-25 06:22:49 +00:00
|
|
|
ATA_FLAG_FPDMA_AUX = (1 << 20), /* controller supports H2DFIS aux field */
|
2008-06-03 17:33:55 +00:00
|
|
|
ATA_FLAG_EM = (1 << 21), /* driver supports enclosure
|
|
|
|
* management */
|
|
|
|
ATA_FLAG_SW_ACTIVITY = (1 << 22), /* driver supports sw activity
|
|
|
|
* led */
|
2011-03-16 10:14:55 +00:00
|
|
|
ATA_FLAG_NO_DIPM = (1 << 23), /* host not happy with DIPM */
|
2015-04-13 23:42:16 +00:00
|
|
|
ATA_FLAG_SAS_HOST = (1 << 24), /* SAS host */
|
2006-04-02 09:51:52 +00:00
|
|
|
|
2006-06-28 16:29:30 +00:00
|
|
|
/* bits 24:31 of ap->flags are reserved for LLD specific flags */
|
2006-05-15 11:57:58 +00:00
|
|
|
|
2009-04-09 16:31:17 +00:00
|
|
|
|
2006-06-28 16:29:30 +00:00
|
|
|
/* struct ata_port pflags */
|
|
|
|
ATA_PFLAG_EH_PENDING = (1 << 0), /* EH pending */
|
|
|
|
ATA_PFLAG_EH_IN_PROGRESS = (1 << 1), /* EH in progress */
|
|
|
|
ATA_PFLAG_FROZEN = (1 << 2), /* port is frozen */
|
|
|
|
ATA_PFLAG_RECOVERED = (1 << 3), /* recovery action performed */
|
|
|
|
ATA_PFLAG_LOADING = (1 << 4), /* boot/loading probe */
|
|
|
|
ATA_PFLAG_SCSI_HOTPLUG = (1 << 6), /* SCSI hotplug scheduled */
|
2007-05-01 09:50:15 +00:00
|
|
|
ATA_PFLAG_INITIALIZING = (1 << 7), /* being initialized, don't touch */
|
2007-10-09 06:06:10 +00:00
|
|
|
ATA_PFLAG_RESETTING = (1 << 8), /* reset in progress */
|
2008-11-03 11:04:37 +00:00
|
|
|
ATA_PFLAG_UNLOADING = (1 << 9), /* driver is being unloaded */
|
|
|
|
ATA_PFLAG_UNLOADED = (1 << 10), /* driver is unloaded */
|
2006-04-02 09:51:52 +00:00
|
|
|
|
2006-06-28 16:29:30 +00:00
|
|
|
ATA_PFLAG_SUSPENDED = (1 << 17), /* port is suspended (power) */
|
2006-07-03 07:07:27 +00:00
|
|
|
ATA_PFLAG_PM_PENDING = (1 << 18), /* PM operation pending */
|
2007-12-15 06:05:02 +00:00
|
|
|
ATA_PFLAG_INIT_GTM_VALID = (1 << 19), /* initial gtm data valid */
|
2006-04-02 09:51:52 +00:00
|
|
|
|
2009-04-09 16:31:17 +00:00
|
|
|
ATA_PFLAG_PIO32 = (1 << 20), /* 32bit PIO */
|
|
|
|
ATA_PFLAG_PIO32CHANGE = (1 << 21), /* 32bit PIO can be turned on/off */
|
2015-09-30 19:10:25 +00:00
|
|
|
ATA_PFLAG_EXTERNAL = (1 << 22), /* eSATA/external port */
|
2009-04-09 16:31:17 +00:00
|
|
|
|
2006-04-02 09:51:52 +00:00
|
|
|
/* struct ata_queued_cmd flags */
|
|
|
|
ATA_QCFLAG_ACTIVE = (1 << 0), /* cmd not yet ack'd to scsi lyer */
|
2007-12-05 07:43:09 +00:00
|
|
|
ATA_QCFLAG_DMAMAP = (1 << 1), /* SG table is DMA mapped */
|
2006-04-02 09:51:53 +00:00
|
|
|
ATA_QCFLAG_IO = (1 << 3), /* standard IO command */
|
2006-05-15 11:57:40 +00:00
|
|
|
ATA_QCFLAG_RESULT_TF = (1 << 4), /* result TF requested */
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */
|
2007-10-26 07:19:26 +00:00
|
|
|
ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */
|
2008-03-27 10:14:24 +00:00
|
|
|
ATA_QCFLAG_RETRY = (1 << 7), /* retry after failure */
|
2006-05-15 11:57:40 +00:00
|
|
|
|
2006-05-15 11:57:58 +00:00
|
|
|
ATA_QCFLAG_FAILED = (1 << 16), /* cmd failed and is owned by EH */
|
|
|
|
ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */
|
|
|
|
ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-03-27 17:42:40 +00:00
|
|
|
/* host set flags */
|
2006-08-24 07:19:22 +00:00
|
|
|
ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */
|
2007-04-17 14:44:06 +00:00
|
|
|
ATA_HOST_STARTED = (1 << 1), /* Host started */
|
2009-01-09 23:54:07 +00:00
|
|
|
ATA_HOST_PARALLEL_SCAN = (1 << 2), /* Ports on this host can be scanned in parallel */
|
2012-05-04 21:15:10 +00:00
|
|
|
ATA_HOST_IGNORE_ATA = (1 << 3), /* Ignore ATA devices on this host. */
|
2006-08-31 04:02:15 +00:00
|
|
|
|
2007-07-10 06:55:43 +00:00
|
|
|
/* bits 24:31 of host->flags are reserved for LLD specific flags */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* various lengths of time */
|
2008-05-19 17:17:51 +00:00
|
|
|
ATA_TMOUT_BOOT = 30000, /* heuristic */
|
|
|
|
ATA_TMOUT_BOOT_QUICK = 7000, /* heuristic */
|
|
|
|
ATA_TMOUT_INTERNAL_QUICK = 5000,
|
2008-09-21 09:54:08 +00:00
|
|
|
ATA_TMOUT_MAX_PARK = 30000,
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-04-09 10:46:38 +00:00
|
|
|
/*
|
|
|
|
* GoVault needs 2s and iVDR disk HHD424020F7SV00 800ms. 2s
|
|
|
|
* is too much without parallel probing. Use 2s if parallel
|
|
|
|
* probing is available, 800ms otherwise.
|
2007-10-16 21:21:24 +00:00
|
|
|
*/
|
2010-04-09 10:46:38 +00:00
|
|
|
ATA_TMOUT_FF_WAIT_LONG = 2000,
|
|
|
|
ATA_TMOUT_FF_WAIT = 800,
|
2007-10-16 21:21:24 +00:00
|
|
|
|
2008-04-07 13:47:19 +00:00
|
|
|
/* Spec mandates to wait for ">= 2ms" before checking status
|
|
|
|
* after reset. We wait 150ms, because that was the magic
|
|
|
|
* delay used for ATAPI devices in Hale Landis's ATADRVR, for
|
|
|
|
* the period of time between when the ATA command register is
|
|
|
|
* written, and then status is checked. Because waiting for
|
|
|
|
* "a while" before checking status is fine, post SRST, we
|
|
|
|
* perform this magic delay here as well.
|
|
|
|
*
|
|
|
|
* Old drivers/ide uses the 2mS rule and then waits for ready.
|
|
|
|
*/
|
2008-05-19 17:17:51 +00:00
|
|
|
ATA_WAIT_AFTER_RESET = 150,
|
2008-04-07 13:47:19 +00:00
|
|
|
|
2008-04-07 13:47:19 +00:00
|
|
|
/* If PMP is supported, we have to do follow-up SRST. As some
|
|
|
|
* PMPs don't send D2H Reg FIS after hardreset, LLDs are
|
|
|
|
* advised to wait only for the following duration before
|
|
|
|
* doing SRST.
|
|
|
|
*/
|
2009-03-04 19:59:46 +00:00
|
|
|
ATA_TMOUT_PMP_SRST_WAIT = 5000,
|
2008-04-07 13:47:19 +00:00
|
|
|
|
2015-04-25 17:52:37 +00:00
|
|
|
/* When the LPM policy is set to ATA_LPM_MAX_POWER, there might
|
|
|
|
* be a spurious PHY event, so ignore the first PHY event that
|
|
|
|
* occurs within 10s after the policy change.
|
|
|
|
*/
|
|
|
|
ATA_TMOUT_SPURIOUS_PHY = 10000,
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* ATA bus states */
|
|
|
|
BUS_UNKNOWN = 0,
|
|
|
|
BUS_DMA = 1,
|
|
|
|
BUS_IDLE = 2,
|
|
|
|
BUS_NOINTR = 3,
|
|
|
|
BUS_NODATA = 4,
|
|
|
|
BUS_TIMER = 5,
|
|
|
|
BUS_PIO = 6,
|
|
|
|
BUS_EDD = 7,
|
|
|
|
BUS_IDENTIFY = 8,
|
|
|
|
BUS_PACKET = 9,
|
|
|
|
|
|
|
|
/* SATA port states */
|
|
|
|
PORT_UNKNOWN = 0,
|
|
|
|
PORT_ENABLED = 1,
|
|
|
|
PORT_DISABLED = 2,
|
|
|
|
|
|
|
|
/* encoding various smaller bitmaps into a single
|
2007-11-27 10:43:42 +00:00
|
|
|
* unsigned long bitmap
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2007-11-27 10:43:40 +00:00
|
|
|
ATA_NR_PIO_MODES = 7,
|
|
|
|
ATA_NR_MWDMA_MODES = 5,
|
|
|
|
ATA_NR_UDMA_MODES = 8,
|
2006-03-05 19:31:56 +00:00
|
|
|
|
|
|
|
ATA_SHIFT_PIO = 0,
|
2007-11-27 10:43:40 +00:00
|
|
|
ATA_SHIFT_MWDMA = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
|
|
|
|
ATA_SHIFT_UDMA = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
|
2016-10-17 18:27:29 +00:00
|
|
|
ATA_SHIFT_PRIO = 6,
|
2007-11-27 10:43:40 +00:00
|
|
|
|
2016-10-17 18:27:29 +00:00
|
|
|
ATA_PRIO_HIGH = 2,
|
2005-10-05 11:13:30 +00:00
|
|
|
/* size of buffer to pad xfers ending on unaligned boundaries */
|
|
|
|
ATA_DMA_PAD_SZ = 4,
|
2006-04-02 09:51:52 +00:00
|
|
|
|
2006-05-15 11:58:19 +00:00
|
|
|
/* ering size */
|
|
|
|
ATA_ERING_SIZE = 32,
|
|
|
|
|
2007-09-23 04:14:12 +00:00
|
|
|
/* return values for ->qc_defer */
|
|
|
|
ATA_DEFER_LINK = 1,
|
|
|
|
ATA_DEFER_PORT = 2,
|
|
|
|
|
2006-05-15 11:58:21 +00:00
|
|
|
/* desc_len for ata_eh_info and context */
|
|
|
|
ATA_EH_DESC_LEN = 80,
|
|
|
|
|
2006-05-15 11:58:17 +00:00
|
|
|
/* reset / recovery action types */
|
|
|
|
ATA_EH_REVALIDATE = (1 << 0),
|
libata: prefer hardreset
When both soft and hard resets are available, libata preferred
softreset till now. The logic behind it was to be softer to devices;
however, this doesn't really help much. Rationales for the change:
* BIOS may freeze lock certain things during boot and softreset can't
unlock those. This by itself is okay but during operation PHY event
or other error conditions can trigger hardreset and the device may
end up with different configuration.
For example, after a hardreset, previously unlockable HPA can be
unlocked resulting in different device size and thus revalidation
failure. Similar condition can occur during or after resume.
* Certain ATAPI devices require hardreset to recover after certain
error conditions. On PATA, this is done by issuing the DEVICE RESET
command. On SATA, COMRESET has equivalent effect. The problem is
that DEVICE RESET needs its own execution protocol.
For SFF controllers with bare TF access, it can be easily
implemented but more advanced controllers (e.g. ahci and sata_sil24)
require specialized implementations. Simply using hardreset solves
the problem nicely.
* COMRESET initialization sequence is the norm in SATA land and many
SATA devices don't work properly if only SRST is used. For example,
some PMPs behave this way and libata works around by always issuing
hardreset if the host supports PMP.
Like the above example, libata has developed a number of mechanisms
aiming to promote softreset to hardreset if softreset is not going
to work. This approach is time consuming and error prone.
Also, note that, dependingon how you read the specs, it could be
argued that PMP fan-out ports require COMRESET to start operation.
In fact, all the PMPs on the market except one don't work properly
if COMRESET is not issued to fan-out ports after PMP reset.
* COMRESET is an integral part of SATA connection and any working
device should be able to handle COMRESET properly. After all, it's
the way to signal hardreset during reboot. This is the most used
and recommended (at least by the ahci spec) method of resetting
devices.
So, this patch makes libata prefer hardreset over softreset by making
the following changes.
* Rename ATA_EH_RESET_MASK to ATA_EH_RESET and use it whereever
ATA_EH_{SOFT|HARD}RESET used to be used. ATA_EH_{SOFT|HARD}RESET is
now only used to tell prereset whether soft or hard reset will be
issued.
* Strip out now unneeded promote-to-hardreset logics from
ata_eh_reset(), ata_std_prereset(), sata_pmp_std_prereset() and
other places.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-01-23 15:05:14 +00:00
|
|
|
ATA_EH_SOFTRESET = (1 << 1), /* meaningful only in ->prereset */
|
|
|
|
ATA_EH_HARDRESET = (1 << 2), /* meaningful only in ->prereset */
|
|
|
|
ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
|
2007-09-23 04:14:13 +00:00
|
|
|
ATA_EH_ENABLE_LINK = (1 << 3),
|
2008-09-21 09:54:08 +00:00
|
|
|
ATA_EH_PARK = (1 << 5), /* unload heads and stop I/O */
|
2006-05-15 11:58:17 +00:00
|
|
|
|
2008-09-21 09:54:08 +00:00
|
|
|
ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_PARK,
|
2008-07-31 08:02:42 +00:00
|
|
|
ATA_EH_ALL_ACTIONS = ATA_EH_REVALIDATE | ATA_EH_RESET |
|
2010-09-01 15:50:06 +00:00
|
|
|
ATA_EH_ENABLE_LINK,
|
2006-05-15 11:58:17 +00:00
|
|
|
|
2006-05-15 11:58:21 +00:00
|
|
|
/* ata_eh_info->flags */
|
2006-05-31 09:27:29 +00:00
|
|
|
ATA_EHI_HOTPLUGGED = (1 << 0), /* could have been hotplugged */
|
2006-07-03 07:07:26 +00:00
|
|
|
ATA_EHI_NO_AUTOPSY = (1 << 2), /* no autopsy */
|
|
|
|
ATA_EHI_QUIET = (1 << 3), /* be quiet */
|
2010-09-07 12:05:31 +00:00
|
|
|
ATA_EHI_NO_RECOVERY = (1 << 4), /* no recovery */
|
2006-05-31 09:27:29 +00:00
|
|
|
|
2007-04-22 17:41:05 +00:00
|
|
|
ATA_EHI_DID_SOFTRESET = (1 << 16), /* already soft-reset this port */
|
|
|
|
ATA_EHI_DID_HARDRESET = (1 << 17), /* already soft-reset this port */
|
|
|
|
ATA_EHI_PRINTINFO = (1 << 18), /* print configuration info */
|
|
|
|
ATA_EHI_SETMODE = (1 << 19), /* configure transfer mode */
|
2010-10-16 13:19:18 +00:00
|
|
|
ATA_EHI_POST_SETMODE = (1 << 20), /* revalidating after setmode */
|
2006-05-15 11:58:21 +00:00
|
|
|
|
2007-04-22 17:41:05 +00:00
|
|
|
ATA_EHI_DID_RESET = ATA_EHI_DID_SOFTRESET | ATA_EHI_DID_HARDRESET,
|
2006-07-10 14:18:46 +00:00
|
|
|
|
2008-10-21 05:26:39 +00:00
|
|
|
/* mask of flags to transfer *to* the slave link */
|
|
|
|
ATA_EHI_TO_SLAVE_MASK = ATA_EHI_NO_AUTOPSY | ATA_EHI_QUIET,
|
|
|
|
|
2007-08-18 04:28:49 +00:00
|
|
|
/* max tries if error condition is still set after ->error_handler */
|
|
|
|
ATA_EH_MAX_TRIES = 5,
|
2006-05-15 11:58:12 +00:00
|
|
|
|
2010-01-11 02:14:44 +00:00
|
|
|
/* sometimes resuming a link requires several retries */
|
|
|
|
ATA_LINK_RESUME_TRIES = 5,
|
|
|
|
|
2006-04-02 08:54:46 +00:00
|
|
|
/* how hard are we gonna try to probe/recover devices */
|
|
|
|
ATA_PROBE_MAX_TRIES = 3,
|
2006-05-15 11:58:22 +00:00
|
|
|
ATA_EH_DEV_TRIES = 3,
|
2007-09-23 04:14:12 +00:00
|
|
|
ATA_EH_PMP_TRIES = 5,
|
|
|
|
ATA_EH_PMP_LINK_TRIES = 3,
|
|
|
|
|
2008-05-18 16:15:10 +00:00
|
|
|
SATA_PMP_RW_TIMEOUT = 3000, /* PMP read/write timeout */
|
2006-05-31 09:27:48 +00:00
|
|
|
|
2008-05-19 17:17:54 +00:00
|
|
|
/* This should match the actual table size of
|
|
|
|
* ata_eh_cmd_timeout_table in libata-eh.c.
|
|
|
|
*/
|
2009-11-19 06:36:45 +00:00
|
|
|
ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 6,
|
2008-05-19 17:17:54 +00:00
|
|
|
|
2006-09-12 15:55:12 +00:00
|
|
|
/* Horkage types. May be set by libata or controller on drives
|
2011-03-31 01:57:33 +00:00
|
|
|
(some horkage may be drive/controller pair dependent */
|
2006-09-12 15:55:12 +00:00
|
|
|
|
|
|
|
ATA_HORKAGE_DIAGNOSTIC = (1 << 0), /* Failed boot diag */
|
2006-10-28 02:08:46 +00:00
|
|
|
ATA_HORKAGE_NODMA = (1 << 1), /* DMA problems */
|
|
|
|
ATA_HORKAGE_NONCQ = (1 << 2), /* Don't use NCQ */
|
2007-04-02 03:34:15 +00:00
|
|
|
ATA_HORKAGE_MAX_SEC_128 = (1 << 3), /* Limit max sects to 128 */
|
2007-08-29 02:58:33 +00:00
|
|
|
ATA_HORKAGE_BROKEN_HPA = (1 << 4), /* Broken HPA */
|
2008-05-18 16:15:14 +00:00
|
|
|
ATA_HORKAGE_DISABLE = (1 << 5), /* Disable it */
|
2007-09-29 08:06:48 +00:00
|
|
|
ATA_HORKAGE_HPA_SIZE = (1 << 6), /* native size off by one */
|
2007-11-05 22:58:58 +00:00
|
|
|
ATA_HORKAGE_IVB = (1 << 8), /* cbl det validity bit bugs */
|
2007-11-15 01:35:46 +00:00
|
|
|
ATA_HORKAGE_STUCK_ERR = (1 << 9), /* stuck ERR on next PACKET */
|
2008-08-27 13:23:18 +00:00
|
|
|
ATA_HORKAGE_BRIDGE_OK = (1 << 10), /* no bridge limits */
|
2008-11-03 10:01:09 +00:00
|
|
|
ATA_HORKAGE_ATAPI_MOD16_DMA = (1 << 11), /* use ATAPI DMA for commands
|
|
|
|
not multiple of 16 bytes */
|
2009-01-26 10:06:57 +00:00
|
|
|
ATA_HORKAGE_FIRMWARE_WARN = (1 << 12), /* firmware update warning */
|
2009-01-29 11:31:36 +00:00
|
|
|
ATA_HORKAGE_1_5_GBPS = (1 << 13), /* force 1.5 Gbps */
|
2009-07-09 00:27:50 +00:00
|
|
|
ATA_HORKAGE_NOSETXFER = (1 << 14), /* skip SETXFER, SATA only */
|
2009-07-27 01:24:35 +00:00
|
|
|
ATA_HORKAGE_BROKEN_FPDMA_AA = (1 << 15), /* skip AA */
|
2010-05-23 10:59:11 +00:00
|
|
|
ATA_HORKAGE_DUMP_ID = (1 << 16), /* dump IDENTIFY data */
|
2013-03-18 02:30:44 +00:00
|
|
|
ATA_HORKAGE_MAX_SEC_LBA48 = (1 << 17), /* Set max sects to 65535 */
|
2013-05-21 20:30:58 +00:00
|
|
|
ATA_HORKAGE_ATAPI_DMADIR = (1 << 18), /* device requires dmadir */
|
2013-12-17 02:15:53 +00:00
|
|
|
ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19), /* don't use queued TRIM */
|
2014-01-16 14:47:17 +00:00
|
|
|
ATA_HORKAGE_NOLPM = (1 << 20), /* don't use LPM */
|
|
|
|
ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21), /* some WDs have broken LPM */
|
2015-01-08 15:34:27 +00:00
|
|
|
ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
|
2017-07-10 05:45:20 +00:00
|
|
|
ATA_HORKAGE_NO_DMA_LOG = (1 << 23), /* don't use DMA for log read */
|
2015-07-15 11:54:36 +00:00
|
|
|
ATA_HORKAGE_NOTRIM = (1 << 24), /* don't use TRIM */
|
2015-07-13 16:48:23 +00:00
|
|
|
ATA_HORKAGE_MAX_SEC_1024 = (1 << 25), /* Limit max sects to 1024 */
|
2007-10-02 16:38:26 +00:00
|
|
|
|
2007-10-19 10:42:56 +00:00
|
|
|
/* DMA mask for user DMA control: User visible values; DO NOT
|
2007-10-02 16:38:26 +00:00
|
|
|
renumber */
|
|
|
|
ATA_DMA_MASK_ATA = (1 << 0), /* DMA on ATA Disk */
|
|
|
|
ATA_DMA_MASK_ATAPI = (1 << 1), /* DMA on ATAPI */
|
|
|
|
ATA_DMA_MASK_CFA = (1 << 2), /* DMA on CF Card */
|
2007-12-05 07:43:06 +00:00
|
|
|
|
|
|
|
/* ATAPI command types */
|
|
|
|
ATAPI_READ = 0, /* READs */
|
|
|
|
ATAPI_WRITE = 1, /* WRITEs */
|
|
|
|
ATAPI_READ_CD = 2, /* READ CD [MSF] */
|
2008-04-02 08:35:19 +00:00
|
|
|
ATAPI_PASS_THRU = 3, /* SAT pass-thru */
|
|
|
|
ATAPI_MISC = 4, /* the rest */
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
|
|
|
|
/* Timing constants */
|
|
|
|
ATA_TIMING_SETUP = (1 << 0),
|
|
|
|
ATA_TIMING_ACT8B = (1 << 1),
|
|
|
|
ATA_TIMING_REC8B = (1 << 2),
|
|
|
|
ATA_TIMING_CYC8B = (1 << 3),
|
|
|
|
ATA_TIMING_8BIT = ATA_TIMING_ACT8B | ATA_TIMING_REC8B |
|
|
|
|
ATA_TIMING_CYC8B,
|
|
|
|
ATA_TIMING_ACTIVE = (1 << 4),
|
|
|
|
ATA_TIMING_RECOVER = (1 << 5),
|
2009-01-16 01:45:31 +00:00
|
|
|
ATA_TIMING_DMACK_HOLD = (1 << 6),
|
|
|
|
ATA_TIMING_CYCLE = (1 << 7),
|
|
|
|
ATA_TIMING_UDMA = (1 << 8),
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
ATA_TIMING_ALL = ATA_TIMING_SETUP | ATA_TIMING_ACT8B |
|
|
|
|
ATA_TIMING_REC8B | ATA_TIMING_CYC8B |
|
|
|
|
ATA_TIMING_ACTIVE | ATA_TIMING_RECOVER |
|
2009-01-16 01:45:31 +00:00
|
|
|
ATA_TIMING_DMACK_HOLD | ATA_TIMING_CYCLE |
|
|
|
|
ATA_TIMING_UDMA,
|
2009-09-15 19:16:04 +00:00
|
|
|
|
|
|
|
/* ACPI constants */
|
|
|
|
ATA_ACPI_FILTER_SETXFER = 1 << 0,
|
|
|
|
ATA_ACPI_FILTER_LOCK = 1 << 1,
|
|
|
|
ATA_ACPI_FILTER_DIPM = 1 << 2,
|
2009-09-15 19:17:02 +00:00
|
|
|
ATA_ACPI_FILTER_FPDMA_OFFSET = 1 << 3, /* FPDMA non-zero offset */
|
|
|
|
ATA_ACPI_FILTER_FPDMA_AA = 1 << 4, /* FPDMA auto activate */
|
2009-09-15 19:16:04 +00:00
|
|
|
|
|
|
|
ATA_ACPI_FILTER_DEFAULT = ATA_ACPI_FILTER_SETXFER |
|
|
|
|
ATA_ACPI_FILTER_LOCK |
|
|
|
|
ATA_ACPI_FILTER_DIPM,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-11-27 10:43:42 +00:00
|
|
|
enum ata_xfer_mask {
|
|
|
|
ATA_MASK_PIO = ((1LU << ATA_NR_PIO_MODES) - 1)
|
|
|
|
<< ATA_SHIFT_PIO,
|
|
|
|
ATA_MASK_MWDMA = ((1LU << ATA_NR_MWDMA_MODES) - 1)
|
|
|
|
<< ATA_SHIFT_MWDMA,
|
|
|
|
ATA_MASK_UDMA = ((1LU << ATA_NR_UDMA_MODES) - 1)
|
|
|
|
<< ATA_SHIFT_UDMA,
|
|
|
|
};
|
|
|
|
|
2005-09-27 09:36:35 +00:00
|
|
|
enum hsm_task_states {
|
2005-09-30 11:07:39 +00:00
|
|
|
HSM_ST_IDLE, /* no command on going */
|
2007-04-02 03:28:52 +00:00
|
|
|
HSM_ST_FIRST, /* (waiting the device to)
|
|
|
|
write CDB or first data block */
|
2005-09-30 11:07:39 +00:00
|
|
|
HSM_ST, /* (waiting the device to) transfer data */
|
|
|
|
HSM_ST_LAST, /* (waiting the device to) complete command */
|
|
|
|
HSM_ST_ERR, /* error */
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2005-10-30 09:44:42 +00:00
|
|
|
enum ata_completion_errors {
|
2006-01-23 04:09:36 +00:00
|
|
|
AC_ERR_DEV = (1 << 0), /* device reported error */
|
|
|
|
AC_ERR_HSM = (1 << 1), /* host state machine violation */
|
|
|
|
AC_ERR_TIMEOUT = (1 << 2), /* timeout */
|
|
|
|
AC_ERR_MEDIA = (1 << 3), /* media error */
|
|
|
|
AC_ERR_ATA_BUS = (1 << 4), /* ATA bus error */
|
|
|
|
AC_ERR_HOST_BUS = (1 << 5), /* host bus error */
|
|
|
|
AC_ERR_SYSTEM = (1 << 6), /* system error */
|
|
|
|
AC_ERR_INVALID = (1 << 7), /* invalid argument */
|
|
|
|
AC_ERR_OTHER = (1 << 8), /* unknown */
|
2006-11-10 09:08:10 +00:00
|
|
|
AC_ERR_NODEV_HINT = (1 << 9), /* polling device detection hint */
|
2007-07-16 05:29:40 +00:00
|
|
|
AC_ERR_NCQ = (1 << 10), /* marker for offending NCQ qc */
|
2005-10-30 09:44:42 +00:00
|
|
|
};
|
|
|
|
|
2010-09-01 15:50:04 +00:00
|
|
|
/*
|
|
|
|
* Link power management policy: If you alter this, you also need to
|
|
|
|
* alter libata-scsi.c (for the ascii descriptions)
|
|
|
|
*/
|
|
|
|
enum ata_lpm_policy {
|
|
|
|
ATA_LPM_UNKNOWN,
|
|
|
|
ATA_LPM_MAX_POWER,
|
|
|
|
ATA_LPM_MED_POWER,
|
2017-09-14 10:35:36 +00:00
|
|
|
ATA_LPM_MED_POWER_WITH_DIPM, /* Med power + DIPM as win IRST does */
|
2010-09-01 15:50:04 +00:00
|
|
|
ATA_LPM_MIN_POWER,
|
|
|
|
};
|
|
|
|
|
2010-09-01 15:50:06 +00:00
|
|
|
enum ata_lpm_hints {
|
|
|
|
ATA_LPM_EMPTY = (1 << 0), /* port empty/probing */
|
|
|
|
ATA_LPM_HIPM = (1 << 1), /* may use HIPM */
|
2016-01-11 21:22:26 +00:00
|
|
|
ATA_LPM_WAKE_ONLY = (1 << 2), /* only wake up link */
|
2010-09-01 15:50:06 +00:00
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* forward declarations */
|
|
|
|
struct scsi_device;
|
|
|
|
struct ata_port_operations;
|
|
|
|
struct ata_port;
|
2007-08-06 09:36:23 +00:00
|
|
|
struct ata_link;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_queued_cmd;
|
|
|
|
|
|
|
|
/* typedefs */
|
2006-01-23 04:09:36 +00:00
|
|
|
typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc);
|
2007-08-06 09:36:23 +00:00
|
|
|
typedef int (*ata_prereset_fn_t)(struct ata_link *link, unsigned long deadline);
|
|
|
|
typedef int (*ata_reset_fn_t)(struct ata_link *link, unsigned int *classes,
|
libata: add deadline support to prereset and reset methods
Add @deadline to prereset and reset methods and make them honor it.
ata_wait_ready() which directly takes @deadline is implemented to be
used as the wait function. This patch is in preparation for EH timing
improvements.
* ata_wait_ready() never does busy sleep. It's only used from EH and
no wait in EH is that urgent. This function also prints 'be
patient' message automatically after 5 secs of waiting if more than
3 secs is remaining till deadline.
* ata_bus_post_reset() now fails with error code if any of its wait
fails. This is important because earlier reset tries will have
shorter timeout than the spec requires. If a device fails to
respond before the short timeout, reset should be retried with
longer timeout rather than silently ignoring the device.
There are three behavior differences.
1. Timeout is applied to both devices at once, not separately. This
is more consistent with what the spec says.
2. When a device passes devchk but fails to become ready before
deadline. Previouly, post_reset would just succeed and let
device classification remove the device. New code fails the
reset thus causing reset retry. After a few times, EH will give
up disabling the port.
3. When slave device passes devchk but fails to become accessible
(TF-wise) after reset. Original code disables dev1 after 30s
timeout and continues as if the device doesn't exist, while the
patched code fails reset. When this happens, new code fails
reset on whole port rather than proceeding with only the primary
device.
If the failing device is suffering transient problems, new code
retries reset which is a better behavior. If the failing device is
actually broken, the net effect is identical to it, but not to the
other device sharing the channel. In the previous code, reset would
have succeeded after 30s thus detecting the working one. In the new
code, reset fails and whole port gets disabled. IMO, it's a
pathological case anyway (broken device sharing bus with working
one) and doesn't really matter.
* ata_bus_softreset() is changed to return error code from
ata_bus_post_reset(). It used to return 0 unconditionally.
* Spin up waiting is to be removed and not converted to honor
deadline.
* To be on the safe side, deadline is set to 40s for the time being.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2007-02-02 07:50:52 +00:00
|
|
|
unsigned long deadline);
|
2007-08-06 09:36:23 +00:00
|
|
|
typedef void (*ata_postreset_fn_t)(struct ata_link *link, unsigned int *classes);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-21 23:13:36 +00:00
|
|
|
extern struct device_attribute dev_attr_link_power_management_policy;
|
2008-09-21 09:54:08 +00:00
|
|
|
extern struct device_attribute dev_attr_unload_heads;
|
2016-10-17 18:27:30 +00:00
|
|
|
extern struct device_attribute dev_attr_ncq_prio_enable;
|
2008-06-03 17:33:55 +00:00
|
|
|
extern struct device_attribute dev_attr_em_message_type;
|
|
|
|
extern struct device_attribute dev_attr_em_message;
|
|
|
|
extern struct device_attribute dev_attr_sw_activity;
|
|
|
|
|
|
|
|
enum sw_activity {
|
|
|
|
OFF,
|
|
|
|
BLINK_ON,
|
|
|
|
BLINK_OFF,
|
|
|
|
};
|
2007-10-25 04:58:59 +00:00
|
|
|
|
2013-06-30 20:01:32 +00:00
|
|
|
struct ata_taskfile {
|
|
|
|
unsigned long flags; /* ATA_TFLAG_xxx */
|
|
|
|
u8 protocol; /* ATA_PROT_xxx */
|
|
|
|
|
|
|
|
u8 ctl; /* control reg */
|
|
|
|
|
|
|
|
u8 hob_feature; /* additional data */
|
|
|
|
u8 hob_nsect; /* to support LBA48 */
|
|
|
|
u8 hob_lbal;
|
|
|
|
u8 hob_lbam;
|
|
|
|
u8 hob_lbah;
|
|
|
|
|
|
|
|
u8 feature;
|
|
|
|
u8 nsect;
|
|
|
|
u8 lbal;
|
|
|
|
u8 lbam;
|
|
|
|
u8 lbah;
|
|
|
|
|
|
|
|
u8 device;
|
|
|
|
|
|
|
|
u8 command; /* IO operation */
|
2013-08-25 06:22:48 +00:00
|
|
|
|
|
|
|
u32 auxiliary; /* auxiliary field */
|
|
|
|
/* from SATA 3.1 and */
|
|
|
|
/* ATA-8 ACS-3 */
|
2013-06-30 20:01:32 +00:00
|
|
|
};
|
|
|
|
|
2008-04-07 13:47:21 +00:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_ioports {
|
2007-02-01 06:06:36 +00:00
|
|
|
void __iomem *cmd_addr;
|
|
|
|
void __iomem *data_addr;
|
|
|
|
void __iomem *error_addr;
|
|
|
|
void __iomem *feature_addr;
|
|
|
|
void __iomem *nsect_addr;
|
|
|
|
void __iomem *lbal_addr;
|
|
|
|
void __iomem *lbam_addr;
|
|
|
|
void __iomem *lbah_addr;
|
|
|
|
void __iomem *device_addr;
|
|
|
|
void __iomem *status_addr;
|
|
|
|
void __iomem *command_addr;
|
|
|
|
void __iomem *altstatus_addr;
|
|
|
|
void __iomem *ctl_addr;
|
2010-05-19 20:10:24 +00:00
|
|
|
#ifdef CONFIG_ATA_BMDMA
|
2007-02-01 06:06:36 +00:00
|
|
|
void __iomem *bmdma_addr;
|
2010-05-19 20:10:24 +00:00
|
|
|
#endif /* CONFIG_ATA_BMDMA */
|
2007-02-01 06:06:36 +00:00
|
|
|
void __iomem *scr_addr;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2008-04-07 13:47:21 +00:00
|
|
|
#endif /* CONFIG_ATA_SFF */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-08-24 07:19:22 +00:00
|
|
|
struct ata_host {
|
2005-04-16 22:20:36 +00:00
|
|
|
spinlock_t lock;
|
|
|
|
struct device *dev;
|
2007-02-01 06:06:36 +00:00
|
|
|
void __iomem * const *iomap;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int n_ports;
|
2014-07-23 13:05:27 +00:00
|
|
|
unsigned int n_tags; /* nr of NCQ tags */
|
2005-04-16 22:20:36 +00:00
|
|
|
void *private_data;
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
struct ata_port_operations *ops;
|
2006-03-27 17:58:20 +00:00
|
|
|
unsigned long flags;
|
libata: implement cross-port EH exclusion
In libata, the non-EH code paths should always take and release
ap->lock explicitly when accessing hardware or shared data structures.
However, once EH is active, it's assumed that the port is owned by EH
and EH methods don't explicitly take ap->lock unless race from irq
handler or other code paths are expected. However, libata EH didn't
guarantee exclusion among EHs for ports of the same host. IOW,
multiple EHs may execute in parallel on multiple ports of the same
controller.
In many cases, especially in SATA, the ports are completely
independent of each other and this doesn't cause problems; however,
there are cases where different ports share the same resource, which
lead to obscure timing related bugs such as the one fixed by commit
213373cf (ata_piix: fix locking around SIDPR access).
This patch implements exclusion among EHs of the same host. When EH
begins, it acquires per-host EH ownership by calling ata_eh_acquire().
When EH finishes, the ownership is released by calling
ata_eh_release(). EH ownership is also released whenever the EH
thread goes to sleep from ata_msleep() or explicitly and reacquired
after waking up.
This ensures that while EH is actively accessing the hardware, it has
exclusive access to it while allowing EHs to interleave and progress
in parallel as they hit waiting stages, which dominate the time spent
in EH. This achieves cross-port EH exclusion without pervasive and
fragile changes while still allowing parallel EH for the most part.
This was first reported by yuanding02@gmail.com more than three years
ago in the following bugzilla. :-)
https://bugzilla.kernel.org/show_bug.cgi?id=8223
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Reported-by: yuanding02@gmail.com
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2010-09-06 15:57:14 +00:00
|
|
|
|
|
|
|
struct mutex eh_mutex;
|
|
|
|
struct task_struct *eh_owner;
|
|
|
|
|
2007-03-01 17:36:46 +00:00
|
|
|
struct ata_port *simplex_claimed; /* channel owning the DMA */
|
2006-06-12 14:05:38 +00:00
|
|
|
struct ata_port *ports[0];
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_queued_cmd {
|
|
|
|
struct ata_port *ap;
|
|
|
|
struct ata_device *dev;
|
|
|
|
|
|
|
|
struct scsi_cmnd *scsicmd;
|
|
|
|
void (*scsidone)(struct scsi_cmnd *);
|
|
|
|
|
|
|
|
struct ata_taskfile tf;
|
|
|
|
u8 cdb[ATAPI_CDB_LEN];
|
|
|
|
|
|
|
|
unsigned long flags; /* ATA_QCFLAG_xxx */
|
|
|
|
unsigned int tag;
|
|
|
|
unsigned int n_elem;
|
2009-02-27 08:35:43 +00:00
|
|
|
unsigned int orig_n_elem;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
int dma_dir;
|
|
|
|
|
2007-03-16 14:22:26 +00:00
|
|
|
unsigned int sect_size;
|
2005-10-05 11:13:30 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int nbytes;
|
2008-03-18 08:47:43 +00:00
|
|
|
unsigned int extrabytes;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int curbytes;
|
|
|
|
|
|
|
|
struct scatterlist sgent;
|
|
|
|
|
2007-12-05 07:43:11 +00:00
|
|
|
struct scatterlist *sg;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-09-10 11:19:43 +00:00
|
|
|
struct scatterlist *cursg;
|
|
|
|
unsigned int cursg_ofs;
|
|
|
|
|
2005-12-05 07:38:02 +00:00
|
|
|
unsigned int err_mask;
|
2006-05-15 11:57:40 +00:00
|
|
|
struct ata_taskfile result_tf;
|
2005-04-16 22:20:36 +00:00
|
|
|
ata_qc_cb_t complete_fn;
|
|
|
|
|
|
|
|
void *private_data;
|
2007-01-30 09:18:41 +00:00
|
|
|
void *lldd_task;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2006-08-24 07:19:22 +00:00
|
|
|
struct ata_port_stats {
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long unhandled_irq;
|
|
|
|
unsigned long idle_irq;
|
|
|
|
unsigned long rw_reqbuf;
|
|
|
|
};
|
|
|
|
|
2006-05-15 11:58:19 +00:00
|
|
|
struct ata_ering_entry {
|
2007-11-27 10:28:56 +00:00
|
|
|
unsigned int eflags;
|
2006-05-15 11:58:19 +00:00
|
|
|
unsigned int err_mask;
|
|
|
|
u64 timestamp;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_ering {
|
|
|
|
int cursor;
|
|
|
|
struct ata_ering_entry ring[ATA_ERING_SIZE];
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_device {
|
2007-08-06 09:36:22 +00:00
|
|
|
struct ata_link *link;
|
2006-05-31 09:27:32 +00:00
|
|
|
unsigned int devno; /* 0 or 1 */
|
2007-07-05 04:31:27 +00:00
|
|
|
unsigned int horkage; /* List of broken features */
|
2008-09-22 21:47:13 +00:00
|
|
|
unsigned long flags; /* ATA_DFLAG_xxx */
|
2006-05-31 09:27:40 +00:00
|
|
|
struct scsi_device *sdev; /* attached SCSI device */
|
2009-11-25 17:12:48 +00:00
|
|
|
void *private_data;
|
2007-05-14 18:28:16 +00:00
|
|
|
#ifdef CONFIG_ATA_ACPI
|
2007-12-15 06:05:03 +00:00
|
|
|
union acpi_object *gtf_cache;
|
2009-09-15 19:17:28 +00:00
|
|
|
unsigned int gtf_filter;
|
2013-01-15 09:20:58 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_SATA_ZPODD
|
|
|
|
void *zpodd;
|
2007-05-14 18:28:16 +00:00
|
|
|
#endif
|
2010-05-25 19:31:38 +00:00
|
|
|
struct device tdev;
|
2009-01-29 11:31:32 +00:00
|
|
|
/* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
|
2006-05-31 09:27:32 +00:00
|
|
|
u64 n_sectors; /* size of device, if ATA */
|
2009-07-15 08:11:41 +00:00
|
|
|
u64 n_native_sectors; /* native size, if ATA */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int class; /* ATA_DEV_xxx */
|
2008-09-21 09:54:08 +00:00
|
|
|
unsigned long unpark_deadline;
|
2007-09-23 04:14:12 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
u8 pio_mode;
|
|
|
|
u8 dma_mode;
|
|
|
|
u8 xfer_mode;
|
|
|
|
unsigned int xfer_shift; /* ATA_SHIFT_xxx */
|
|
|
|
|
2005-10-12 07:06:27 +00:00
|
|
|
unsigned int multi_count; /* sectors count for
|
|
|
|
READ/WRITE MULTIPLE */
|
2006-02-12 14:32:59 +00:00
|
|
|
unsigned int max_sectors; /* per-device max sectors */
|
2006-02-12 14:32:58 +00:00
|
|
|
unsigned int cdb_len;
|
2005-05-12 19:29:42 +00:00
|
|
|
|
2006-03-24 05:07:50 +00:00
|
|
|
/* per-dev xfer mask */
|
2007-11-27 10:43:42 +00:00
|
|
|
unsigned long pio_mask;
|
|
|
|
unsigned long mwdma_mask;
|
|
|
|
unsigned long udma_mask;
|
2006-03-24 05:07:50 +00:00
|
|
|
|
2005-05-12 19:29:42 +00:00
|
|
|
/* for CHS addressing */
|
|
|
|
u16 cylinders; /* Number of cylinders */
|
|
|
|
u16 heads; /* Number of heads */
|
|
|
|
u16 sectors; /* Number of sectors per track */
|
2006-05-15 11:58:19 +00:00
|
|
|
|
2008-04-29 21:47:34 +00:00
|
|
|
union {
|
|
|
|
u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
|
|
|
|
u32 gscr[SATA_PMP_GSCR_DWORDS]; /* PMP GSCR block */
|
2016-02-24 15:16:43 +00:00
|
|
|
} ____cacheline_aligned;
|
2009-01-29 11:31:32 +00:00
|
|
|
|
2012-12-17 15:18:59 +00:00
|
|
|
/* DEVSLP Timing Variables from Identify Device Data Log */
|
|
|
|
u8 devslp_timing[ATA_LOG_DEVSLP_SIZE];
|
2012-09-07 14:40:01 +00:00
|
|
|
|
2013-08-25 06:22:50 +00:00
|
|
|
/* NCQ send and receive log subcommand support */
|
|
|
|
u8 ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_SIZE];
|
2016-04-25 10:45:54 +00:00
|
|
|
u8 ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_SIZE];
|
2013-08-25 06:22:50 +00:00
|
|
|
|
2016-04-25 10:45:56 +00:00
|
|
|
/* ZAC zone configuration */
|
|
|
|
u32 zac_zoned_cap;
|
|
|
|
u32 zac_zones_optimal_open;
|
|
|
|
u32 zac_zones_optimal_nonseq;
|
|
|
|
u32 zac_zones_max_open;
|
|
|
|
|
2009-01-29 11:31:32 +00:00
|
|
|
/* error history */
|
|
|
|
int spdn_cnt;
|
|
|
|
/* ering is CLEAR_END, read comment above CLEAR_END */
|
|
|
|
struct ata_ering ering;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2009-01-29 11:31:32 +00:00
|
|
|
/* Fields between ATA_DEVICE_CLEAR_BEGIN and ATA_DEVICE_CLEAR_END are
|
|
|
|
* cleared to zero on ata_dev_init().
|
2006-05-31 09:27:32 +00:00
|
|
|
*/
|
2009-01-29 11:31:32 +00:00
|
|
|
#define ATA_DEVICE_CLEAR_BEGIN offsetof(struct ata_device, n_sectors)
|
|
|
|
#define ATA_DEVICE_CLEAR_END offsetof(struct ata_device, ering)
|
2006-05-31 09:27:32 +00:00
|
|
|
|
2006-05-15 11:58:21 +00:00
|
|
|
struct ata_eh_info {
|
|
|
|
struct ata_device *dev; /* offending device */
|
|
|
|
u32 serror; /* SError from LLDD */
|
|
|
|
unsigned int err_mask; /* port-wide err_mask */
|
|
|
|
unsigned int action; /* ATA_EH_* action mask */
|
2006-06-19 09:27:23 +00:00
|
|
|
unsigned int dev_action[ATA_MAX_DEVICES]; /* dev EH action */
|
2006-05-15 11:58:21 +00:00
|
|
|
unsigned int flags; /* ATA_EHI_* flags */
|
2006-05-31 09:27:29 +00:00
|
|
|
|
|
|
|
unsigned int probe_mask;
|
|
|
|
|
2006-05-15 11:58:21 +00:00
|
|
|
char desc[ATA_EH_DESC_LEN];
|
|
|
|
int desc_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_eh_context {
|
|
|
|
struct ata_eh_info i;
|
|
|
|
int tries[ATA_MAX_DEVICES];
|
2008-05-19 17:17:54 +00:00
|
|
|
int cmd_timeout_idx[ATA_MAX_DEVICES]
|
|
|
|
[ATA_EH_CMD_TIMEOUT_TABLE_SIZE];
|
2006-05-31 09:27:29 +00:00
|
|
|
unsigned int classes[ATA_MAX_DEVICES];
|
|
|
|
unsigned int did_probe_mask;
|
2008-09-21 09:54:08 +00:00
|
|
|
unsigned int unloaded_mask;
|
2007-11-27 10:28:58 +00:00
|
|
|
unsigned int saved_ncq_enabled;
|
|
|
|
u8 saved_xfer_mode[ATA_MAX_DEVICES];
|
2008-05-19 17:17:52 +00:00
|
|
|
/* timestamp for the last reset attempt or success */
|
|
|
|
unsigned long last_reset;
|
2006-05-15 11:58:21 +00:00
|
|
|
};
|
|
|
|
|
2007-05-14 18:28:16 +00:00
|
|
|
struct ata_acpi_drive
|
|
|
|
{
|
|
|
|
u32 pio;
|
|
|
|
u32 dma;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct ata_acpi_gtm {
|
|
|
|
struct ata_acpi_drive drive[2];
|
|
|
|
u32 flags;
|
|
|
|
} __packed;
|
|
|
|
|
2007-08-06 09:36:22 +00:00
|
|
|
struct ata_link {
|
|
|
|
struct ata_port *ap;
|
2007-08-06 09:36:23 +00:00
|
|
|
int pmp; /* port multiplier port # */
|
2007-08-06 09:36:22 +00:00
|
|
|
|
2010-05-25 19:31:38 +00:00
|
|
|
struct device tdev;
|
2007-08-06 09:36:22 +00:00
|
|
|
unsigned int active_tag; /* active tag on this link */
|
|
|
|
u32 sactive; /* active NCQ commands */
|
|
|
|
|
2007-08-06 09:36:23 +00:00
|
|
|
unsigned int flags; /* ATA_LFLAG_xxx */
|
|
|
|
|
2008-07-31 07:09:34 +00:00
|
|
|
u32 saved_scontrol; /* SControl on probe */
|
2007-08-06 09:36:22 +00:00
|
|
|
unsigned int hw_sata_spd_limit;
|
|
|
|
unsigned int sata_spd_limit;
|
|
|
|
unsigned int sata_spd; /* current SATA PHY speed */
|
2010-09-01 15:50:06 +00:00
|
|
|
enum ata_lpm_policy lpm_policy;
|
2007-08-06 09:36:22 +00:00
|
|
|
|
|
|
|
/* record runtime error info, protected by host_set lock */
|
|
|
|
struct ata_eh_info eh_info;
|
|
|
|
/* EH context */
|
|
|
|
struct ata_eh_context eh_context;
|
|
|
|
|
|
|
|
struct ata_device device[ATA_MAX_DEVICES];
|
2015-04-25 17:52:37 +00:00
|
|
|
|
|
|
|
unsigned long last_lpm_change; /* when last LPM change happened */
|
2007-08-06 09:36:22 +00:00
|
|
|
};
|
2010-05-25 19:31:38 +00:00
|
|
|
#define ATA_LINK_CLEAR_BEGIN offsetof(struct ata_link, active_tag)
|
|
|
|
#define ATA_LINK_CLEAR_END offsetof(struct ata_link, device[0])
|
2007-08-06 09:36:22 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_port {
|
2006-08-24 07:19:22 +00:00
|
|
|
struct Scsi_Host *scsi_host; /* our co-allocated scsi host */
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
struct ata_port_operations *ops;
|
2006-06-23 03:46:10 +00:00
|
|
|
spinlock_t *lock;
|
2009-04-09 16:31:17 +00:00
|
|
|
/* Flags owned by the EH context. Only EH should touch these once the
|
|
|
|
port is active */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags; /* ATA_FLAG_xxx */
|
2009-04-09 16:31:17 +00:00
|
|
|
/* Flags that change dynamically, protected by ap->lock */
|
2006-06-28 16:29:30 +00:00
|
|
|
unsigned int pflags; /* ATA_PFLAG_xxx */
|
2007-02-20 16:06:51 +00:00
|
|
|
unsigned int print_id; /* user visible unique port ID */
|
2013-05-14 18:48:40 +00:00
|
|
|
unsigned int local_port_no; /* host local port num */
|
2007-02-20 16:06:51 +00:00
|
|
|
unsigned int port_no; /* 0 based port no. inside the host */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-07 13:47:21 +00:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */
|
|
|
|
u8 ctl; /* cache of ATA control register */
|
|
|
|
u8 last_ctl; /* Cache last written value */
|
2010-08-31 23:20:36 +00:00
|
|
|
struct ata_link* sff_pio_task_link; /* link currently used */
|
2010-05-10 19:41:38 +00:00
|
|
|
struct delayed_work sff_pio_task;
|
2010-05-19 20:10:24 +00:00
|
|
|
#ifdef CONFIG_ATA_BMDMA
|
2010-05-10 19:41:41 +00:00
|
|
|
struct ata_bmdma_prd *bmdma_prd; /* BMDMA SG list */
|
|
|
|
dma_addr_t bmdma_prd_dma; /* and its DMA mapping */
|
2010-05-19 20:10:24 +00:00
|
|
|
#endif /* CONFIG_ATA_BMDMA */
|
2010-05-10 19:41:37 +00:00
|
|
|
#endif /* CONFIG_ATA_SFF */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int pio_mask;
|
|
|
|
unsigned int mwdma_mask;
|
|
|
|
unsigned int udma_mask;
|
|
|
|
unsigned int cbl; /* cable type; ATA_CBL_xxx */
|
|
|
|
|
|
|
|
struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
|
2015-01-16 01:32:27 +00:00
|
|
|
unsigned long sas_tag_allocated; /* for sas tag allocation only */
|
2006-05-15 12:03:43 +00:00
|
|
|
unsigned int qc_active;
|
2007-09-23 04:14:12 +00:00
|
|
|
int nr_active_links; /* #links with active qcs */
|
2015-01-16 01:32:27 +00:00
|
|
|
unsigned int sas_last_tag; /* track next tag hw expects */
|
2006-05-15 12:03:43 +00:00
|
|
|
|
libata: implement slave_link
Explanation taken from the comment of ata_slave_link_init().
In libata, a port contains links and a link contains devices. There
is single host link but if a PMP is attached to it, there can be
multiple fan-out links. On SATA, there's usually a single device
connected to a link but PATA and SATA controllers emulating TF based
interface can have two - master and slave.
However, there are a few controllers which don't fit into this
abstraction too well - SATA controllers which emulate TF interface
with both master and slave devices but also have separate SCR
register sets for each device. These controllers need separate links
for physical link handling (e.g. onlineness, link speed) but should
be treated like a traditional M/S controller for everything else
(e.g. command issue, softreset).
slave_link is libata's way of handling this class of controllers
without impacting core layer too much. For anything other than
physical link handling, the default host link is used for both master
and slave. For physical link handling, separate @ap->slave_link is
used. All dirty details are implemented inside libata core layer.
From LLD's POV, the only difference is that prereset, hardreset and
postreset are called once more for the slave link, so the reset
sequence looks like the following.
prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
softreset(M) -> postreset(M) -> postreset(S)
Note that softreset is called only for the master. Softreset resets
both M/S by definition, so SRST on master should handle both (the
standard method will work just fine).
As slave_link excludes PMP support and only code paths which deal with
the attributes of physical link are affected, all the changes are
localized to libata.h, libata-core.c and libata-eh.c.
* ata_is_host_link() updated so that slave_link is considered as host
link too.
* iterator extended to iterate over the slave_link when using the
underbarred version.
* force param handling updated such that devno 16 is mapped to the
slave link/device.
* ata_link_on/offline() updated to return the combined result from
master and slave link. ata_phys_link_on/offline() are the direct
versions.
* EH autopsy and report are performed separately for master slave
links. Reset is udpated to implement the above described reset
sequence.
Except for reset update, most changes are minor, many of them just
modifying dev->link to ata_dev_phys_link(dev) or using phys online
test instead.
After this update, LLDs can take full advantage of per-dev SCR
registers by simply turning on slave link.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-07-31 08:02:43 +00:00
|
|
|
struct ata_link link; /* host default link */
|
|
|
|
struct ata_link *slave_link; /* see ata_slave_link_init() */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-08-06 09:36:23 +00:00
|
|
|
int nr_pmp_links; /* nr of available PMP links */
|
|
|
|
struct ata_link *pmp_link; /* array of PMP links */
|
2007-09-23 04:14:12 +00:00
|
|
|
struct ata_link *excl_link; /* for PMP qc exclusion */
|
2007-08-06 09:36:23 +00:00
|
|
|
|
2006-08-24 07:19:22 +00:00
|
|
|
struct ata_port_stats stats;
|
|
|
|
struct ata_host *host;
|
2006-03-23 23:30:15 +00:00
|
|
|
struct device *dev;
|
2010-05-25 19:31:38 +00:00
|
|
|
struct device tdev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-07-02 08:03:52 +00:00
|
|
|
struct mutex scsi_scan_mutex;
|
2006-11-22 14:54:01 +00:00
|
|
|
struct delayed_work hotplug_task;
|
2006-06-12 04:22:04 +00:00
|
|
|
struct work_struct scsi_rescan_task;
|
2006-03-05 06:29:09 +00:00
|
|
|
|
2005-09-27 09:36:35 +00:00
|
|
|
unsigned int hsm_task_state;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-01-18 00:34:42 +00:00
|
|
|
u32 msg_enable;
|
2006-01-23 04:09:37 +00:00
|
|
|
struct list_head eh_done_q;
|
2006-05-31 09:27:27 +00:00
|
|
|
wait_queue_head_t eh_wait_q;
|
2007-08-18 04:28:49 +00:00
|
|
|
int eh_tries;
|
2008-09-21 09:54:08 +00:00
|
|
|
struct completion park_req_pending;
|
2006-01-18 00:34:42 +00:00
|
|
|
|
2006-07-03 07:07:27 +00:00
|
|
|
pm_message_t pm_mesg;
|
2010-09-01 15:50:06 +00:00
|
|
|
enum ata_lpm_policy target_lpm_policy;
|
2006-07-03 07:07:27 +00:00
|
|
|
|
2007-07-16 05:29:41 +00:00
|
|
|
struct timer_list fastdrain_timer;
|
|
|
|
unsigned long fastdrain_cnt;
|
|
|
|
|
2008-06-03 17:33:55 +00:00
|
|
|
int em_message_type;
|
2005-04-16 22:20:36 +00:00
|
|
|
void *private_data;
|
2006-05-15 11:57:35 +00:00
|
|
|
|
2007-05-14 18:28:16 +00:00
|
|
|
#ifdef CONFIG_ATA_ACPI
|
2007-12-15 06:05:02 +00:00
|
|
|
struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */
|
2007-05-14 18:28:16 +00:00
|
|
|
#endif
|
2009-03-02 09:53:26 +00:00
|
|
|
/* owned by EH */
|
|
|
|
u8 sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
/* The following initializer overrides a method to NULL whether one of
|
|
|
|
* its parent has the method defined or not. This is equivalent to
|
|
|
|
* ERR_PTR(-ENOENT). Unfortunately, ERR_PTR doesn't render a constant
|
|
|
|
* expression and thus can't be used as an initializer.
|
|
|
|
*/
|
|
|
|
#define ATA_OP_NULL (void *)(unsigned long)(-ENOENT)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct ata_port_operations {
|
2008-03-25 03:22:47 +00:00
|
|
|
/*
|
|
|
|
* Command execution
|
|
|
|
*/
|
|
|
|
int (*qc_defer)(struct ata_queued_cmd *qc);
|
|
|
|
int (*check_atapi_dma)(struct ata_queued_cmd *qc);
|
|
|
|
void (*qc_prep)(struct ata_queued_cmd *qc);
|
|
|
|
unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
|
2008-04-07 13:47:20 +00:00
|
|
|
bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-25 03:22:47 +00:00
|
|
|
/*
|
|
|
|
* Configuration and exception handling
|
|
|
|
*/
|
|
|
|
int (*cable_detect)(struct ata_port *ap);
|
|
|
|
unsigned long (*mode_filter)(struct ata_device *dev, unsigned long xfer_mask);
|
|
|
|
void (*set_piomode)(struct ata_port *ap, struct ata_device *dev);
|
|
|
|
void (*set_dmamode)(struct ata_port *ap, struct ata_device *dev);
|
|
|
|
int (*set_mode)(struct ata_link *link, struct ata_device **r_failed_dev);
|
2008-07-24 16:16:06 +00:00
|
|
|
unsigned int (*read_id)(struct ata_device *dev, struct ata_taskfile *tf, u16 *id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*dev_config)(struct ata_device *dev);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*freeze)(struct ata_port *ap);
|
|
|
|
void (*thaw)(struct ata_port *ap);
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:50 +00:00
|
|
|
ata_prereset_fn_t prereset;
|
|
|
|
ata_reset_fn_t softreset;
|
|
|
|
ata_reset_fn_t hardreset;
|
|
|
|
ata_postreset_fn_t postreset;
|
|
|
|
ata_prereset_fn_t pmp_prereset;
|
|
|
|
ata_reset_fn_t pmp_softreset;
|
|
|
|
ata_reset_fn_t pmp_hardreset;
|
|
|
|
ata_postreset_fn_t pmp_postreset;
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*error_handler)(struct ata_port *ap);
|
2009-03-24 10:23:46 +00:00
|
|
|
void (*lost_interrupt)(struct ata_port *ap);
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*post_internal_cmd)(struct ata_queued_cmd *qc);
|
2012-06-22 06:25:27 +00:00
|
|
|
void (*sched_eh)(struct ata_port *ap);
|
|
|
|
void (*end_eh)(struct ata_port *ap);
|
2008-03-25 03:22:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Optional features
|
|
|
|
*/
|
2008-07-31 08:02:40 +00:00
|
|
|
int (*scr_read)(struct ata_link *link, unsigned int sc_reg, u32 *val);
|
|
|
|
int (*scr_write)(struct ata_link *link, unsigned int sc_reg, u32 val);
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*pmp_attach)(struct ata_port *ap);
|
|
|
|
void (*pmp_detach)(struct ata_port *ap);
|
2010-09-01 15:50:06 +00:00
|
|
|
int (*set_lpm)(struct ata_link *link, enum ata_lpm_policy policy,
|
|
|
|
unsigned hints);
|
2008-03-25 03:22:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Start, stop, suspend and resume
|
|
|
|
*/
|
|
|
|
int (*port_suspend)(struct ata_port *ap, pm_message_t mesg);
|
|
|
|
int (*port_resume)(struct ata_port *ap);
|
|
|
|
int (*port_start)(struct ata_port *ap);
|
|
|
|
void (*port_stop)(struct ata_port *ap);
|
|
|
|
void (*host_stop)(struct ata_host *host);
|
|
|
|
|
2008-04-07 13:47:21 +00:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
2008-03-25 03:22:47 +00:00
|
|
|
/*
|
|
|
|
* SFF / taskfile oriented ops
|
|
|
|
*/
|
2008-04-07 13:47:16 +00:00
|
|
|
void (*sff_dev_select)(struct ata_port *ap, unsigned int device);
|
2010-05-07 18:47:50 +00:00
|
|
|
void (*sff_set_devctl)(struct ata_port *ap, u8 ctl);
|
2008-04-07 13:47:16 +00:00
|
|
|
u8 (*sff_check_status)(struct ata_port *ap);
|
|
|
|
u8 (*sff_check_altstatus)(struct ata_port *ap);
|
|
|
|
void (*sff_tf_load)(struct ata_port *ap, const struct ata_taskfile *tf);
|
|
|
|
void (*sff_tf_read)(struct ata_port *ap, struct ata_taskfile *tf);
|
|
|
|
void (*sff_exec_command)(struct ata_port *ap,
|
|
|
|
const struct ata_taskfile *tf);
|
2016-12-30 14:01:17 +00:00
|
|
|
unsigned int (*sff_data_xfer)(struct ata_queued_cmd *qc,
|
2008-04-07 13:47:16 +00:00
|
|
|
unsigned char *buf, unsigned int buflen, int rw);
|
2010-05-07 18:49:02 +00:00
|
|
|
void (*sff_irq_on)(struct ata_port *);
|
2010-01-19 01:49:19 +00:00
|
|
|
bool (*sff_irq_check)(struct ata_port *);
|
2008-04-07 13:47:16 +00:00
|
|
|
void (*sff_irq_clear)(struct ata_port *);
|
2010-05-10 19:41:36 +00:00
|
|
|
void (*sff_drain_fifo)(struct ata_queued_cmd *qc);
|
2008-04-07 13:47:16 +00:00
|
|
|
|
2010-05-19 20:10:24 +00:00
|
|
|
#ifdef CONFIG_ATA_BMDMA
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*bmdma_setup)(struct ata_queued_cmd *qc);
|
|
|
|
void (*bmdma_start)(struct ata_queued_cmd *qc);
|
|
|
|
void (*bmdma_stop)(struct ata_queued_cmd *qc);
|
|
|
|
u8 (*bmdma_status)(struct ata_port *ap);
|
2010-05-19 20:10:24 +00:00
|
|
|
#endif /* CONFIG_ATA_BMDMA */
|
2008-04-07 13:47:21 +00:00
|
|
|
#endif /* CONFIG_ATA_SFF */
|
2008-03-25 03:22:47 +00:00
|
|
|
|
2008-06-03 17:33:55 +00:00
|
|
|
ssize_t (*em_show)(struct ata_port *ap, char *buf);
|
|
|
|
ssize_t (*em_store)(struct ata_port *ap, const char *message,
|
|
|
|
size_t size);
|
|
|
|
ssize_t (*sw_activity_show)(struct ata_device *dev, char *buf);
|
|
|
|
ssize_t (*sw_activity_store)(struct ata_device *dev,
|
|
|
|
enum sw_activity val);
|
2013-05-30 20:17:30 +00:00
|
|
|
ssize_t (*transmit_led_message)(struct ata_port *ap, u32 state,
|
|
|
|
ssize_t size);
|
|
|
|
|
2008-03-25 03:22:47 +00:00
|
|
|
/*
|
|
|
|
* Obsolete
|
2006-05-15 11:57:58 +00:00
|
|
|
*/
|
2008-03-25 03:22:47 +00:00
|
|
|
void (*phy_reset)(struct ata_port *ap);
|
|
|
|
void (*eng_timeout)(struct ata_port *ap);
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ->inherits must be the last field and all the preceding
|
|
|
|
* fields must be pointers.
|
|
|
|
*/
|
|
|
|
const struct ata_port_operations *inherits;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ata_port_info {
|
2006-08-24 07:19:22 +00:00
|
|
|
unsigned long flags;
|
2007-08-06 09:36:23 +00:00
|
|
|
unsigned long link_flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long pio_mask;
|
|
|
|
unsigned long mwdma_mask;
|
|
|
|
unsigned long udma_mask;
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
struct ata_port_operations *port_ops;
|
2005-11-08 14:09:44 +00:00
|
|
|
void *private_data;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2005-10-21 23:01:32 +00:00
|
|
|
struct ata_timing {
|
|
|
|
unsigned short mode; /* ATA mode */
|
|
|
|
unsigned short setup; /* t1 */
|
|
|
|
unsigned short act8b; /* t2 for 8-bit I/O */
|
|
|
|
unsigned short rec8b; /* t2i for 8-bit I/O */
|
|
|
|
unsigned short cyc8b; /* t0 for 8-bit I/O */
|
|
|
|
unsigned short active; /* t2 or tD */
|
|
|
|
unsigned short recover; /* t2i or tK */
|
2009-01-16 01:45:31 +00:00
|
|
|
unsigned short dmack_hold; /* tj */
|
2005-10-21 23:01:32 +00:00
|
|
|
unsigned short cycle; /* t0 */
|
|
|
|
unsigned short udma; /* t2CYCTYP/2 */
|
|
|
|
};
|
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/*
|
|
|
|
* Core layer - drivers/ata/libata-core.c
|
|
|
|
*/
|
2006-07-03 07:07:26 +00:00
|
|
|
extern const unsigned long sata_deb_timing_normal[];
|
|
|
|
extern const unsigned long sata_deb_timing_hotplug[];
|
|
|
|
extern const unsigned long sata_deb_timing_long[];
|
|
|
|
|
libata: implement and use ops inheritance
libata lets low level drivers build ata_port_operations table and
register it with libata core layer. This allows low level drivers
high level of flexibility but also burdens them with lots of
boilerplate entries.
This becomes worse for drivers which support related similar
controllers which differ slightly. They share most of the operations
except for a few. However, the driver still needs to list all
operations for each variant. This results in large number of
duplicate entries, which is not only inefficient but also error-prone
as it becomes very difficult to tell what the actual differences are.
This duplicate boilerplates all over the low level drivers also make
updating the core layer exteremely difficult and error-prone. When
compounded with multi-branched development model, it ends up
accumulating inconsistencies over time. Some of those inconsistencies
cause immediate problems and fixed. Others just remain there dormant
making maintenance increasingly difficult.
To rectify the problem, this patch implements ata_port_operations
inheritance. To allow LLDs to easily re-use their own ops tables
overriding only specific methods, this patch implements poor man's
class inheritance. An ops table has ->inherits field which can be set
to any ops table as long as it doesn't create a loop. When the host
is started, the inheritance chain is followed and any operation which
isn't specified is taken from the nearest ancestor which has it
specified. This operation is called finalization and done only once
per an ops table and the LLD doesn't have to do anything special about
it other than making the ops table non-const such that libata can
update it.
libata provides four base ops tables lower drivers can inherit from -
base, sata, pmp, sff and bmdma. To avoid overriding these ops
accidentaly, these ops are declared const and LLDs should always
inherit these instead of using them directly.
After finalization, all the ops table are identical before and after
the patch except for setting .irq_handler to ata_interrupt in drivers
which didn't use to. The .irq_handler doesn't have any actual effect
and the field will soon be removed by later patch.
* sata_sx4 is still using old style EH and currently doesn't take
advantage of ops inheritance.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:49 +00:00
|
|
|
extern struct ata_port_operations ata_dummy_port_ops;
|
2007-04-17 14:44:07 +00:00
|
|
|
extern const struct ata_port_info ata_dummy_port_info;
|
2006-08-10 07:59:12 +00:00
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_atapi(u8 prot)
|
2013-06-30 20:01:32 +00:00
|
|
|
{
|
2016-07-16 13:16:43 +00:00
|
|
|
return prot & ATA_PROT_FLAG_ATAPI;
|
2013-06-30 20:01:32 +00:00
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_pio(u8 prot)
|
2013-06-30 20:01:32 +00:00
|
|
|
{
|
2016-07-16 13:16:43 +00:00
|
|
|
return prot & ATA_PROT_FLAG_PIO;
|
2013-06-30 20:01:32 +00:00
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_dma(u8 prot)
|
2013-06-30 20:01:32 +00:00
|
|
|
{
|
2016-07-16 13:16:43 +00:00
|
|
|
return prot & ATA_PROT_FLAG_DMA;
|
2013-06-30 20:01:32 +00:00
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_ncq(u8 prot)
|
2013-06-30 20:01:32 +00:00
|
|
|
{
|
2016-07-16 13:16:43 +00:00
|
|
|
return prot & ATA_PROT_FLAG_NCQ;
|
2013-06-30 20:01:32 +00:00
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_data(u8 prot)
|
2013-06-30 20:01:32 +00:00
|
|
|
{
|
2016-07-16 13:16:43 +00:00
|
|
|
return prot & (ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA);
|
2013-06-30 20:01:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_multi_taskfile(struct ata_taskfile *tf)
|
|
|
|
{
|
|
|
|
return (tf->command == ATA_CMD_READ_MULTI) ||
|
|
|
|
(tf->command == ATA_CMD_WRITE_MULTI) ||
|
|
|
|
(tf->command == ATA_CMD_READ_MULTI_EXT) ||
|
|
|
|
(tf->command == ATA_CMD_WRITE_MULTI_EXT) ||
|
|
|
|
(tf->command == ATA_CMD_WRITE_MULTI_FUA_EXT);
|
|
|
|
}
|
|
|
|
|
2006-07-03 07:07:26 +00:00
|
|
|
static inline const unsigned long *
|
|
|
|
sata_ehc_deb_timing(struct ata_eh_context *ehc)
|
|
|
|
{
|
|
|
|
if (ehc->i.flags & ATA_EHI_HOTPLUGGED)
|
|
|
|
return sata_deb_timing_hotplug;
|
|
|
|
else
|
|
|
|
return sata_deb_timing_normal;
|
|
|
|
}
|
2006-05-31 09:27:46 +00:00
|
|
|
|
2006-08-10 07:59:12 +00:00
|
|
|
static inline int ata_port_is_dummy(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return ap->ops == &ata_dummy_port_ops;
|
|
|
|
}
|
|
|
|
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int sata_set_spd(struct ata_link *link);
|
2008-04-07 13:47:18 +00:00
|
|
|
extern int ata_std_prereset(struct ata_link *link, unsigned long deadline);
|
2008-04-07 13:47:19 +00:00
|
|
|
extern int ata_wait_after_reset(struct ata_link *link, unsigned long deadline,
|
|
|
|
int (*check_ready)(struct ata_link *link));
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int sata_link_debounce(struct ata_link *link,
|
|
|
|
const unsigned long *params, unsigned long deadline);
|
|
|
|
extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
|
|
|
|
unsigned long deadline);
|
2010-09-01 15:50:05 +00:00
|
|
|
extern int sata_link_scr_lpm(struct ata_link *link, enum ata_lpm_policy policy,
|
|
|
|
bool spm_wakeup);
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int sata_link_hardreset(struct ata_link *link,
|
2008-04-07 13:47:19 +00:00
|
|
|
const unsigned long *timing, unsigned long deadline,
|
|
|
|
bool *online, int (*check_ready)(struct ata_link *));
|
2008-04-07 13:47:19 +00:00
|
|
|
extern int sata_std_hardreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline);
|
2008-04-07 13:47:18 +00:00
|
|
|
extern void ata_std_postreset(struct ata_link *link, unsigned int *classes);
|
2007-10-11 21:12:35 +00:00
|
|
|
|
2007-04-17 14:44:07 +00:00
|
|
|
extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
|
2007-04-17 14:44:07 +00:00
|
|
|
extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
|
|
|
|
const struct ata_port_info * const * ppi, int n_ports);
|
libata: implement slave_link
Explanation taken from the comment of ata_slave_link_init().
In libata, a port contains links and a link contains devices. There
is single host link but if a PMP is attached to it, there can be
multiple fan-out links. On SATA, there's usually a single device
connected to a link but PATA and SATA controllers emulating TF based
interface can have two - master and slave.
However, there are a few controllers which don't fit into this
abstraction too well - SATA controllers which emulate TF interface
with both master and slave devices but also have separate SCR
register sets for each device. These controllers need separate links
for physical link handling (e.g. onlineness, link speed) but should
be treated like a traditional M/S controller for everything else
(e.g. command issue, softreset).
slave_link is libata's way of handling this class of controllers
without impacting core layer too much. For anything other than
physical link handling, the default host link is used for both master
and slave. For physical link handling, separate @ap->slave_link is
used. All dirty details are implemented inside libata core layer.
From LLD's POV, the only difference is that prereset, hardreset and
postreset are called once more for the slave link, so the reset
sequence looks like the following.
prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
softreset(M) -> postreset(M) -> postreset(S)
Note that softreset is called only for the master. Softreset resets
both M/S by definition, so SRST on master should handle both (the
standard method will work just fine).
As slave_link excludes PMP support and only code paths which deal with
the attributes of physical link are affected, all the changes are
localized to libata.h, libata-core.c and libata-eh.c.
* ata_is_host_link() updated so that slave_link is considered as host
link too.
* iterator extended to iterate over the slave_link when using the
underbarred version.
* force param handling updated such that devno 16 is mapped to the
slave link/device.
* ata_link_on/offline() updated to return the combined result from
master and slave link. ata_phys_link_on/offline() are the direct
versions.
* EH autopsy and report are performed separately for master slave
links. Reset is udpated to implement the above described reset
sequence.
Except for reset update, most changes are minor, many of them just
modifying dev->link to ata_dev_phys_link(dev) or using phys online
test instead.
After this update, LLDs can take full advantage of per-dev SCR
registers by simply turning on slave link.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-07-31 08:02:43 +00:00
|
|
|
extern int ata_slave_link_init(struct ata_port *ap);
|
2007-04-17 14:44:06 +00:00
|
|
|
extern int ata_host_start(struct ata_host *host);
|
2007-04-17 14:44:07 +00:00
|
|
|
extern int ata_host_register(struct ata_host *host,
|
|
|
|
struct scsi_host_template *sht);
|
2007-04-17 14:44:07 +00:00
|
|
|
extern int ata_host_activate(struct ata_host *host, int irq,
|
|
|
|
irq_handler_t irq_handler, unsigned long irq_flags,
|
|
|
|
struct scsi_host_template *sht);
|
2007-01-20 07:00:26 +00:00
|
|
|
extern void ata_host_detach(struct ata_host *host);
|
2012-07-10 04:06:08 +00:00
|
|
|
extern void ata_host_init(struct ata_host *, struct device *, struct ata_port_operations *);
|
2005-11-07 05:59:37 +00:00
|
|
|
extern int ata_scsi_detect(struct scsi_host_template *sht);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
|
2010-11-16 07:10:29 +00:00
|
|
|
extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
|
2009-01-16 15:17:09 +00:00
|
|
|
extern int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *dev,
|
|
|
|
int cmd, void __user *arg);
|
2006-08-07 19:27:31 +00:00
|
|
|
extern void ata_sas_port_destroy(struct ata_port *);
|
2006-08-24 07:19:22 +00:00
|
|
|
extern struct ata_port *ata_sas_port_alloc(struct ata_host *,
|
2006-08-07 19:27:31 +00:00
|
|
|
struct ata_port_info *, struct Scsi_Host *);
|
2012-03-22 04:09:07 +00:00
|
|
|
extern void ata_sas_async_probe(struct ata_port *ap);
|
|
|
|
extern int ata_sas_sync_probe(struct ata_port *ap);
|
2006-08-07 19:27:31 +00:00
|
|
|
extern int ata_sas_port_init(struct ata_port *);
|
|
|
|
extern int ata_sas_port_start(struct ata_port *ap);
|
|
|
|
extern void ata_sas_port_stop(struct ata_port *ap);
|
|
|
|
extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
|
2010-11-18 03:56:48 +00:00
|
|
|
extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap);
|
2017-01-30 12:18:58 +00:00
|
|
|
extern enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int sata_scr_valid(struct ata_link *link);
|
|
|
|
extern int sata_scr_read(struct ata_link *link, int reg, u32 *val);
|
|
|
|
extern int sata_scr_write(struct ata_link *link, int reg, u32 val);
|
|
|
|
extern int sata_scr_write_flush(struct ata_link *link, int reg, u32 val);
|
2008-07-31 08:02:42 +00:00
|
|
|
extern bool ata_link_online(struct ata_link *link);
|
|
|
|
extern bool ata_link_offline(struct ata_link *link);
|
2007-03-02 08:32:47 +00:00
|
|
|
#ifdef CONFIG_PM
|
2006-08-24 07:19:22 +00:00
|
|
|
extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
|
|
|
|
extern void ata_host_resume(struct ata_host *host);
|
libata, libsas: kill pm_result and related cleanup
Tejun says:
"At least for libata, worrying about suspend/resume failures don't make
whole lot of sense. If suspend failed, just proceed with suspend. If
the device can't be woken up afterwards, that's that. There isn't
anything we could have done differently anyway. The same for resume, if
spinup fails, the device is dud and the following commands will invoke
EH actions and will eventually fail. Again, there really isn't any
*choice* to make. Just making sure the errors are handled gracefully
(ie. don't crash) and the following commands are handled correctly
should be enough."
The only libata user that actually cares about the result from a suspend
operation is libsas. However, it only cares about whether queuing a new
operation collides with an in-flight one. All libsas does with the
error is retry, but we can just let libata wait for the previous
operation before continuing.
Other cleanups include:
1/ Unifying all ata port pm operations on an ata_port_pm_ prefix
2/ Marking all ata port pm helper routines as returning void, only
ata_port_pm_ entry points need to fake a 0 return value.
3/ Killing ata_port_{suspend|resume}_common() in favor of calling
ata_port_request_pm() directly
4/ Killing the wrappers that just do a to_ata_port() conversion
5/ Clearly marking the entry points that do async operations with an
_async suffix.
Reference: http://marc.info/?l=linux-scsi&m=138995409532286&w=2
Cc: Phillip Susi <psusi@ubuntu.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Suggested-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Todd Brandt <todd.e.brandt@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-03-14 20:52:48 +00:00
|
|
|
extern void ata_sas_port_suspend(struct ata_port *ap);
|
|
|
|
extern void ata_sas_port_resume(struct ata_port *ap);
|
2012-06-22 06:41:46 +00:00
|
|
|
#else
|
libata, libsas: kill pm_result and related cleanup
Tejun says:
"At least for libata, worrying about suspend/resume failures don't make
whole lot of sense. If suspend failed, just proceed with suspend. If
the device can't be woken up afterwards, that's that. There isn't
anything we could have done differently anyway. The same for resume, if
spinup fails, the device is dud and the following commands will invoke
EH actions and will eventually fail. Again, there really isn't any
*choice* to make. Just making sure the errors are handled gracefully
(ie. don't crash) and the following commands are handled correctly
should be enough."
The only libata user that actually cares about the result from a suspend
operation is libsas. However, it only cares about whether queuing a new
operation collides with an in-flight one. All libsas does with the
error is retry, but we can just let libata wait for the previous
operation before continuing.
Other cleanups include:
1/ Unifying all ata port pm operations on an ata_port_pm_ prefix
2/ Marking all ata port pm helper routines as returning void, only
ata_port_pm_ entry points need to fake a 0 return value.
3/ Killing ata_port_{suspend|resume}_common() in favor of calling
ata_port_request_pm() directly
4/ Killing the wrappers that just do a to_ata_port() conversion
5/ Clearly marking the entry points that do async operations with an
_async suffix.
Reference: http://marc.info/?l=linux-scsi&m=138995409532286&w=2
Cc: Phillip Susi <psusi@ubuntu.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Suggested-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Todd Brandt <todd.e.brandt@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
2014-03-14 20:52:48 +00:00
|
|
|
static inline void ata_sas_port_suspend(struct ata_port *ap)
|
2012-06-22 06:41:46 +00:00
|
|
|
{
|
|
|
|
}
|
2014-03-19 17:46:25 +00:00
|
|
|
static inline void ata_sas_port_resume(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
}
|
2007-03-02 08:32:47 +00:00
|
|
|
#endif
|
2005-10-05 06:58:32 +00:00
|
|
|
extern int ata_ratelimit(void);
|
2010-09-06 15:56:29 +00:00
|
|
|
extern void ata_msleep(struct ata_port *ap, unsigned int msecs);
|
|
|
|
extern u32 ata_wait_register(struct ata_port *ap, void __iomem *reg, u32 mask,
|
|
|
|
u32 val, unsigned long interval, unsigned long timeout);
|
2008-04-02 08:28:46 +00:00
|
|
|
extern int atapi_cmd_type(u8 opcode);
|
2007-07-16 05:29:38 +00:00
|
|
|
extern void ata_tf_to_fis(const struct ata_taskfile *tf,
|
|
|
|
u8 pmp, int is_cmd, u8 *fis);
|
2005-10-22 18:27:05 +00:00
|
|
|
extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
|
2007-11-27 10:43:42 +00:00
|
|
|
extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
|
|
|
|
unsigned long mwdma_mask, unsigned long udma_mask);
|
|
|
|
extern void ata_unpack_xfermask(unsigned long xfer_mask,
|
|
|
|
unsigned long *pio_mask, unsigned long *mwdma_mask,
|
|
|
|
unsigned long *udma_mask);
|
|
|
|
extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
|
|
|
|
extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
|
|
|
|
extern int ata_xfer_mode2shift(unsigned long xfer_mode);
|
|
|
|
extern const char *ata_mode_string(unsigned long xfer_mask);
|
|
|
|
extern unsigned long ata_id_xfermask(const u16 *id);
|
2007-09-23 04:14:12 +00:00
|
|
|
extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
|
2006-03-17 23:04:03 +00:00
|
|
|
extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
|
|
|
|
unsigned int n_elem);
|
2005-10-22 18:27:05 +00:00
|
|
|
extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
|
2007-02-20 18:01:59 +00:00
|
|
|
extern void ata_dev_disable(struct ata_device *adev);
|
2006-02-13 01:02:46 +00:00
|
|
|
extern void ata_id_string(const u16 *id, unsigned char *s,
|
|
|
|
unsigned int ofs, unsigned int len);
|
|
|
|
extern void ata_id_c_string(const u16 *id, unsigned char *s,
|
|
|
|
unsigned int ofs, unsigned int len);
|
2008-07-24 16:16:06 +00:00
|
|
|
extern unsigned int ata_do_dev_read_id(struct ata_device *dev,
|
|
|
|
struct ata_taskfile *tf, u16 *id);
|
2006-05-15 11:58:05 +00:00
|
|
|
extern void ata_qc_complete(struct ata_queued_cmd *qc);
|
2008-04-07 13:47:20 +00:00
|
|
|
extern int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active);
|
2010-11-18 03:56:48 +00:00
|
|
|
extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int ata_std_bios_param(struct scsi_device *sdev,
|
|
|
|
struct block_device *bdev,
|
|
|
|
sector_t capacity, int geom[]);
|
2010-05-15 18:09:34 +00:00
|
|
|
extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int ata_scsi_slave_config(struct scsi_device *sdev);
|
2006-05-31 09:28:07 +00:00
|
|
|
extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
|
2006-05-15 12:03:48 +00:00
|
|
|
extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
|
2014-11-13 14:08:42 +00:00
|
|
|
int queue_depth);
|
2011-09-20 22:10:33 +00:00
|
|
|
extern int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
|
2014-11-13 14:08:42 +00:00
|
|
|
int queue_depth);
|
2006-05-15 11:57:53 +00:00
|
|
|
extern struct ata_device *ata_dev_pair(struct ata_device *adev);
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
|
2011-01-23 15:42:50 +00:00
|
|
|
extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
|
|
|
|
extern void ata_scsi_cmd_error_handler(struct Scsi_Host *host, struct ata_port *ap, struct list_head *eh_q);
|
2015-04-25 17:52:36 +00:00
|
|
|
extern bool sata_lpm_ignore_phy_events(struct ata_link *link);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-03-06 10:37:56 +00:00
|
|
|
extern int ata_cable_40wire(struct ata_port *ap);
|
|
|
|
extern int ata_cable_80wire(struct ata_port *ap);
|
|
|
|
extern int ata_cable_sata(struct ata_port *ap);
|
2007-11-27 10:43:48 +00:00
|
|
|
extern int ata_cable_ignore(struct ata_port *ap);
|
2007-03-06 10:37:56 +00:00
|
|
|
extern int ata_cable_unknown(struct ata_port *ap);
|
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/* Timing helpers */
|
2006-01-09 17:18:14 +00:00
|
|
|
extern unsigned int ata_pio_need_iordy(const struct ata_device *);
|
2007-11-27 10:43:39 +00:00
|
|
|
extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
|
2005-10-21 23:01:32 +00:00
|
|
|
extern int ata_timing_compute(struct ata_device *, unsigned short,
|
|
|
|
struct ata_timing *, int, int);
|
|
|
|
extern void ata_timing_merge(const struct ata_timing *,
|
|
|
|
const struct ata_timing *, struct ata_timing *,
|
|
|
|
unsigned int);
|
2007-12-18 07:33:05 +00:00
|
|
|
extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
|
2005-10-21 23:01:32 +00:00
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/* PCI */
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
struct pci_dev;
|
|
|
|
|
|
|
|
struct pci_bits {
|
|
|
|
unsigned int reg; /* PCI config register to read */
|
|
|
|
unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
|
|
|
|
unsigned long mask;
|
|
|
|
unsigned long val;
|
2005-10-21 23:01:32 +00:00
|
|
|
};
|
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
|
|
|
|
extern void ata_pci_remove_one(struct pci_dev *pdev);
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
|
|
|
|
extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
|
|
|
|
extern int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
|
|
|
|
extern int ata_pci_device_resume(struct pci_dev *pdev);
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2012-11-02 19:29:32 +00:00
|
|
|
struct platform_device;
|
|
|
|
|
|
|
|
extern int ata_platform_remove_one(struct platform_device *pdev);
|
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/*
|
|
|
|
* ACPI - drivers/ata/libata-acpi.c
|
|
|
|
*/
|
2007-08-16 06:33:36 +00:00
|
|
|
#ifdef CONFIG_ATA_ACPI
|
2007-12-15 06:05:02 +00:00
|
|
|
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
if (ap->pflags & ATA_PFLAG_INIT_GTM_VALID)
|
|
|
|
return &ap->__acpi_init_gtm;
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-12-15 06:04:57 +00:00
|
|
|
int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
|
|
|
|
int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
|
2007-12-18 07:33:03 +00:00
|
|
|
unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
|
|
|
|
const struct ata_acpi_gtm *gtm);
|
2007-12-18 07:33:06 +00:00
|
|
|
int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
|
2007-08-16 06:33:36 +00:00
|
|
|
#else
|
2007-12-15 06:05:02 +00:00
|
|
|
static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-12-18 07:33:03 +00:00
|
|
|
|
|
|
|
static inline int ata_acpi_stm(const struct ata_port *ap,
|
|
|
|
struct ata_acpi_gtm *stm)
|
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ata_acpi_gtm(const struct ata_port *ap,
|
|
|
|
struct ata_acpi_gtm *stm)
|
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
|
|
|
|
const struct ata_acpi_gtm *gtm)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2007-12-18 07:33:06 +00:00
|
|
|
|
|
|
|
static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
|
|
|
|
const struct ata_acpi_gtm *gtm)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2007-08-16 06:33:36 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-04-02 09:51:53 +00:00
|
|
|
/*
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
* EH - drivers/ata/libata-eh.c
|
2006-04-02 09:51:53 +00:00
|
|
|
*/
|
2006-05-15 11:58:07 +00:00
|
|
|
extern void ata_port_schedule_eh(struct ata_port *ap);
|
2011-12-03 00:07:01 +00:00
|
|
|
extern void ata_port_wait_eh(struct ata_port *ap);
|
2007-08-06 09:36:23 +00:00
|
|
|
extern int ata_link_abort(struct ata_link *link);
|
2006-05-15 11:58:07 +00:00
|
|
|
extern int ata_port_abort(struct ata_port *ap);
|
2006-05-15 11:58:09 +00:00
|
|
|
extern int ata_port_freeze(struct ata_port *ap);
|
2007-09-23 04:14:13 +00:00
|
|
|
extern int sata_async_notification(struct ata_port *ap);
|
2006-05-15 11:58:09 +00:00
|
|
|
|
|
|
|
extern void ata_eh_freeze_port(struct ata_port *ap);
|
|
|
|
extern void ata_eh_thaw_port(struct ata_port *ap);
|
2006-05-15 11:58:07 +00:00
|
|
|
|
2006-04-02 09:51:53 +00:00
|
|
|
extern void ata_eh_qc_complete(struct ata_queued_cmd *qc);
|
|
|
|
extern void ata_eh_qc_retry(struct ata_queued_cmd *qc);
|
2008-05-02 06:14:53 +00:00
|
|
|
extern void ata_eh_analyze_ncq_error(struct ata_link *link);
|
2006-04-02 09:51:53 +00:00
|
|
|
|
2006-05-31 09:27:48 +00:00
|
|
|
extern void ata_do_eh(struct ata_port *ap, ata_prereset_fn_t prereset,
|
|
|
|
ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
|
|
|
|
ata_postreset_fn_t postreset);
|
libata: make reset related methods proper port operations
Currently reset methods are not specified directly in the
ata_port_operations table. If a LLD wants to use custom reset
methods, it should construct and use a error_handler which uses those
reset methods. It's done this way for two reasons.
First, the ops table already contained too many methods and adding
four more of them would noticeably increase the amount of necessary
boilerplate code all over low level drivers.
Second, as ->error_handler uses those reset methods, it can get
confusing. ie. By overriding ->error_handler, those reset ops can be
made useless making layering a bit hazy.
Now that ops table uses inheritance, the first problem doesn't exist
anymore. The second isn't completely solved but is relieved by
providing default values - most drivers can just override what it has
implemented and don't have to concern itself about higher level
callbacks. In fact, there currently is no driver which actually
modifies error handling behavior. Drivers which override
->error_handler just wraps the standard error handler only to prepare
the controller for EH. I don't think making ops layering strict has
any noticeable benefit.
This patch makes ->prereset, ->softreset, ->hardreset, ->postreset and
their PMP counterparts propoer ops. Default ops are provided in the
base ops tables and drivers are converted to override individual reset
methods instead of creating custom error_handler.
* ata_std_error_handler() doesn't use sata_std_hardreset() if SCRs
aren't accessible. sata_promise doesn't need to use separate
error_handlers for PATA and SATA anymore.
* softreset is broken for sata_inic162x and sata_sx4. As libata now
always prefers hardreset, this doesn't really matter but the ops are
forced to NULL using ATA_OP_NULL for documentation purpose.
* pata_hpt374 needs to use different prereset for the first and second
PCI functions. This used to be done by branching from
hpt374_error_handler(). The proper way to do this is to use
separate ops and port_info tables for each function. Converted.
Signed-off-by: Tejun Heo <htejun@gmail.com>
2008-03-25 03:22:50 +00:00
|
|
|
extern void ata_std_error_handler(struct ata_port *ap);
|
2012-06-22 06:25:27 +00:00
|
|
|
extern void ata_std_sched_eh(struct ata_port *ap);
|
|
|
|
extern void ata_std_end_eh(struct ata_port *ap);
|
2011-03-04 18:24:11 +00:00
|
|
|
extern int ata_link_nr_enabled(struct ata_link *link);
|
2006-05-15 11:58:22 +00:00
|
|
|
|
2008-03-25 03:22:49 +00:00
|
|
|
/*
|
|
|
|
* Base operations to inherit from and initializers for sht
|
|
|
|
*
|
|
|
|
* Operations
|
|
|
|
*
|
|
|
|
* base : Common to all libata drivers.
|
|
|
|
* sata : SATA controllers w/ native interface.
|
|
|
|
* pmp : SATA controllers w/ PMP support.
|
|
|
|
* sff : SFF ATA controllers w/o BMDMA support.
|
|
|
|
* bmdma : SFF ATA controllers w/ BMDMA support.
|
|
|
|
*
|
|
|
|
* sht initializers
|
|
|
|
*
|
|
|
|
* BASE : Common to all libata drivers. The user must set
|
|
|
|
* sg_tablesize and dma_boundary.
|
|
|
|
* PIO : SFF ATA controllers w/ only PIO support.
|
|
|
|
* BMDMA : SFF ATA controllers w/ BMDMA support. sg_tablesize and
|
|
|
|
* dma_boundary are set to BMDMA limits.
|
|
|
|
* NCQ : SATA controllers supporting NCQ. The user must set
|
|
|
|
* sg_tablesize, dma_boundary and can_queue.
|
|
|
|
*/
|
|
|
|
extern const struct ata_port_operations ata_base_port_ops;
|
|
|
|
extern const struct ata_port_operations sata_port_ops;
|
2008-09-21 09:54:08 +00:00
|
|
|
extern struct device_attribute *ata_common_sdev_attrs[];
|
2008-03-25 03:22:49 +00:00
|
|
|
|
2015-01-28 23:30:29 +00:00
|
|
|
/*
|
|
|
|
* All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated
|
|
|
|
* by the edge drivers. Because the 'module' field of sht must be the
|
|
|
|
* edge driver's module reference, otherwise the driver can be unloaded
|
|
|
|
* even if the scsi_device is being accessed.
|
|
|
|
*/
|
2008-03-25 03:22:49 +00:00
|
|
|
#define ATA_BASE_SHT(drv_name) \
|
|
|
|
.module = THIS_MODULE, \
|
|
|
|
.name = drv_name, \
|
|
|
|
.ioctl = ata_scsi_ioctl, \
|
|
|
|
.queuecommand = ata_scsi_queuecmd, \
|
|
|
|
.can_queue = ATA_DEF_QUEUE, \
|
2015-01-16 01:32:27 +00:00
|
|
|
.tag_alloc_policy = BLK_TAG_ALLOC_RR, \
|
2008-03-25 03:22:49 +00:00
|
|
|
.this_id = ATA_SHT_THIS_ID, \
|
|
|
|
.emulated = ATA_SHT_EMULATED, \
|
|
|
|
.use_clustering = ATA_SHT_USE_CLUSTERING, \
|
|
|
|
.proc_name = drv_name, \
|
|
|
|
.slave_configure = ata_scsi_slave_config, \
|
|
|
|
.slave_destroy = ata_scsi_slave_destroy, \
|
2017-01-30 12:18:58 +00:00
|
|
|
.eh_timed_out = ata_scsi_timed_out, \
|
2008-09-21 09:54:08 +00:00
|
|
|
.bios_param = ata_std_bios_param, \
|
2010-05-15 18:09:34 +00:00
|
|
|
.unlock_native_capacity = ata_scsi_unlock_native_capacity, \
|
2008-09-21 09:54:08 +00:00
|
|
|
.sdev_attrs = ata_common_sdev_attrs
|
2008-03-25 03:22:49 +00:00
|
|
|
|
|
|
|
#define ATA_NCQ_SHT(drv_name) \
|
|
|
|
ATA_BASE_SHT(drv_name), \
|
|
|
|
.change_queue_depth = ata_scsi_change_queue_depth
|
|
|
|
|
2008-04-07 13:47:22 +00:00
|
|
|
/*
|
|
|
|
* PMP helpers
|
|
|
|
*/
|
2008-04-07 13:47:22 +00:00
|
|
|
#ifdef CONFIG_SATA_PMP
|
2008-04-07 13:47:22 +00:00
|
|
|
static inline bool sata_pmp_supported(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return ap->flags & ATA_FLAG_PMP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool sata_pmp_attached(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return ap->nr_pmp_links != 0;
|
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_host_link(const struct ata_link *link)
|
2008-04-07 13:47:22 +00:00
|
|
|
{
|
libata: implement slave_link
Explanation taken from the comment of ata_slave_link_init().
In libata, a port contains links and a link contains devices. There
is single host link but if a PMP is attached to it, there can be
multiple fan-out links. On SATA, there's usually a single device
connected to a link but PATA and SATA controllers emulating TF based
interface can have two - master and slave.
However, there are a few controllers which don't fit into this
abstraction too well - SATA controllers which emulate TF interface
with both master and slave devices but also have separate SCR
register sets for each device. These controllers need separate links
for physical link handling (e.g. onlineness, link speed) but should
be treated like a traditional M/S controller for everything else
(e.g. command issue, softreset).
slave_link is libata's way of handling this class of controllers
without impacting core layer too much. For anything other than
physical link handling, the default host link is used for both master
and slave. For physical link handling, separate @ap->slave_link is
used. All dirty details are implemented inside libata core layer.
From LLD's POV, the only difference is that prereset, hardreset and
postreset are called once more for the slave link, so the reset
sequence looks like the following.
prereset(M) -> prereset(S) -> hardreset(M) -> hardreset(S) ->
softreset(M) -> postreset(M) -> postreset(S)
Note that softreset is called only for the master. Softreset resets
both M/S by definition, so SRST on master should handle both (the
standard method will work just fine).
As slave_link excludes PMP support and only code paths which deal with
the attributes of physical link are affected, all the changes are
localized to libata.h, libata-core.c and libata-eh.c.
* ata_is_host_link() updated so that slave_link is considered as host
link too.
* iterator extended to iterate over the slave_link when using the
underbarred version.
* force param handling updated such that devno 16 is mapped to the
slave link/device.
* ata_link_on/offline() updated to return the combined result from
master and slave link. ata_phys_link_on/offline() are the direct
versions.
* EH autopsy and report are performed separately for master slave
links. Reset is udpated to implement the above described reset
sequence.
Except for reset update, most changes are minor, many of them just
modifying dev->link to ata_dev_phys_link(dev) or using phys online
test instead.
After this update, LLDs can take full advantage of per-dev SCR
registers by simply turning on slave link.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2008-07-31 08:02:43 +00:00
|
|
|
return link == &link->ap->link || link == link->ap->slave_link;
|
2008-04-07 13:47:22 +00:00
|
|
|
}
|
2008-04-07 13:47:22 +00:00
|
|
|
#else /* CONFIG_SATA_PMP */
|
|
|
|
static inline bool sata_pmp_supported(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool sata_pmp_attached(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-07-14 00:05:42 +00:00
|
|
|
static inline bool ata_is_host_link(const struct ata_link *link)
|
2008-04-07 13:47:22 +00:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SATA_PMP */
|
2008-04-07 13:47:22 +00:00
|
|
|
|
|
|
|
static inline int sata_srst_pmp(struct ata_link *link)
|
|
|
|
{
|
|
|
|
if (sata_pmp_supported(link->ap) && ata_is_host_link(link))
|
|
|
|
return SATA_PMP_CTRL_PORT;
|
|
|
|
return link->pmp;
|
|
|
|
}
|
|
|
|
|
2006-05-15 11:57:55 +00:00
|
|
|
/*
|
|
|
|
* printk helpers
|
|
|
|
*/
|
2011-11-01 00:11:33 +00:00
|
|
|
__printf(3, 4)
|
2014-09-22 16:52:18 +00:00
|
|
|
void ata_port_printk(const struct ata_port *ap, const char *level,
|
|
|
|
const char *fmt, ...);
|
2011-11-01 00:11:33 +00:00
|
|
|
__printf(3, 4)
|
2014-09-22 16:52:18 +00:00
|
|
|
void ata_link_printk(const struct ata_link *link, const char *level,
|
|
|
|
const char *fmt, ...);
|
2011-11-01 00:11:33 +00:00
|
|
|
__printf(3, 4)
|
2014-09-22 16:52:18 +00:00
|
|
|
void ata_dev_printk(const struct ata_device *dev, const char *level,
|
|
|
|
const char *fmt, ...);
|
ata: Convert ata_<foo>_printk(KERN_<LEVEL> to ata_<foo>_<level>
Saves text by removing nearly duplicated text format strings by
creating ata_<foo>_printk functions and printf extension %pV.
ata defconfig size shrinks ~5% (~8KB), allyesconfig ~2.5% (~13KB)
Format string duplication comes from:
#define ata_link_printk(link, lv, fmt, args...) do { \
if (sata_pmp_attached((link)->ap) || (link)->ap->slave_link) \
printk("%sata%u.%02u: "fmt, lv, (link)->ap->print_id, \
(link)->pmp , ##args); \
else \
printk("%sata%u: "fmt, lv, (link)->ap->print_id , ##args); \
} while(0)
Coalesce long formats.
$ size drivers/ata/built-in.*
text data bss dec hex filename
544969 73893 116584 735446 b38d6 drivers/ata/built-in.allyesconfig.ata.o
558429 73893 117864 750186 b726a drivers/ata/built-in.allyesconfig.dev_level.o
141328 14689 4220 160237 271ed drivers/ata/built-in.defconfig.ata.o
149567 14689 4220 168476 2921c drivers/ata/built-in.defconfig.dev_level.o
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
2011-04-15 22:51:59 +00:00
|
|
|
|
|
|
|
#define ata_port_err(ap, fmt, ...) \
|
|
|
|
ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_port_warn(ap, fmt, ...) \
|
|
|
|
ata_port_printk(ap, KERN_WARNING, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_port_notice(ap, fmt, ...) \
|
|
|
|
ata_port_printk(ap, KERN_NOTICE, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_port_info(ap, fmt, ...) \
|
|
|
|
ata_port_printk(ap, KERN_INFO, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_port_dbg(ap, fmt, ...) \
|
|
|
|
ata_port_printk(ap, KERN_DEBUG, fmt, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
#define ata_link_err(link, fmt, ...) \
|
|
|
|
ata_link_printk(link, KERN_ERR, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_link_warn(link, fmt, ...) \
|
|
|
|
ata_link_printk(link, KERN_WARNING, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_link_notice(link, fmt, ...) \
|
|
|
|
ata_link_printk(link, KERN_NOTICE, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_link_info(link, fmt, ...) \
|
|
|
|
ata_link_printk(link, KERN_INFO, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_link_dbg(link, fmt, ...) \
|
|
|
|
ata_link_printk(link, KERN_DEBUG, fmt, ##__VA_ARGS__)
|
|
|
|
|
|
|
|
#define ata_dev_err(dev, fmt, ...) \
|
|
|
|
ata_dev_printk(dev, KERN_ERR, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_dev_warn(dev, fmt, ...) \
|
|
|
|
ata_dev_printk(dev, KERN_WARNING, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_dev_notice(dev, fmt, ...) \
|
|
|
|
ata_dev_printk(dev, KERN_NOTICE, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_dev_info(dev, fmt, ...) \
|
|
|
|
ata_dev_printk(dev, KERN_INFO, fmt, ##__VA_ARGS__)
|
|
|
|
#define ata_dev_dbg(dev, fmt, ...) \
|
|
|
|
ata_dev_printk(dev, KERN_DEBUG, fmt, ##__VA_ARGS__)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-04-15 22:52:00 +00:00
|
|
|
void ata_print_version(const struct device *dev, const char *version);
|
|
|
|
|
2006-05-15 11:58:21 +00:00
|
|
|
/*
|
|
|
|
* ata_eh_info helpers
|
|
|
|
*/
|
2011-11-01 00:11:33 +00:00
|
|
|
extern __printf(2, 3)
|
|
|
|
void __ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
|
|
|
|
extern __printf(2, 3)
|
|
|
|
void ata_ehi_push_desc(struct ata_eh_info *ehi, const char *fmt, ...);
|
2007-07-16 05:29:39 +00:00
|
|
|
extern void ata_ehi_clear_desc(struct ata_eh_info *ehi);
|
2006-05-15 11:58:21 +00:00
|
|
|
|
2006-07-03 07:07:26 +00:00
|
|
|
static inline void ata_ehi_hotplugged(struct ata_eh_info *ehi)
|
|
|
|
{
|
2008-01-23 15:05:14 +00:00
|
|
|
ehi->probe_mask |= (1 << ATA_MAX_DEVICES) - 1;
|
2007-07-16 05:29:40 +00:00
|
|
|
ehi->flags |= ATA_EHI_HOTPLUGGED;
|
2008-01-23 15:05:14 +00:00
|
|
|
ehi->action |= ATA_EH_RESET | ATA_EH_ENABLE_LINK;
|
2006-07-03 07:07:26 +00:00
|
|
|
ehi->err_mask |= AC_ERR_ATA_BUS;
|
|
|
|
}
|
|
|
|
|
2007-08-18 04:14:55 +00:00
|
|
|
/*
|
|
|
|
* port description helpers
|
|
|
|
*/
|
2011-11-01 00:11:33 +00:00
|
|
|
extern __printf(2, 3)
|
|
|
|
void ata_port_desc(struct ata_port *ap, const char *fmt, ...);
|
2007-08-18 04:14:55 +00:00
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
|
|
|
|
const char *name);
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline unsigned int ata_tag_valid(unsigned int tag)
|
|
|
|
{
|
|
|
|
return (tag < ATA_MAX_QUEUE) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
2006-05-15 11:58:02 +00:00
|
|
|
static inline unsigned int ata_tag_internal(unsigned int tag)
|
|
|
|
{
|
2008-02-28 12:43:13 +00:00
|
|
|
return tag == ATA_TAG_INTERNAL;
|
2006-05-15 11:58:02 +00:00
|
|
|
}
|
|
|
|
|
2006-06-24 11:30:19 +00:00
|
|
|
/*
|
|
|
|
* device helpers
|
|
|
|
*/
|
2006-03-31 16:38:18 +00:00
|
|
|
static inline unsigned int ata_class_enabled(unsigned int class)
|
2006-02-28 16:25:38 +00:00
|
|
|
{
|
2007-09-23 04:14:12 +00:00
|
|
|
return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
|
2014-11-05 12:08:21 +00:00
|
|
|
class == ATA_DEV_PMP || class == ATA_DEV_SEMB ||
|
|
|
|
class == ATA_DEV_ZAC;
|
2006-02-28 16:25:38 +00:00
|
|
|
}
|
|
|
|
|
2006-03-31 16:38:18 +00:00
|
|
|
static inline unsigned int ata_class_disabled(unsigned int class)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-09-23 04:14:12 +00:00
|
|
|
return class == ATA_DEV_ATA_UNSUP || class == ATA_DEV_ATAPI_UNSUP ||
|
2016-04-25 10:45:51 +00:00
|
|
|
class == ATA_DEV_PMP_UNSUP || class == ATA_DEV_SEMB_UNSUP ||
|
|
|
|
class == ATA_DEV_ZAC_UNSUP;
|
2006-03-31 16:38:18 +00:00
|
|
|
}
|
|
|
|
|
2006-04-02 08:54:46 +00:00
|
|
|
static inline unsigned int ata_class_absent(unsigned int class)
|
|
|
|
{
|
|
|
|
return !ata_class_enabled(class) && !ata_class_disabled(class);
|
|
|
|
}
|
|
|
|
|
2006-03-31 16:38:18 +00:00
|
|
|
static inline unsigned int ata_dev_enabled(const struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return ata_class_enabled(dev->class);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int ata_dev_disabled(const struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return ata_class_disabled(dev->class);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-04-02 08:54:46 +00:00
|
|
|
static inline unsigned int ata_dev_absent(const struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return ata_class_absent(dev->class);
|
|
|
|
}
|
|
|
|
|
2006-06-24 11:30:19 +00:00
|
|
|
/*
|
2007-08-06 09:36:23 +00:00
|
|
|
* link helpers
|
2006-06-24 11:30:19 +00:00
|
|
|
*/
|
2007-08-06 09:36:23 +00:00
|
|
|
static inline int ata_link_max_devices(const struct ata_link *link)
|
2006-06-24 11:30:19 +00:00
|
|
|
{
|
2007-08-06 09:36:23 +00:00
|
|
|
if (ata_is_host_link(link) && link->ap->flags & ATA_FLAG_SLAVE_POSS)
|
2006-06-24 11:30:19 +00:00
|
|
|
return 2;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-09-23 04:14:12 +00:00
|
|
|
static inline int ata_link_active(struct ata_link *link)
|
|
|
|
{
|
|
|
|
return ata_tag_valid(link->active_tag) || link->sactive;
|
|
|
|
}
|
|
|
|
|
2008-11-03 11:03:17 +00:00
|
|
|
/*
|
|
|
|
* Iterators
|
|
|
|
*
|
|
|
|
* ATA_LITER_* constants are used to select link iteration mode and
|
|
|
|
* ATA_DITER_* device iteration mode.
|
|
|
|
*
|
|
|
|
* For a custom iteration directly using ata_{link|dev}_next(), if
|
|
|
|
* @link or @dev, respectively, is NULL, the first element is
|
|
|
|
* returned. @dev and @link can be any valid device or link and the
|
|
|
|
* next element according to the iteration mode will be returned.
|
|
|
|
* After the last element, NULL is returned.
|
|
|
|
*/
|
|
|
|
enum ata_link_iter_mode {
|
|
|
|
ATA_LITER_EDGE, /* if present, PMP links only; otherwise,
|
|
|
|
* host link. no slave link */
|
|
|
|
ATA_LITER_HOST_FIRST, /* host link followed by PMP or slave links */
|
|
|
|
ATA_LITER_PMP_FIRST, /* PMP links followed by host link,
|
|
|
|
* slave link still comes after host link */
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ata_dev_iter_mode {
|
|
|
|
ATA_DITER_ENABLED,
|
|
|
|
ATA_DITER_ENABLED_REVERSE,
|
|
|
|
ATA_DITER_ALL,
|
|
|
|
ATA_DITER_ALL_REVERSE,
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct ata_link *ata_link_next(struct ata_link *link,
|
|
|
|
struct ata_port *ap,
|
|
|
|
enum ata_link_iter_mode mode);
|
|
|
|
|
|
|
|
extern struct ata_device *ata_dev_next(struct ata_device *dev,
|
|
|
|
struct ata_link *link,
|
|
|
|
enum ata_dev_iter_mode mode);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Shortcut notation for iterations
|
|
|
|
*
|
|
|
|
* ata_for_each_link() iterates over each link of @ap according to
|
|
|
|
* @mode. @link points to the current link in the loop. @link is
|
|
|
|
* NULL after loop termination. ata_for_each_dev() works the same way
|
|
|
|
* except that it iterates over each device of @link.
|
|
|
|
*
|
|
|
|
* Note that the mode prefixes ATA_{L|D}ITER_ shouldn't need to be
|
|
|
|
* specified when using the following shorthand notations. Only the
|
|
|
|
* mode itself (EDGE, HOST_FIRST, ENABLED, etc...) should be
|
|
|
|
* specified. This not only increases brevity but also makes it
|
|
|
|
* impossible to use ATA_LITER_* for device iteration or vice-versa.
|
|
|
|
*/
|
|
|
|
#define ata_for_each_link(link, ap, mode) \
|
|
|
|
for ((link) = ata_link_next(NULL, (ap), ATA_LITER_##mode); (link); \
|
|
|
|
(link) = ata_link_next((link), (ap), ATA_LITER_##mode))
|
|
|
|
|
|
|
|
#define ata_for_each_dev(dev, link, mode) \
|
|
|
|
for ((dev) = ata_dev_next(NULL, (link), ATA_DITER_##mode); (dev); \
|
|
|
|
(dev) = ata_dev_next((dev), (link), ATA_DITER_##mode))
|
2006-06-24 11:30:19 +00:00
|
|
|
|
2007-02-20 14:20:27 +00:00
|
|
|
/**
|
|
|
|
* ata_ncq_enabled - Test whether NCQ is enabled
|
|
|
|
* @dev: ATA device to test for
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* spin_lock_irqsave(host lock)
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* 1 if NCQ is enabled for @dev, 0 otherwise.
|
|
|
|
*/
|
|
|
|
static inline int ata_ncq_enabled(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return (dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
|
|
|
|
ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ;
|
|
|
|
}
|
2005-06-02 22:17:13 +00:00
|
|
|
|
2013-08-25 06:22:51 +00:00
|
|
|
static inline bool ata_fpdma_dsm_supported(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
|
|
|
|
(dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &
|
|
|
|
ATA_LOG_NCQ_SEND_RECV_DSM_TRIM);
|
|
|
|
}
|
|
|
|
|
2016-04-25 10:45:47 +00:00
|
|
|
static inline bool ata_fpdma_read_log_supported(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
|
|
|
|
(dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET] &
|
|
|
|
ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED);
|
|
|
|
}
|
|
|
|
|
2016-04-25 10:45:52 +00:00
|
|
|
static inline bool ata_fpdma_zac_mgmt_in_supported(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return (dev->flags & ATA_DFLAG_NCQ_SEND_RECV) &&
|
|
|
|
(dev->ncq_send_recv_cmds[ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET] &
|
|
|
|
ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED);
|
|
|
|
}
|
|
|
|
|
2016-04-25 10:45:54 +00:00
|
|
|
static inline bool ata_fpdma_zac_mgmt_out_supported(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return (dev->ncq_non_data_cmds[ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET] &
|
|
|
|
ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
qc->tf.ctl |= ATA_NIEN;
|
|
|
|
}
|
|
|
|
|
2006-05-15 11:58:03 +00:00
|
|
|
static inline struct ata_queued_cmd *__ata_qc_from_tag(struct ata_port *ap,
|
|
|
|
unsigned int tag)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (likely(ata_tag_valid(tag)))
|
|
|
|
return &ap->qcmd[tag];
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-05-15 11:58:03 +00:00
|
|
|
static inline struct ata_queued_cmd *ata_qc_from_tag(struct ata_port *ap,
|
|
|
|
unsigned int tag)
|
|
|
|
{
|
|
|
|
struct ata_queued_cmd *qc = __ata_qc_from_tag(ap, tag);
|
|
|
|
|
|
|
|
if (unlikely(!qc) || !ap->ops->error_handler)
|
|
|
|
return qc;
|
|
|
|
|
|
|
|
if ((qc->flags & (ATA_QCFLAG_ACTIVE |
|
|
|
|
ATA_QCFLAG_FAILED)) == ATA_QCFLAG_ACTIVE)
|
|
|
|
return qc;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-03-18 08:47:43 +00:00
|
|
|
static inline unsigned int ata_qc_raw_nbytes(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
return qc->nbytes - min(qc->extrabytes, qc->nbytes);
|
|
|
|
}
|
|
|
|
|
2006-05-15 11:57:53 +00:00
|
|
|
static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
memset(tf, 0, sizeof(*tf));
|
|
|
|
|
2010-05-10 19:41:37 +00:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
2007-08-06 09:36:22 +00:00
|
|
|
tf->ctl = dev->link->ap->ctl;
|
2010-05-10 19:41:37 +00:00
|
|
|
#else
|
|
|
|
tf->ctl = ATA_DEVCTL_OBS;
|
|
|
|
#endif
|
2006-05-15 11:57:53 +00:00
|
|
|
if (dev->devno == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
tf->device = ATA_DEVICE_OBS;
|
|
|
|
else
|
|
|
|
tf->device = ATA_DEVICE_OBS | ATA_DEV1;
|
|
|
|
}
|
|
|
|
|
2005-11-14 19:14:16 +00:00
|
|
|
static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
|
|
|
|
{
|
2007-01-17 02:34:02 +00:00
|
|
|
qc->dma_dir = DMA_NONE;
|
2007-12-05 07:43:11 +00:00
|
|
|
qc->sg = NULL;
|
2005-11-14 19:14:16 +00:00
|
|
|
qc->flags = 0;
|
2007-10-16 09:14:12 +00:00
|
|
|
qc->cursg = NULL;
|
|
|
|
qc->cursg_ofs = 0;
|
2008-03-18 08:47:43 +00:00
|
|
|
qc->nbytes = qc->extrabytes = qc->curbytes = 0;
|
2007-01-17 18:32:12 +00:00
|
|
|
qc->n_elem = 0;
|
2005-12-05 07:38:02 +00:00
|
|
|
qc->err_mask = 0;
|
2007-03-16 14:22:26 +00:00
|
|
|
qc->sect_size = ATA_SECT_SIZE;
|
2005-11-14 19:14:16 +00:00
|
|
|
|
2006-05-15 11:57:53 +00:00
|
|
|
ata_tf_init(qc->dev, &qc->tf);
|
2006-05-15 11:57:40 +00:00
|
|
|
|
|
|
|
/* init result_tf such that it indicates normal completion */
|
|
|
|
qc->result_tf.command = ATA_DRDY;
|
|
|
|
qc->result_tf.feature = 0;
|
2005-11-14 19:14:16 +00:00
|
|
|
}
|
|
|
|
|
2005-10-22 18:27:05 +00:00
|
|
|
static inline int ata_try_flush_cache(const struct ata_device *dev)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return ata_id_wcache_enabled(dev->id) ||
|
|
|
|
ata_id_has_flush(dev->id) ||
|
|
|
|
ata_id_has_flush_ext(dev->id);
|
|
|
|
}
|
|
|
|
|
2005-10-30 09:44:42 +00:00
|
|
|
static inline unsigned int ac_err_mask(u8 status)
|
|
|
|
{
|
2006-05-19 03:43:04 +00:00
|
|
|
if (status & (ATA_BUSY | ATA_DRQ))
|
2006-01-23 04:09:36 +00:00
|
|
|
return AC_ERR_HSM;
|
2005-10-30 09:44:42 +00:00
|
|
|
if (status & (ATA_ERR | ATA_DF))
|
|
|
|
return AC_ERR_DEV;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int __ac_err_mask(u8 status)
|
|
|
|
{
|
|
|
|
unsigned int mask = ac_err_mask(status);
|
|
|
|
if (mask == 0)
|
|
|
|
return AC_ERR_OTHER;
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2006-04-11 17:12:34 +00:00
|
|
|
static inline struct ata_port *ata_shost_to_port(struct Scsi_Host *host)
|
|
|
|
{
|
2007-04-17 14:44:06 +00:00
|
|
|
return *(struct ata_port **)&host->hostdata[0];
|
2006-04-11 17:12:34 +00:00
|
|
|
}
|
|
|
|
|
2008-05-01 14:41:41 +00:00
|
|
|
static inline int ata_check_ready(u8 status)
|
|
|
|
{
|
2008-05-09 19:00:55 +00:00
|
|
|
if (!(status & ATA_BUSY))
|
|
|
|
return 1;
|
2008-05-01 14:41:41 +00:00
|
|
|
|
|
|
|
/* 0xff indicates either no device or device not ready */
|
|
|
|
if (status == 0xff)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2008-05-09 19:00:55 +00:00
|
|
|
return 0;
|
2008-05-01 14:41:41 +00:00
|
|
|
}
|
|
|
|
|
2008-05-19 17:17:51 +00:00
|
|
|
static inline unsigned long ata_deadline(unsigned long from_jiffies,
|
|
|
|
unsigned long timeout_msecs)
|
|
|
|
{
|
|
|
|
return from_jiffies + msecs_to_jiffies(timeout_msecs);
|
|
|
|
}
|
|
|
|
|
2008-08-01 08:18:34 +00:00
|
|
|
/* Don't open code these in drivers as there are traps. Firstly the range may
|
|
|
|
change in future hardware and specs, secondly 0xFF means 'no DMA' but is
|
|
|
|
> UDMA_0. Dyma ddreigiau */
|
|
|
|
|
|
|
|
static inline int ata_using_mwdma(struct ata_device *adev)
|
|
|
|
{
|
|
|
|
if (adev->dma_mode >= XFER_MW_DMA_0 && adev->dma_mode <= XFER_MW_DMA_4)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ata_using_udma(struct ata_device *adev)
|
|
|
|
{
|
|
|
|
if (adev->dma_mode >= XFER_UDMA_0 && adev->dma_mode <= XFER_UDMA_7)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ata_dma_enabled(struct ata_device *adev)
|
|
|
|
{
|
|
|
|
return (adev->dma_mode == 0xFF ? 0 : 1);
|
|
|
|
}
|
2008-04-07 13:47:21 +00:00
|
|
|
|
|
|
|
/**************************************************************************
|
|
|
|
* PMP - drivers/ata/libata-pmp.c
|
|
|
|
*/
|
2008-04-07 13:47:22 +00:00
|
|
|
#ifdef CONFIG_SATA_PMP
|
|
|
|
|
2008-04-07 13:47:21 +00:00
|
|
|
extern const struct ata_port_operations sata_pmp_port_ops;
|
|
|
|
|
|
|
|
extern int sata_pmp_qc_defer_cmd_switch(struct ata_queued_cmd *qc);
|
|
|
|
extern void sata_pmp_error_handler(struct ata_port *ap);
|
|
|
|
|
2008-04-07 13:47:22 +00:00
|
|
|
#else /* CONFIG_SATA_PMP */
|
|
|
|
|
|
|
|
#define sata_pmp_port_ops sata_port_ops
|
|
|
|
#define sata_pmp_qc_defer_cmd_switch ata_std_qc_defer
|
|
|
|
#define sata_pmp_error_handler ata_std_error_handler
|
|
|
|
|
|
|
|
#endif /* CONFIG_SATA_PMP */
|
|
|
|
|
2008-04-07 13:47:21 +00:00
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/**************************************************************************
|
|
|
|
* SFF - drivers/ata/libata-sff.c
|
|
|
|
*/
|
2008-04-07 13:47:21 +00:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
extern const struct ata_port_operations ata_sff_port_ops;
|
2009-01-05 14:16:39 +00:00
|
|
|
extern const struct ata_port_operations ata_bmdma32_port_ops;
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
|
|
|
|
/* PIO only, sg_tablesize and dma_boundary limits can be removed */
|
|
|
|
#define ATA_PIO_SHT(drv_name) \
|
|
|
|
ATA_BASE_SHT(drv_name), \
|
|
|
|
.sg_tablesize = LIBATA_MAX_PRD, \
|
|
|
|
.dma_boundary = ATA_DMA_BOUNDARY
|
|
|
|
|
2008-04-07 13:47:16 +00:00
|
|
|
extern void ata_sff_dev_select(struct ata_port *ap, unsigned int device);
|
|
|
|
extern u8 ata_sff_check_status(struct ata_port *ap);
|
2008-05-29 21:10:58 +00:00
|
|
|
extern void ata_sff_pause(struct ata_port *ap);
|
|
|
|
extern void ata_sff_dma_pause(struct ata_port *ap);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int ata_sff_busy_sleep(struct ata_port *ap,
|
|
|
|
unsigned long timeout_pat, unsigned long timeout);
|
2008-04-07 13:47:19 +00:00
|
|
|
extern int ata_sff_wait_ready(struct ata_link *link, unsigned long deadline);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern void ata_sff_tf_load(struct ata_port *ap, const struct ata_taskfile *tf);
|
|
|
|
extern void ata_sff_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
|
|
|
|
extern void ata_sff_exec_command(struct ata_port *ap,
|
|
|
|
const struct ata_taskfile *tf);
|
2016-12-30 14:01:17 +00:00
|
|
|
extern unsigned int ata_sff_data_xfer(struct ata_queued_cmd *qc,
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
unsigned char *buf, unsigned int buflen, int rw);
|
2016-12-30 14:01:17 +00:00
|
|
|
extern unsigned int ata_sff_data_xfer32(struct ata_queued_cmd *qc,
|
2009-01-05 14:16:39 +00:00
|
|
|
unsigned char *buf, unsigned int buflen, int rw);
|
2016-12-30 14:01:17 +00:00
|
|
|
extern unsigned int ata_sff_data_xfer_noirq(struct ata_queued_cmd *qc,
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
unsigned char *buf, unsigned int buflen, int rw);
|
2010-05-07 18:49:02 +00:00
|
|
|
extern void ata_sff_irq_on(struct ata_port *ap);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern void ata_sff_irq_clear(struct ata_port *ap);
|
|
|
|
extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
|
|
|
|
u8 status, int in_wq);
|
2011-02-22 09:02:38 +00:00
|
|
|
extern void ata_sff_queue_work(struct work_struct *work);
|
|
|
|
extern void ata_sff_queue_delayed_work(struct delayed_work *dwork,
|
|
|
|
unsigned long delay);
|
2010-08-31 23:20:36 +00:00
|
|
|
extern void ata_sff_queue_pio_task(struct ata_link *link, unsigned long delay);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern unsigned int ata_sff_qc_issue(struct ata_queued_cmd *qc);
|
2008-04-07 13:47:20 +00:00
|
|
|
extern bool ata_sff_qc_fill_rtf(struct ata_queued_cmd *qc);
|
2010-05-19 20:10:21 +00:00
|
|
|
extern unsigned int ata_sff_port_intr(struct ata_port *ap,
|
2008-04-07 13:47:16 +00:00
|
|
|
struct ata_queued_cmd *qc);
|
|
|
|
extern irqreturn_t ata_sff_interrupt(int irq, void *dev_instance);
|
2009-03-24 10:23:46 +00:00
|
|
|
extern void ata_sff_lost_interrupt(struct ata_port *ap);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern void ata_sff_freeze(struct ata_port *ap);
|
|
|
|
extern void ata_sff_thaw(struct ata_port *ap);
|
|
|
|
extern int ata_sff_prereset(struct ata_link *link, unsigned long deadline);
|
|
|
|
extern unsigned int ata_sff_dev_classify(struct ata_device *dev, int present,
|
|
|
|
u8 *r_err);
|
2008-04-07 13:47:19 +00:00
|
|
|
extern int ata_sff_wait_after_reset(struct ata_link *link, unsigned int devmask,
|
|
|
|
unsigned long deadline);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int ata_sff_softreset(struct ata_link *link, unsigned int *classes,
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
unsigned long deadline);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int sata_sff_hardreset(struct ata_link *link, unsigned int *class,
|
|
|
|
unsigned long deadline);
|
|
|
|
extern void ata_sff_postreset(struct ata_link *link, unsigned int *classes);
|
2009-03-24 10:23:19 +00:00
|
|
|
extern void ata_sff_drain_fifo(struct ata_queued_cmd *qc);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern void ata_sff_error_handler(struct ata_port *ap);
|
|
|
|
extern void ata_sff_std_ports(struct ata_ioports *ioaddr);
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
#ifdef CONFIG_PCI
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int ata_pci_sff_init_host(struct ata_host *host);
|
|
|
|
extern int ata_pci_sff_prepare_host(struct pci_dev *pdev,
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
const struct ata_port_info * const * ppi,
|
|
|
|
struct ata_host **r_host);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int ata_pci_sff_activate_host(struct ata_host *host,
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
irq_handler_t irq_handler,
|
|
|
|
struct scsi_host_template *sht);
|
2008-04-07 13:47:16 +00:00
|
|
|
extern int ata_pci_sff_init_one(struct pci_dev *pdev,
|
2010-02-23 07:26:06 +00:00
|
|
|
const struct ata_port_info * const * ppi,
|
|
|
|
struct scsi_host_template *sht, void *host_priv, int hflags);
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
#endif /* CONFIG_PCI */
|
|
|
|
|
2010-05-19 20:10:24 +00:00
|
|
|
#ifdef CONFIG_ATA_BMDMA
|
|
|
|
|
|
|
|
extern const struct ata_port_operations ata_bmdma_port_ops;
|
|
|
|
|
|
|
|
#define ATA_BMDMA_SHT(drv_name) \
|
|
|
|
ATA_BASE_SHT(drv_name), \
|
|
|
|
.sg_tablesize = LIBATA_MAX_PRD, \
|
|
|
|
.dma_boundary = ATA_DMA_BOUNDARY
|
|
|
|
|
2010-05-10 19:41:40 +00:00
|
|
|
extern void ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
|
2010-05-10 19:41:42 +00:00
|
|
|
extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
|
2010-05-10 19:41:40 +00:00
|
|
|
extern void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
|
2010-05-19 20:10:21 +00:00
|
|
|
extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
|
|
|
|
struct ata_queued_cmd *qc);
|
|
|
|
extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);
|
2010-05-10 19:41:39 +00:00
|
|
|
extern void ata_bmdma_error_handler(struct ata_port *ap);
|
|
|
|
extern void ata_bmdma_post_internal_cmd(struct ata_queued_cmd *qc);
|
2010-05-19 20:10:20 +00:00
|
|
|
extern void ata_bmdma_irq_clear(struct ata_port *ap);
|
2010-05-10 19:41:32 +00:00
|
|
|
extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
|
|
|
|
extern void ata_bmdma_start(struct ata_queued_cmd *qc);
|
|
|
|
extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
|
|
|
|
extern u8 ata_bmdma_status(struct ata_port *ap);
|
libata-sff: clean up BMDMA initialization
When BMDMA initialization failed or BMDMA was not available for
whatever reason, bmdma_addr was left at zero and used as an indication
that BMDMA shouldn't be used. This leads to the following problems.
p1. For BMDMA drivers which don't use traditional BMDMA register,
ata_bmdma_mode_filter() incorrectly inhibits DMA modes. Those
drivers either have to inherit from ata_sff_port_ops or clear
->mode_filter explicitly.
p2. non-BMDMA drivers call into BMDMA PRD table allocation. It
doesn't actually allocate PRD table if bmdma_addr is not
initialized but is still confusing.
p3. For BMDMA drivers which don't use traditional BMDMA register, some
methods might not be invoked as expected (e.g. bmdma_stop from
ata_sff_post_internal_cmd()).
p4. SFF drivers w/ custom DMA interface implement noop BMDMA ops
worrying libata core might call into one of them.
These problems are caused by the muddy line between SFF and BMDMA and
the assumption that all BMDMA controllers initialize bmdma_addr.
This patch fixes p1 and p2 by removing the bmdma_addr assumption and
moving prd allocation to BMDMA port start. Later patches will fix the
remaining issues.
This patch improves BMDMA initialization such that
* When BMDMA register initialization fails, falls back to PIO instead
of failing. ata_pci_bmdma_init() never fails now.
* When ata_pci_bmdma_init() falls back to PIO, it clears
ap->mwdma_mask and udma_mask instead of depending on
ata_bmdma_mode_filter(). This makes ata_bmdma_mode_filter()
unnecessary thus resolving p1.
* ata_port_start() which actually is BMDMA specific is moved to
ata_bmdma_port_start(). ata_port_start() and ata_sff_port_start()
are killed.
* ata_sff_port_start32() is moved and renamed to
ata_bmdma_port_start32().
Drivers which no longer call into PRD table allocation are...
pdc_adma, sata_inic162x, sata_qstor, sata_sx4, pata_cmd640 and all
drivers which inherit from ata_sff_port_ops.
pata_icside sets ->port_start to ATA_OP_NULL as it doesn't need PRD
but is a BMDMA controller and doesn't have custom port_start like
other such controllers.
Note that with the previous patch which makes all and only BMDMA
drivers inherit from ata_bmdma_port_ops, this change doesn't break
drivers which need PRD table.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2010-05-10 19:41:34 +00:00
|
|
|
extern int ata_bmdma_port_start(struct ata_port *ap);
|
|
|
|
extern int ata_bmdma_port_start32(struct ata_port *ap);
|
2010-05-10 19:41:32 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
extern int ata_pci_bmdma_clear_simplex(struct pci_dev *pdev);
|
libata-sff: clean up BMDMA initialization
When BMDMA initialization failed or BMDMA was not available for
whatever reason, bmdma_addr was left at zero and used as an indication
that BMDMA shouldn't be used. This leads to the following problems.
p1. For BMDMA drivers which don't use traditional BMDMA register,
ata_bmdma_mode_filter() incorrectly inhibits DMA modes. Those
drivers either have to inherit from ata_sff_port_ops or clear
->mode_filter explicitly.
p2. non-BMDMA drivers call into BMDMA PRD table allocation. It
doesn't actually allocate PRD table if bmdma_addr is not
initialized but is still confusing.
p3. For BMDMA drivers which don't use traditional BMDMA register, some
methods might not be invoked as expected (e.g. bmdma_stop from
ata_sff_post_internal_cmd()).
p4. SFF drivers w/ custom DMA interface implement noop BMDMA ops
worrying libata core might call into one of them.
These problems are caused by the muddy line between SFF and BMDMA and
the assumption that all BMDMA controllers initialize bmdma_addr.
This patch fixes p1 and p2 by removing the bmdma_addr assumption and
moving prd allocation to BMDMA port start. Later patches will fix the
remaining issues.
This patch improves BMDMA initialization such that
* When BMDMA register initialization fails, falls back to PIO instead
of failing. ata_pci_bmdma_init() never fails now.
* When ata_pci_bmdma_init() falls back to PIO, it clears
ap->mwdma_mask and udma_mask instead of depending on
ata_bmdma_mode_filter(). This makes ata_bmdma_mode_filter()
unnecessary thus resolving p1.
* ata_port_start() which actually is BMDMA specific is moved to
ata_bmdma_port_start(). ata_port_start() and ata_sff_port_start()
are killed.
* ata_sff_port_start32() is moved and renamed to
ata_bmdma_port_start32().
Drivers which no longer call into PRD table allocation are...
pdc_adma, sata_inic162x, sata_qstor, sata_sx4, pata_cmd640 and all
drivers which inherit from ata_sff_port_ops.
pata_icside sets ->port_start to ATA_OP_NULL as it doesn't need PRD
but is a BMDMA controller and doesn't have custom port_start like
other such controllers.
Note that with the previous patch which makes all and only BMDMA
drivers inherit from ata_bmdma_port_ops, this change doesn't break
drivers which need PRD table.
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
2010-05-10 19:41:34 +00:00
|
|
|
extern void ata_pci_bmdma_init(struct ata_host *host);
|
2010-05-19 20:10:22 +00:00
|
|
|
extern int ata_pci_bmdma_prepare_host(struct pci_dev *pdev,
|
|
|
|
const struct ata_port_info * const * ppi,
|
|
|
|
struct ata_host **r_host);
|
|
|
|
extern int ata_pci_bmdma_init_one(struct pci_dev *pdev,
|
|
|
|
const struct ata_port_info * const * ppi,
|
|
|
|
struct scsi_host_template *sht,
|
|
|
|
void *host_priv, int hflags);
|
2010-05-10 19:41:32 +00:00
|
|
|
#endif /* CONFIG_PCI */
|
2010-05-19 20:10:24 +00:00
|
|
|
#endif /* CONFIG_ATA_BMDMA */
|
2010-05-10 19:41:32 +00:00
|
|
|
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
/**
|
2008-04-07 13:47:16 +00:00
|
|
|
* ata_sff_busy_wait - Wait for a port status register
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
* @ap: Port to wait for.
|
|
|
|
* @bits: bits that must be clear
|
|
|
|
* @max: number of 10uS waits to perform
|
|
|
|
*
|
|
|
|
* Waits up to max*10 microseconds for the selected bits in the port's
|
|
|
|
* status register to be cleared.
|
|
|
|
* Returns final value of status register.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
2008-04-07 13:47:16 +00:00
|
|
|
static inline u8 ata_sff_busy_wait(struct ata_port *ap, unsigned int bits,
|
|
|
|
unsigned int max)
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
{
|
|
|
|
u8 status;
|
|
|
|
|
|
|
|
do {
|
|
|
|
udelay(10);
|
2008-04-07 13:47:16 +00:00
|
|
|
status = ap->ops->sff_check_status(ap);
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
max--;
|
|
|
|
} while (status != 0xff && (status & bits) && (max > 0));
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ata_wait_idle - Wait for a port to be idle.
|
|
|
|
* @ap: Port to wait for.
|
|
|
|
*
|
|
|
|
* Waits up to 10ms for port's BUSY and DRQ signals to clear.
|
|
|
|
* Returns final value of status register.
|
|
|
|
*
|
|
|
|
* LOCKING:
|
|
|
|
* Inherited from caller.
|
|
|
|
*/
|
|
|
|
static inline u8 ata_wait_idle(struct ata_port *ap)
|
|
|
|
{
|
2008-04-07 13:47:16 +00:00
|
|
|
u8 status = ata_sff_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
|
|
|
|
#ifdef ATA_DEBUG
|
|
|
|
if (status != 0xff && (status & (ATA_BUSY | ATA_DRQ)))
|
|
|
|
ata_port_printk(ap, KERN_DEBUG, "abnormal Status 0x%X\n",
|
|
|
|
status);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
2008-04-07 13:47:21 +00:00
|
|
|
#endif /* CONFIG_ATA_SFF */
|
libata: reorganize SFF related stuff
* Move SFF related functions from libata-core.c to libata-sff.c.
ata_[bmdma_]sff_port_ops, ata_devchk(), ata_dev_try_classify(),
ata_std_dev_select(), ata_tf_to_host(), ata_busy_sleep(),
ata_wait_after_reset(), ata_wait_ready(), ata_bus_post_reset(),
ata_bus_softreset(), ata_bus_reset(), ata_std_softreset(),
sata_std_hardreset(), ata_fill_sg(), ata_fill_sg_dumb(),
ata_qc_prep(), ata_dump_qc_prep(), ata_data_xfer(),
ata_data_xfer_noirq(), ata_pio_sector(), ata_pio_sectors(),
atapi_send_cdb(), __atapi_pio_bytes(), atapi_pio_bytes(),
ata_hsm_ok_in_wq(), ata_hsm_qc_complete(), ata_hsm_move(),
ata_pio_task(), ata_qc_issue_prot(), ata_host_intr(),
ata_interrupt(), ata_std_ports()
* Make ata_pio_queue_task() global as it's now called from
libata-sff.c.
* Move SFF related stuff in include/linux/libata.h and
drivers/ata/libata.h into one place. While at it, move timing
constants into the global enum definition and fortify comments a
bit.
This patch strictly moves stuff around and as such doesn't cause any
functional difference.
Signed-off-by: Tejun Heo <htejun@gmail.com>
Signed-off-by: Jeff Garzik <jeff@garzik.org>
2008-03-25 13:16:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* __LINUX_LIBATA_H__ */
|