2005-04-17 02:20:36 +04:00
|
|
|
/*
|
2005-08-29 04:18:39 +04:00
|
|
|
* libata.h - helper library for ATA
|
|
|
|
*
|
|
|
|
* Copyright 2003-2004 Red Hat, Inc. All rights reserved.
|
|
|
|
* Copyright 2003-2004 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',
|
|
|
|
* as Documentation/DocBook/libata.*
|
|
|
|
*
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LIBATA_H__
|
|
|
|
#define __LIBATA_H__
|
|
|
|
|
|
|
|
#define DRV_NAME "libata"
|
2007-09-23 08:19:54 +04:00
|
|
|
#define DRV_VERSION "3.00" /* must be exactly four chars */
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
struct ata_scsi_args {
|
2006-01-06 11:56:18 +03:00
|
|
|
struct ata_device *dev;
|
2005-04-17 02:20:36 +04:00
|
|
|
u16 *id;
|
|
|
|
struct scsi_cmnd *cmd;
|
|
|
|
void (*done)(struct scsi_cmnd *);
|
|
|
|
};
|
|
|
|
|
|
|
|
/* libata-core.c */
|
2006-11-10 12:08:10 +03:00
|
|
|
enum {
|
|
|
|
/* flags for ata_dev_read_id() */
|
|
|
|
ATA_READID_POSTRESET = (1 << 0), /* reading ID after reset */
|
2007-02-02 10:22:30 +03:00
|
|
|
|
|
|
|
/* selector for ata_down_xfermask_limit() */
|
|
|
|
ATA_DNXFER_PIO = 0, /* speed down PIO */
|
|
|
|
ATA_DNXFER_DMA = 1, /* speed down DMA */
|
|
|
|
ATA_DNXFER_40C = 2, /* apply 40c cable limit */
|
|
|
|
ATA_DNXFER_FORCE_PIO = 3, /* force PIO */
|
|
|
|
ATA_DNXFER_FORCE_PIO0 = 4, /* force PIO0 */
|
|
|
|
|
|
|
|
ATA_DNXFER_QUIET = (1 << 31),
|
2006-11-10 12:08:10 +03:00
|
|
|
};
|
|
|
|
|
2007-04-17 18:44:07 +04:00
|
|
|
extern unsigned int ata_print_id;
|
2007-08-07 20:08:45 +04:00
|
|
|
extern int atapi_passthru16;
|
2006-02-28 06:31:19 +03:00
|
|
|
extern int libata_fua;
|
2007-03-28 09:57:37 +04:00
|
|
|
extern int libata_noacpi;
|
2007-11-05 06:05:49 +03:00
|
|
|
extern int libata_allow_tpm;
|
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 12:02:43 +04:00
|
|
|
extern struct ata_link *ata_dev_phys_link(struct ata_device *dev);
|
2008-02-13 03:15:09 +03:00
|
|
|
extern void ata_force_cbl(struct ata_port *ap);
|
2008-03-27 13:14:23 +03:00
|
|
|
extern u64 ata_tf_to_lba(const struct ata_taskfile *tf);
|
|
|
|
extern u64 ata_tf_to_lba48(const struct ata_taskfile *tf);
|
2008-11-10 08:48:21 +03:00
|
|
|
extern struct ata_queued_cmd *ata_qc_new_init(struct ata_device *dev);
|
2006-11-14 16:47:10 +03:00
|
|
|
extern int ata_build_rw_tf(struct ata_taskfile *tf, struct ata_device *dev,
|
|
|
|
u64 block, u32 n_block, unsigned int tf_flags,
|
|
|
|
unsigned int tag);
|
2006-11-14 16:37:35 +03:00
|
|
|
extern u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev);
|
2006-05-15 15:57:53 +04:00
|
|
|
extern unsigned ata_exec_internal(struct ata_device *dev,
|
2006-04-02 13:51:53 +04:00
|
|
|
struct ata_taskfile *tf, const u8 *cdb,
|
2007-10-09 10:05:44 +04:00
|
|
|
int dma_dir, void *buf, unsigned int buflen,
|
|
|
|
unsigned long timeout);
|
2006-11-14 16:47:09 +03:00
|
|
|
extern unsigned ata_exec_internal_sg(struct ata_device *dev,
|
|
|
|
struct ata_taskfile *tf, const u8 *cdb,
|
|
|
|
int dma_dir, struct scatterlist *sg,
|
2007-10-09 10:05:44 +04:00
|
|
|
unsigned int n_elem, unsigned long timeout);
|
2006-06-24 15:30:19 +04:00
|
|
|
extern unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd);
|
2008-04-07 17:47:19 +04:00
|
|
|
extern int ata_wait_ready(struct ata_link *link, unsigned long deadline,
|
|
|
|
int (*check_ready)(struct ata_link *link));
|
2006-05-31 13:27:44 +04:00
|
|
|
extern int ata_dev_read_id(struct ata_device *dev, unsigned int *p_class,
|
2006-11-10 12:08:10 +03:00
|
|
|
unsigned int flags, u16 *id);
|
2007-05-14 22:28:15 +04:00
|
|
|
extern int ata_dev_reread_id(struct ata_device *dev, unsigned int readid_flags);
|
2007-09-23 08:14:12 +04:00
|
|
|
extern int ata_dev_revalidate(struct ata_device *dev, unsigned int new_class,
|
|
|
|
unsigned int readid_flags);
|
2006-11-01 12:38:52 +03:00
|
|
|
extern int ata_dev_configure(struct ata_device *dev);
|
2009-01-29 14:31:33 +03:00
|
|
|
extern int sata_down_spd_limit(struct ata_link *link, u32 spd_limit);
|
2007-02-02 10:22:30 +03:00
|
|
|
extern int ata_down_xfermask_limit(struct ata_device *dev, unsigned int sel);
|
2010-09-01 19:50:05 +04:00
|
|
|
extern unsigned int ata_dev_set_feature(struct ata_device *dev,
|
|
|
|
u8 enable, u8 feature);
|
2006-11-14 16:47:10 +03:00
|
|
|
extern void ata_sg_clean(struct ata_queued_cmd *qc);
|
2008-11-10 08:48:21 +03:00
|
|
|
extern void ata_qc_free(struct ata_queued_cmd *qc);
|
2006-03-31 15:41:11 +04:00
|
|
|
extern void ata_qc_issue(struct ata_queued_cmd *qc);
|
2006-05-15 15:58:05 +04:00
|
|
|
extern void __ata_qc_complete(struct ata_queued_cmd *qc);
|
2008-06-17 07:36:26 +04:00
|
|
|
extern int atapi_check_dma(struct ata_queued_cmd *qc);
|
2005-04-17 02:20:36 +04:00
|
|
|
extern void swap_buf_le16(u16 *buf, unsigned int buf_words);
|
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 12:02:43 +04:00
|
|
|
extern bool ata_phys_link_online(struct ata_link *link);
|
|
|
|
extern bool ata_phys_link_offline(struct ata_link *link);
|
2006-05-31 13:27:30 +04:00
|
|
|
extern void ata_dev_init(struct ata_device *dev);
|
2007-09-23 08:14:12 +04:00
|
|
|
extern void ata_link_init(struct ata_port *ap, struct ata_link *link, int pmp);
|
|
|
|
extern int sata_link_init_spd(struct ata_link *link);
|
2005-05-12 23:45:22 +04:00
|
|
|
extern int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg);
|
|
|
|
extern int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg);
|
2007-04-17 18:44:07 +04:00
|
|
|
extern struct ata_port *ata_port_alloc(struct ata_host *host);
|
2010-05-25 23:31:38 +04:00
|
|
|
extern const char *sata_spd_string(unsigned int spd);
|
2011-01-23 17:28:33 +03:00
|
|
|
extern int ata_port_probe(struct ata_port *ap);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-09-28 22:29:01 +04:00
|
|
|
/* libata-acpi.c */
|
2007-05-05 18:50:38 +04:00
|
|
|
#ifdef CONFIG_ATA_ACPI
|
2009-09-15 23:17:28 +04:00
|
|
|
extern unsigned int ata_acpi_gtf_filter;
|
|
|
|
|
2007-09-23 08:19:54 +04:00
|
|
|
extern void ata_acpi_associate_sata_port(struct ata_port *ap);
|
2007-05-14 22:28:16 +04:00
|
|
|
extern void ata_acpi_associate(struct ata_host *host);
|
2007-12-15 09:05:01 +03:00
|
|
|
extern void ata_acpi_dissociate(struct ata_host *host);
|
2007-05-14 22:28:16 +04:00
|
|
|
extern int ata_acpi_on_suspend(struct ata_port *ap);
|
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 22:28:16 +04:00
|
|
|
extern void ata_acpi_on_resume(struct ata_port *ap);
|
2007-12-15 09:05:01 +03:00
|
|
|
extern int ata_acpi_on_devcfg(struct ata_device *dev);
|
|
|
|
extern void ata_acpi_on_disable(struct ata_device *dev);
|
2007-11-02 04:32:38 +03:00
|
|
|
extern void ata_acpi_set_state(struct ata_port *ap, pm_message_t state);
|
2006-09-28 22:29:01 +04:00
|
|
|
#else
|
2007-09-23 08:19:54 +04:00
|
|
|
static inline void ata_acpi_associate_sata_port(struct ata_port *ap) { }
|
2007-05-14 22:28:16 +04:00
|
|
|
static inline void ata_acpi_associate(struct ata_host *host) { }
|
2007-12-15 09:05:01 +03:00
|
|
|
static inline void ata_acpi_dissociate(struct ata_host *host) { }
|
2007-05-14 22:28:16 +04:00
|
|
|
static inline int ata_acpi_on_suspend(struct ata_port *ap) { return 0; }
|
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 22:28:16 +04:00
|
|
|
static inline void ata_acpi_on_resume(struct ata_port *ap) { }
|
2007-12-15 09:05:01 +03:00
|
|
|
static inline int ata_acpi_on_devcfg(struct ata_device *dev) { return 0; }
|
|
|
|
static inline void ata_acpi_on_disable(struct ata_device *dev) { }
|
2007-11-02 04:32:38 +03:00
|
|
|
static inline void ata_acpi_set_state(struct ata_port *ap,
|
|
|
|
pm_message_t state) { }
|
2006-09-28 22:29:01 +04:00
|
|
|
#endif
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
/* libata-scsi.c */
|
2007-04-17 18:44:07 +04:00
|
|
|
extern int ata_scsi_add_hosts(struct ata_host *host,
|
|
|
|
struct scsi_host_template *sht);
|
2007-07-16 09:29:40 +04:00
|
|
|
extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
|
2006-05-31 13:28:01 +04:00
|
|
|
extern int ata_scsi_offline_dev(struct ata_device *dev);
|
2007-09-23 08:14:13 +04:00
|
|
|
extern void ata_scsi_media_change_notify(struct ata_device *dev);
|
2006-11-22 17:55:48 +03:00
|
|
|
extern void ata_scsi_hotplug(struct work_struct *work);
|
2006-05-15 15:58:07 +04:00
|
|
|
extern void ata_schedule_scsi_eh(struct Scsi_Host *shost);
|
2006-11-22 17:55:48 +03:00
|
|
|
extern void ata_scsi_dev_rescan(struct work_struct *work);
|
2006-08-07 23:27:31 +04:00
|
|
|
extern int ata_bus_probe(struct ata_port *ap);
|
2010-05-25 23:31:38 +04:00
|
|
|
extern int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
|
|
|
|
unsigned int id, unsigned int lun);
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-04-02 13:51:53 +04:00
|
|
|
/* libata-eh.c */
|
2008-05-19 21:17:54 +04:00
|
|
|
extern unsigned long ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd);
|
|
|
|
extern void ata_internal_cmd_timed_out(struct ata_device *dev, u8 cmd);
|
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 19:57:14 +04:00
|
|
|
extern void ata_eh_acquire(struct ata_port *ap);
|
|
|
|
extern void ata_eh_release(struct ata_port *ap);
|
2008-09-14 16:55:09 +04:00
|
|
|
extern enum blk_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd);
|
2006-04-11 21:04:39 +04:00
|
|
|
extern void ata_scsi_error(struct Scsi_Host *host);
|
2006-05-31 13:27:27 +04:00
|
|
|
extern void ata_port_wait_eh(struct ata_port *ap);
|
2007-07-16 09:29:41 +04:00
|
|
|
extern void ata_eh_fastdrain_timerfn(unsigned long arg);
|
2006-05-15 15:58:05 +04:00
|
|
|
extern void ata_qc_schedule_eh(struct ata_queued_cmd *qc);
|
2009-01-29 14:31:30 +03:00
|
|
|
extern void ata_dev_disable(struct ata_device *dev);
|
2007-09-23 08:14:12 +04:00
|
|
|
extern void ata_eh_detach_dev(struct ata_device *dev);
|
|
|
|
extern void ata_eh_about_to_do(struct ata_link *link, struct ata_device *dev,
|
|
|
|
unsigned int action);
|
|
|
|
extern void ata_eh_done(struct ata_link *link, struct ata_device *dev,
|
|
|
|
unsigned int action);
|
|
|
|
extern void ata_eh_autopsy(struct ata_port *ap);
|
2009-07-15 06:43:39 +04:00
|
|
|
const char *ata_get_cmd_descript(u8 command);
|
2007-09-23 08:14:12 +04:00
|
|
|
extern void ata_eh_report(struct ata_port *ap);
|
|
|
|
extern int ata_eh_reset(struct ata_link *link, int classify,
|
|
|
|
ata_prereset_fn_t prereset, ata_reset_fn_t softreset,
|
|
|
|
ata_reset_fn_t hardreset, ata_postreset_fn_t postreset);
|
2007-11-27 13:28:55 +03:00
|
|
|
extern int ata_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
|
2007-09-23 08:14:12 +04:00
|
|
|
extern int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
|
|
|
|
ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
|
|
|
|
ata_postreset_fn_t postreset,
|
|
|
|
struct ata_link **r_failed_disk);
|
|
|
|
extern void ata_eh_finish(struct ata_port *ap);
|
2010-05-25 23:31:38 +04:00
|
|
|
extern int ata_ering_map(struct ata_ering *ering,
|
|
|
|
int (*map_fn)(struct ata_ering_entry *, void *),
|
|
|
|
void *arg);
|
2006-04-02 13:51:53 +04:00
|
|
|
|
2008-04-07 17:47:21 +04:00
|
|
|
/* libata-pmp.c */
|
2008-04-07 17:47:22 +04:00
|
|
|
#ifdef CONFIG_SATA_PMP
|
2008-04-07 17:47:21 +04:00
|
|
|
extern int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *val);
|
|
|
|
extern int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val);
|
2010-09-01 19:50:07 +04:00
|
|
|
extern int sata_pmp_set_lpm(struct ata_link *link, enum ata_lpm_policy policy,
|
|
|
|
unsigned hints);
|
2008-04-07 17:47:21 +04:00
|
|
|
extern int sata_pmp_attach(struct ata_device *dev);
|
2008-04-07 17:47:22 +04:00
|
|
|
#else /* CONFIG_SATA_PMP */
|
|
|
|
static inline int sata_pmp_scr_read(struct ata_link *link, int reg, u32 *val)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int sata_pmp_scr_write(struct ata_link *link, int reg, u32 val)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-09-01 19:50:07 +04:00
|
|
|
static inline int sata_pmp_set_lpm(struct ata_link *link,
|
|
|
|
enum ata_lpm_policy policy, unsigned hints)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-04-07 17:47:22 +04:00
|
|
|
static inline int sata_pmp_attach(struct ata_device *dev)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SATA_PMP */
|
2008-04-07 17:47:21 +04:00
|
|
|
|
2006-10-09 06:10:26 +04:00
|
|
|
/* libata-sff.c */
|
2008-04-07 17:47:21 +04:00
|
|
|
#ifdef CONFIG_ATA_SFF
|
2010-05-10 23:41:38 +04:00
|
|
|
extern void ata_sff_flush_pio_task(struct ata_port *ap);
|
2010-05-10 23:41:35 +04:00
|
|
|
extern void ata_sff_port_init(struct ata_port *ap);
|
|
|
|
extern int ata_sff_init(void);
|
|
|
|
extern void ata_sff_exit(void);
|
|
|
|
#else /* CONFIG_ATA_SFF */
|
2010-05-10 23:41:38 +04:00
|
|
|
static inline void ata_sff_flush_pio_task(struct ata_port *ap)
|
|
|
|
{ }
|
2010-05-10 23:41:35 +04:00
|
|
|
static inline void ata_sff_port_init(struct ata_port *ap)
|
|
|
|
{ }
|
|
|
|
static inline int ata_sff_init(void)
|
|
|
|
{ return 0; }
|
|
|
|
static inline void ata_sff_exit(void)
|
|
|
|
{ }
|
2008-04-07 17:47:21 +04:00
|
|
|
#endif /* CONFIG_ATA_SFF */
|
2007-01-30 11:59:17 +03:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif /* __LIBATA_H__ */
|