2006-10-18 21:43:37 +00:00
|
|
|
/*
|
|
|
|
* Support for SATA devices on Serial Attached SCSI (SAS) controllers
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 IBM Corporation
|
|
|
|
*
|
|
|
|
* Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation
|
|
|
|
*
|
|
|
|
* 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 of the
|
|
|
|
* License, 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; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
|
|
* USA
|
|
|
|
*/
|
|
|
|
|
2007-07-22 18:15:55 +00:00
|
|
|
#include <linux/scatterlist.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2007-07-22 18:15:55 +00:00
|
|
|
|
2006-10-18 21:43:37 +00:00
|
|
|
#include <scsi/sas_ata.h>
|
|
|
|
#include "sas_internal.h"
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
#include <scsi/scsi_tcq.h>
|
|
|
|
#include <scsi/scsi.h>
|
|
|
|
#include <scsi/scsi_transport.h>
|
|
|
|
#include <scsi/scsi_transport_sas.h>
|
|
|
|
#include "../scsi_sas_internal.h"
|
2007-01-30 09:18:58 +00:00
|
|
|
#include "../scsi_transport_api.h"
|
|
|
|
#include <scsi/scsi_eh.h>
|
2006-10-18 21:43:37 +00:00
|
|
|
|
|
|
|
static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts)
|
|
|
|
{
|
|
|
|
/* Cheesy attempt to translate SAS errors into ATA. Hah! */
|
|
|
|
|
|
|
|
/* transport error */
|
|
|
|
if (ts->resp == SAS_TASK_UNDELIVERED)
|
|
|
|
return AC_ERR_ATA_BUS;
|
|
|
|
|
|
|
|
/* ts->resp == SAS_TASK_COMPLETE */
|
|
|
|
/* task delivered, what happened afterwards? */
|
|
|
|
switch (ts->stat) {
|
|
|
|
case SAS_DEV_NO_RESPONSE:
|
|
|
|
return AC_ERR_TIMEOUT;
|
|
|
|
|
|
|
|
case SAS_INTERRUPTED:
|
|
|
|
case SAS_PHY_DOWN:
|
|
|
|
case SAS_NAK_R_ERR:
|
|
|
|
return AC_ERR_ATA_BUS;
|
|
|
|
|
|
|
|
|
|
|
|
case SAS_DATA_UNDERRUN:
|
|
|
|
/*
|
|
|
|
* Some programs that use the taskfile interface
|
|
|
|
* (smartctl in particular) can cause underrun
|
|
|
|
* problems. Ignore these errors, perhaps at our
|
|
|
|
* peril.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case SAS_DATA_OVERRUN:
|
|
|
|
case SAS_QUEUE_FULL:
|
|
|
|
case SAS_DEVICE_UNKNOWN:
|
|
|
|
case SAS_SG_ERR:
|
|
|
|
return AC_ERR_INVALID;
|
|
|
|
|
2010-07-27 20:51:13 +00:00
|
|
|
case SAM_STAT_CHECK_CONDITION:
|
2006-10-18 21:43:37 +00:00
|
|
|
case SAS_OPEN_TO:
|
|
|
|
case SAS_OPEN_REJECT:
|
|
|
|
SAS_DPRINTK("%s: Saw error %d. What to do?\n",
|
2008-07-04 06:47:27 +00:00
|
|
|
__func__, ts->stat);
|
2006-10-18 21:43:37 +00:00
|
|
|
return AC_ERR_OTHER;
|
|
|
|
|
|
|
|
case SAS_ABORTED_TASK:
|
|
|
|
return AC_ERR_DEV;
|
|
|
|
|
|
|
|
case SAS_PROTO_RESPONSE:
|
|
|
|
/* This means the ending_fis has the error
|
|
|
|
* value; return 0 here to collect it */
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_ata_task_done(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct ata_queued_cmd *qc = task->uldd_task;
|
2007-01-30 09:18:41 +00:00
|
|
|
struct domain_device *dev;
|
2006-10-18 21:43:37 +00:00
|
|
|
struct task_status_struct *stat = &task->task_status;
|
|
|
|
struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf;
|
2007-01-30 09:18:58 +00:00
|
|
|
struct sas_ha_struct *sas_ha;
|
2006-10-18 21:43:37 +00:00
|
|
|
enum ata_completion_errors ac;
|
2007-01-30 09:18:35 +00:00
|
|
|
unsigned long flags;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
2007-01-30 09:18:41 +00:00
|
|
|
if (!qc)
|
|
|
|
goto qc_already_gone;
|
|
|
|
|
|
|
|
dev = qc->ap->private_data;
|
2007-01-30 09:18:58 +00:00
|
|
|
sas_ha = dev->port->ha;
|
2007-01-30 09:18:41 +00:00
|
|
|
|
2007-01-30 09:18:35 +00:00
|
|
|
spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
|
2010-07-27 20:51:13 +00:00
|
|
|
if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD) {
|
2006-10-18 21:43:37 +00:00
|
|
|
ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
|
|
|
|
qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
|
|
|
|
dev->sata_dev.sstatus = resp->sstatus;
|
|
|
|
dev->sata_dev.serror = resp->serror;
|
|
|
|
dev->sata_dev.scontrol = resp->scontrol;
|
|
|
|
} else if (stat->stat != SAM_STAT_GOOD) {
|
|
|
|
ac = sas_to_ata_err(stat);
|
|
|
|
if (ac) {
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("%s: SAS error %x\n", __func__,
|
2006-10-18 21:43:37 +00:00
|
|
|
stat->stat);
|
|
|
|
/* We saw a SAS error. Send a vague error. */
|
|
|
|
qc->err_mask = ac;
|
|
|
|
dev->sata_dev.tf.feature = 0x04; /* status err */
|
|
|
|
dev->sata_dev.tf.command = ATA_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-01-30 09:18:41 +00:00
|
|
|
qc->lldd_task = NULL;
|
2007-01-30 09:18:55 +00:00
|
|
|
if (qc->scsicmd)
|
|
|
|
ASSIGN_SAS_TASK(qc->scsicmd, NULL);
|
2006-10-18 21:43:37 +00:00
|
|
|
ata_qc_complete(qc);
|
2007-01-30 09:18:35 +00:00
|
|
|
spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags);
|
|
|
|
|
2007-01-30 09:18:58 +00:00
|
|
|
/*
|
|
|
|
* If the sas_task has an ata qc, a scsi_cmnd and the aborted
|
|
|
|
* flag is set, then we must have come in via the libsas EH
|
|
|
|
* functions. When we exit this function, we need to put the
|
|
|
|
* scsi_cmnd on the list of finished errors. The ata_qc_complete
|
|
|
|
* call cleans up the libata side of things but we're protected
|
|
|
|
* from the scsi_cmnd going away because the scsi_cmnd is owned
|
|
|
|
* by the EH, making libata's call to scsi_done a NOP.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED)
|
|
|
|
scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q);
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
|
2007-01-30 09:18:41 +00:00
|
|
|
qc_already_gone:
|
2006-10-18 21:43:37 +00:00
|
|
|
list_del_init(&task->list);
|
|
|
|
sas_free_task(task);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
|
|
|
|
{
|
2007-01-30 09:18:38 +00:00
|
|
|
int res;
|
2006-10-18 21:43:37 +00:00
|
|
|
struct sas_task *task;
|
|
|
|
struct domain_device *dev = qc->ap->private_data;
|
|
|
|
struct sas_ha_struct *sas_ha = dev->port->ha;
|
|
|
|
struct Scsi_Host *host = sas_ha->core.shost;
|
|
|
|
struct sas_internal *i = to_sas_internal(host->transportt);
|
|
|
|
struct scatterlist *sg;
|
|
|
|
unsigned int xfer = 0;
|
2007-12-05 07:43:11 +00:00
|
|
|
unsigned int si;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
|
|
|
task = sas_alloc_task(GFP_ATOMIC);
|
|
|
|
if (!task)
|
2007-01-30 09:18:38 +00:00
|
|
|
return AC_ERR_SYSTEM;
|
2006-10-18 21:43:37 +00:00
|
|
|
task->dev = dev;
|
|
|
|
task->task_proto = SAS_PROTOCOL_STP;
|
|
|
|
task->task_done = sas_ata_task_done;
|
|
|
|
|
|
|
|
if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
|
|
|
|
qc->tf.command == ATA_CMD_FPDMA_READ) {
|
|
|
|
/* Need to zero out the tag libata assigned us */
|
|
|
|
qc->tf.nsect = 0;
|
|
|
|
}
|
|
|
|
|
2007-07-20 18:11:44 +00:00
|
|
|
ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis);
|
2006-10-18 21:43:37 +00:00
|
|
|
task->uldd_task = qc;
|
2007-11-27 10:28:53 +00:00
|
|
|
if (ata_is_atapi(qc->tf.protocol)) {
|
2006-10-18 21:43:37 +00:00
|
|
|
memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
|
2008-02-19 10:36:56 +00:00
|
|
|
task->total_xfer_len = qc->nbytes;
|
|
|
|
task->num_scatter = qc->n_elem;
|
2006-10-18 21:43:37 +00:00
|
|
|
} else {
|
2007-12-05 07:43:11 +00:00
|
|
|
for_each_sg(qc->sg, sg, qc->n_elem, si)
|
2006-10-18 21:43:37 +00:00
|
|
|
xfer += sg->length;
|
|
|
|
|
|
|
|
task->total_xfer_len = xfer;
|
2007-12-05 07:43:11 +00:00
|
|
|
task->num_scatter = si;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
task->data_dir = qc->dma_dir;
|
2007-12-05 07:43:11 +00:00
|
|
|
task->scatter = qc->sg;
|
2006-10-18 21:43:37 +00:00
|
|
|
task->ata_task.retry_count = 1;
|
|
|
|
task->task_state_flags = SAS_TASK_STATE_PENDING;
|
2007-01-30 09:18:41 +00:00
|
|
|
qc->lldd_task = task;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
|
|
|
switch (qc->tf.protocol) {
|
|
|
|
case ATA_PROT_NCQ:
|
|
|
|
task->ata_task.use_ncq = 1;
|
|
|
|
/* fall through */
|
2007-12-18 21:34:43 +00:00
|
|
|
case ATAPI_PROT_DMA:
|
2006-10-18 21:43:37 +00:00
|
|
|
case ATA_PROT_DMA:
|
|
|
|
task->ata_task.dma_xfer = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-01-30 09:18:55 +00:00
|
|
|
if (qc->scsicmd)
|
|
|
|
ASSIGN_SAS_TASK(qc->scsicmd, task);
|
|
|
|
|
2006-10-18 21:43:37 +00:00
|
|
|
if (sas_ha->lldd_max_execute_num < 2)
|
|
|
|
res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC);
|
|
|
|
else
|
|
|
|
res = sas_queue_up(task);
|
|
|
|
|
|
|
|
/* Examine */
|
|
|
|
if (res) {
|
|
|
|
SAS_DPRINTK("lldd_execute_task returned: %d\n", res);
|
|
|
|
|
2007-01-30 09:18:55 +00:00
|
|
|
if (qc->scsicmd)
|
|
|
|
ASSIGN_SAS_TASK(qc->scsicmd, NULL);
|
2006-10-18 21:43:37 +00:00
|
|
|
sas_free_task(task);
|
2007-01-30 09:18:38 +00:00
|
|
|
return AC_ERR_SYSTEM;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
|
2007-01-30 09:18:38 +00:00
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
|
2008-04-07 13:47:20 +00:00
|
|
|
static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
struct domain_device *dev = qc->ap->private_data;
|
|
|
|
|
|
|
|
memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-10-18 21:43:37 +00:00
|
|
|
static void sas_ata_phy_reset(struct ata_port *ap)
|
|
|
|
{
|
|
|
|
struct domain_device *dev = ap->private_data;
|
|
|
|
struct sas_internal *i =
|
|
|
|
to_sas_internal(dev->port->ha->core.shost->transportt);
|
2008-02-24 05:38:44 +00:00
|
|
|
int res = TMF_RESP_FUNC_FAILED;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
|
|
|
if (i->dft->lldd_I_T_nexus_reset)
|
|
|
|
res = i->dft->lldd_I_T_nexus_reset(dev);
|
|
|
|
|
2008-02-24 05:38:44 +00:00
|
|
|
if (res != TMF_RESP_FUNC_COMPLETE)
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __func__);
|
2006-10-18 21:43:37 +00:00
|
|
|
|
|
|
|
switch (dev->sata_dev.command_set) {
|
|
|
|
case ATA_COMMAND_SET:
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("%s: Found ATA device.\n", __func__);
|
2007-08-06 09:36:22 +00:00
|
|
|
ap->link.device[0].class = ATA_DEV_ATA;
|
2006-10-18 21:43:37 +00:00
|
|
|
break;
|
|
|
|
case ATAPI_COMMAND_SET:
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
|
2007-08-06 09:36:22 +00:00
|
|
|
ap->link.device[0].class = ATA_DEV_ATAPI;
|
2006-10-18 21:43:37 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
|
2008-07-04 06:47:27 +00:00
|
|
|
__func__,
|
2006-10-18 21:43:37 +00:00
|
|
|
dev->sata_dev.command_set);
|
2007-08-06 09:36:22 +00:00
|
|
|
ap->link.device[0].class = ATA_DEV_UNKNOWN;
|
2006-10-18 21:43:37 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ap->cbl = ATA_CBL_SATA;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_ata_post_internal(struct ata_queued_cmd *qc)
|
|
|
|
{
|
|
|
|
if (qc->flags & ATA_QCFLAG_FAILED)
|
|
|
|
qc->err_mask |= AC_ERR_OTHER;
|
|
|
|
|
2007-01-30 09:18:41 +00:00
|
|
|
if (qc->err_mask) {
|
|
|
|
/*
|
|
|
|
* Find the sas_task and kill it. By this point,
|
|
|
|
* libata has decided to kill the qc, so we needn't
|
|
|
|
* bother with sas_ata_task_done. But we still
|
|
|
|
* ought to abort the task.
|
|
|
|
*/
|
|
|
|
struct sas_task *task = qc->lldd_task;
|
2007-01-30 09:18:58 +00:00
|
|
|
unsigned long flags;
|
2007-01-30 09:18:41 +00:00
|
|
|
|
|
|
|
qc->lldd_task = NULL;
|
|
|
|
if (task) {
|
2007-01-30 09:18:58 +00:00
|
|
|
/* Should this be a AT(API) device reset? */
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
|
2007-01-30 09:18:41 +00:00
|
|
|
task->uldd_task = NULL;
|
|
|
|
__sas_task_abort(task);
|
|
|
|
}
|
|
|
|
}
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int sas_ata_scr_write(struct ata_link *link, unsigned int sc_reg_in,
|
2006-10-18 21:43:37 +00:00
|
|
|
u32 val)
|
|
|
|
{
|
2008-07-31 08:02:40 +00:00
|
|
|
struct domain_device *dev = link->ap->private_data;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("STUB %s\n", __func__);
|
2006-10-18 21:43:37 +00:00
|
|
|
switch (sc_reg_in) {
|
|
|
|
case SCR_STATUS:
|
|
|
|
dev->sata_dev.sstatus = val;
|
|
|
|
break;
|
|
|
|
case SCR_CONTROL:
|
|
|
|
dev->sata_dev.scontrol = val;
|
|
|
|
break;
|
|
|
|
case SCR_ERROR:
|
|
|
|
dev->sata_dev.serror = val;
|
|
|
|
break;
|
|
|
|
case SCR_ACTIVE:
|
2007-08-06 09:36:22 +00:00
|
|
|
dev->sata_dev.ap->link.sactive = val;
|
2006-10-18 21:43:37 +00:00
|
|
|
break;
|
2007-07-20 18:11:44 +00:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
2007-07-20 18:11:44 +00:00
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
|
2008-07-31 08:02:40 +00:00
|
|
|
static int sas_ata_scr_read(struct ata_link *link, unsigned int sc_reg_in,
|
2007-07-20 18:11:44 +00:00
|
|
|
u32 *val)
|
2006-10-18 21:43:37 +00:00
|
|
|
{
|
2008-07-31 08:02:40 +00:00
|
|
|
struct domain_device *dev = link->ap->private_data;
|
2006-10-18 21:43:37 +00:00
|
|
|
|
2008-07-04 06:47:27 +00:00
|
|
|
SAS_DPRINTK("STUB %s\n", __func__);
|
2006-10-18 21:43:37 +00:00
|
|
|
switch (sc_reg_in) {
|
|
|
|
case SCR_STATUS:
|
2007-07-20 18:11:44 +00:00
|
|
|
*val = dev->sata_dev.sstatus;
|
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
case SCR_CONTROL:
|
2007-07-20 18:11:44 +00:00
|
|
|
*val = dev->sata_dev.scontrol;
|
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
case SCR_ERROR:
|
2007-07-20 18:11:44 +00:00
|
|
|
*val = dev->sata_dev.serror;
|
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
case SCR_ACTIVE:
|
2007-08-06 09:36:22 +00:00
|
|
|
*val = dev->sata_dev.ap->link.sactive;
|
2007-07-20 18:11:44 +00:00
|
|
|
return 0;
|
2006-10-18 21:43:37 +00:00
|
|
|
default:
|
2007-07-20 18:11:44 +00:00
|
|
|
return -EINVAL;
|
2006-10-18 21:43:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ata_port_operations sas_sata_ops = {
|
|
|
|
.phy_reset = sas_ata_phy_reset,
|
|
|
|
.post_internal_cmd = sas_ata_post_internal,
|
2010-09-03 22:13:03 +00:00
|
|
|
.qc_defer = ata_std_qc_defer,
|
2006-10-18 21:43:37 +00:00
|
|
|
.qc_prep = ata_noop_qc_prep,
|
|
|
|
.qc_issue = sas_ata_qc_issue,
|
2008-04-07 13:47:20 +00:00
|
|
|
.qc_fill_rtf = sas_ata_qc_fill_rtf,
|
2006-10-18 21:43:37 +00:00
|
|
|
.port_start = ata_sas_port_start,
|
|
|
|
.port_stop = ata_sas_port_stop,
|
|
|
|
.scr_read = sas_ata_scr_read,
|
|
|
|
.scr_write = sas_ata_scr_write
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct ata_port_info sata_port_info = {
|
|
|
|
.flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | ATA_FLAG_SATA_RESET |
|
|
|
|
ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ,
|
|
|
|
.pio_mask = 0x1f, /* PIO0-4 */
|
|
|
|
.mwdma_mask = 0x07, /* MWDMA0-2 */
|
|
|
|
.udma_mask = ATA_UDMA6,
|
|
|
|
.port_ops = &sas_sata_ops
|
|
|
|
};
|
|
|
|
|
|
|
|
int sas_ata_init_host_and_port(struct domain_device *found_dev,
|
|
|
|
struct scsi_target *starget)
|
|
|
|
{
|
|
|
|
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
|
|
|
|
struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
|
|
|
|
struct ata_port *ap;
|
|
|
|
|
|
|
|
ata_host_init(&found_dev->sata_dev.ata_host,
|
2007-07-26 13:28:37 +00:00
|
|
|
ha->dev,
|
2006-10-18 21:43:37 +00:00
|
|
|
sata_port_info.flags,
|
|
|
|
&sas_sata_ops);
|
|
|
|
ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host,
|
|
|
|
&sata_port_info,
|
|
|
|
shost);
|
|
|
|
if (!ap) {
|
|
|
|
SAS_DPRINTK("ata_sas_port_alloc failed.\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
ap->private_data = found_dev;
|
|
|
|
ap->cbl = ATA_CBL_SATA;
|
|
|
|
ap->scsi_host = shost;
|
|
|
|
found_dev->sata_dev.ap = ap;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2007-01-30 09:18:58 +00:00
|
|
|
|
|
|
|
void sas_ata_task_abort(struct sas_task *task)
|
|
|
|
{
|
|
|
|
struct ata_queued_cmd *qc = task->uldd_task;
|
|
|
|
struct completion *waiting;
|
|
|
|
|
|
|
|
/* Bounce SCSI-initiated commands to the SCSI EH */
|
|
|
|
if (qc->scsicmd) {
|
2010-05-13 14:31:54 +00:00
|
|
|
struct request_queue *q = qc->scsicmd->device->request_queue;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2010-04-15 00:00:08 +00:00
|
|
|
spin_lock_irqsave(q->queue_lock, flags);
|
2008-09-14 12:55:09 +00:00
|
|
|
blk_abort_request(qc->scsicmd->request);
|
2010-04-15 00:00:08 +00:00
|
|
|
spin_unlock_irqrestore(q->queue_lock, flags);
|
2007-01-30 09:18:58 +00:00
|
|
|
scsi_schedule_eh(qc->scsicmd->device->host);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Internal command, fake a timeout and complete. */
|
|
|
|
qc->flags &= ~ATA_QCFLAG_ACTIVE;
|
|
|
|
qc->flags |= ATA_QCFLAG_FAILED;
|
|
|
|
qc->err_mask |= AC_ERR_TIMEOUT;
|
|
|
|
waiting = qc->private_data;
|
|
|
|
complete(waiting);
|
|
|
|
}
|
2007-07-22 18:15:55 +00:00
|
|
|
|
|
|
|
static void sas_task_timedout(unsigned long _task)
|
|
|
|
{
|
|
|
|
struct sas_task *task = (void *) _task;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&task->task_state_lock, flags);
|
|
|
|
if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
|
|
|
|
task->task_state_flags |= SAS_TASK_STATE_ABORTED;
|
|
|
|
spin_unlock_irqrestore(&task->task_state_lock, flags);
|
|
|
|
|
|
|
|
complete(&task->completion);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sas_disc_task_done(struct sas_task *task)
|
|
|
|
{
|
|
|
|
if (!del_timer(&task->timer))
|
|
|
|
return;
|
|
|
|
complete(&task->completion);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SAS_DEV_TIMEOUT 10
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sas_execute_task -- Basic task processing for discovery
|
|
|
|
* @task: the task to be executed
|
|
|
|
* @buffer: pointer to buffer to do I/O
|
|
|
|
* @size: size of @buffer
|
2007-07-26 13:28:37 +00:00
|
|
|
* @dma_dir: DMA direction. DMA_xxx
|
2007-07-22 18:15:55 +00:00
|
|
|
*/
|
|
|
|
static int sas_execute_task(struct sas_task *task, void *buffer, int size,
|
2007-07-26 13:28:37 +00:00
|
|
|
enum dma_data_direction dma_dir)
|
2007-07-22 18:15:55 +00:00
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
struct scatterlist *scatter = NULL;
|
|
|
|
struct task_status_struct *ts = &task->task_status;
|
|
|
|
int num_scatter = 0;
|
|
|
|
int retries = 0;
|
|
|
|
struct sas_internal *i =
|
|
|
|
to_sas_internal(task->dev->port->ha->core.shost->transportt);
|
|
|
|
|
2007-07-26 13:28:37 +00:00
|
|
|
if (dma_dir != DMA_NONE) {
|
2007-07-22 18:15:55 +00:00
|
|
|
scatter = kzalloc(sizeof(*scatter), GFP_KERNEL);
|
|
|
|
if (!scatter)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
sg_init_one(scatter, buffer, size);
|
|
|
|
num_scatter = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
task->task_proto = task->dev->tproto;
|
|
|
|
task->scatter = scatter;
|
|
|
|
task->num_scatter = num_scatter;
|
|
|
|
task->total_xfer_len = size;
|
2007-07-26 13:28:37 +00:00
|
|
|
task->data_dir = dma_dir;
|
2007-07-22 18:15:55 +00:00
|
|
|
task->task_done = sas_disc_task_done;
|
2007-07-26 13:28:37 +00:00
|
|
|
if (dma_dir != DMA_NONE &&
|
2007-07-22 18:15:55 +00:00
|
|
|
sas_protocol_ata(task->task_proto)) {
|
2007-07-26 13:28:37 +00:00
|
|
|
task->num_scatter = dma_map_sg(task->dev->port->ha->dev,
|
2007-07-22 18:15:55 +00:00
|
|
|
task->scatter,
|
|
|
|
task->num_scatter,
|
|
|
|
task->data_dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (retries = 0; retries < 5; retries++) {
|
|
|
|
task->task_state_flags = SAS_TASK_STATE_PENDING;
|
|
|
|
init_completion(&task->completion);
|
|
|
|
|
|
|
|
task->timer.data = (unsigned long) task;
|
|
|
|
task->timer.function = sas_task_timedout;
|
|
|
|
task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ;
|
|
|
|
add_timer(&task->timer);
|
|
|
|
|
|
|
|
res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL);
|
|
|
|
if (res) {
|
|
|
|
del_timer(&task->timer);
|
|
|
|
SAS_DPRINTK("executing SAS discovery task failed:%d\n",
|
|
|
|
res);
|
|
|
|
goto ex_err;
|
|
|
|
}
|
|
|
|
wait_for_completion(&task->completion);
|
2007-12-30 18:37:31 +00:00
|
|
|
res = -ECOMM;
|
2007-07-22 18:15:55 +00:00
|
|
|
if (task->task_state_flags & SAS_TASK_STATE_ABORTED) {
|
|
|
|
int res2;
|
|
|
|
SAS_DPRINTK("task aborted, flags:0x%x\n",
|
|
|
|
task->task_state_flags);
|
|
|
|
res2 = i->dft->lldd_abort_task(task);
|
|
|
|
SAS_DPRINTK("came back from abort task\n");
|
|
|
|
if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
|
|
|
|
if (res2 == TMF_RESP_FUNC_COMPLETE)
|
|
|
|
continue; /* Retry the task */
|
|
|
|
else
|
|
|
|
goto ex_err;
|
|
|
|
}
|
|
|
|
}
|
2010-07-27 20:51:13 +00:00
|
|
|
if (task->task_status.stat == SAM_STAT_BUSY ||
|
|
|
|
task->task_status.stat == SAM_STAT_TASK_SET_FULL ||
|
2007-07-22 18:15:55 +00:00
|
|
|
task->task_status.stat == SAS_QUEUE_FULL) {
|
|
|
|
SAS_DPRINTK("task: q busy, sleeping...\n");
|
|
|
|
schedule_timeout_interruptible(HZ);
|
2010-07-27 20:51:13 +00:00
|
|
|
} else if (task->task_status.stat == SAM_STAT_CHECK_CONDITION) {
|
2007-07-22 18:15:55 +00:00
|
|
|
struct scsi_sense_hdr shdr;
|
|
|
|
|
|
|
|
if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size,
|
|
|
|
&shdr)) {
|
|
|
|
SAS_DPRINTK("couldn't normalize sense\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ((shdr.sense_key == 6 && shdr.asc == 0x29) ||
|
|
|
|
(shdr.sense_key == 2 && shdr.asc == 4 &&
|
|
|
|
shdr.ascq == 1)) {
|
|
|
|
SAS_DPRINTK("device %016llx LUN: %016llx "
|
|
|
|
"powering up or not ready yet, "
|
|
|
|
"sleeping...\n",
|
|
|
|
SAS_ADDR(task->dev->sas_addr),
|
|
|
|
SAS_ADDR(task->ssp_task.LUN));
|
|
|
|
|
|
|
|
schedule_timeout_interruptible(5*HZ);
|
|
|
|
} else if (shdr.sense_key == 1) {
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
} else if (shdr.sense_key == 5) {
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
SAS_DPRINTK("dev %016llx LUN: %016llx "
|
|
|
|
"sense key:0x%x ASC:0x%x ASCQ:0x%x"
|
|
|
|
"\n",
|
|
|
|
SAS_ADDR(task->dev->sas_addr),
|
|
|
|
SAS_ADDR(task->ssp_task.LUN),
|
|
|
|
shdr.sense_key,
|
|
|
|
shdr.asc, shdr.ascq);
|
|
|
|
}
|
|
|
|
} else if (task->task_status.resp != SAS_TASK_COMPLETE ||
|
2010-07-27 20:51:13 +00:00
|
|
|
task->task_status.stat != SAM_STAT_GOOD) {
|
2007-07-22 18:15:55 +00:00
|
|
|
SAS_DPRINTK("task finished with resp:0x%x, "
|
|
|
|
"stat:0x%x\n",
|
|
|
|
task->task_status.resp,
|
|
|
|
task->task_status.stat);
|
|
|
|
goto ex_err;
|
|
|
|
} else {
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ex_err:
|
2007-07-26 13:28:37 +00:00
|
|
|
if (dma_dir != DMA_NONE) {
|
2007-07-22 18:15:55 +00:00
|
|
|
if (sas_protocol_ata(task->task_proto))
|
2007-07-26 13:28:37 +00:00
|
|
|
dma_unmap_sg(task->dev->port->ha->dev,
|
2007-07-22 18:15:55 +00:00
|
|
|
task->scatter, task->num_scatter,
|
|
|
|
task->data_dir);
|
|
|
|
kfree(scatter);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ---------- SATA ---------- */
|
|
|
|
|
|
|
|
static void sas_get_ata_command_set(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
struct dev_to_host_fis *fis =
|
|
|
|
(struct dev_to_host_fis *) dev->frame_rcvd;
|
|
|
|
|
|
|
|
if ((fis->sector_count == 1 && /* ATA */
|
|
|
|
fis->lbal == 1 &&
|
|
|
|
fis->lbam == 0 &&
|
|
|
|
fis->lbah == 0 &&
|
|
|
|
fis->device == 0)
|
|
|
|
||
|
|
|
|
(fis->sector_count == 0 && /* CE-ATA (mATA) */
|
|
|
|
fis->lbal == 0 &&
|
|
|
|
fis->lbam == 0xCE &&
|
|
|
|
fis->lbah == 0xAA &&
|
|
|
|
(fis->device & ~0x10) == 0))
|
|
|
|
|
|
|
|
dev->sata_dev.command_set = ATA_COMMAND_SET;
|
|
|
|
|
|
|
|
else if ((fis->interrupt_reason == 1 && /* ATAPI */
|
|
|
|
fis->lbal == 1 &&
|
|
|
|
fis->byte_count_low == 0x14 &&
|
|
|
|
fis->byte_count_high == 0xEB &&
|
|
|
|
(fis->device & ~0x10) == 0))
|
|
|
|
|
|
|
|
dev->sata_dev.command_set = ATAPI_COMMAND_SET;
|
|
|
|
|
|
|
|
else if ((fis->sector_count == 1 && /* SEMB */
|
|
|
|
fis->lbal == 1 &&
|
|
|
|
fis->lbam == 0x3C &&
|
|
|
|
fis->lbah == 0xC3 &&
|
|
|
|
fis->device == 0)
|
|
|
|
||
|
|
|
|
(fis->interrupt_reason == 1 && /* SATA PM */
|
|
|
|
fis->lbal == 1 &&
|
|
|
|
fis->byte_count_low == 0x69 &&
|
|
|
|
fis->byte_count_high == 0x96 &&
|
|
|
|
(fis->device & ~0x10) == 0))
|
|
|
|
|
|
|
|
/* Treat it as a superset? */
|
|
|
|
dev->sata_dev.command_set = ATAPI_COMMAND_SET;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sas_issue_ata_cmd -- Basic SATA command processing for discovery
|
|
|
|
* @dev: the device to send the command to
|
|
|
|
* @command: the command register
|
|
|
|
* @features: the features register
|
|
|
|
* @buffer: pointer to buffer to do I/O
|
|
|
|
* @size: size of @buffer
|
2007-07-26 13:28:37 +00:00
|
|
|
* @dma_dir: DMA direction. DMA_xxx
|
2007-07-22 18:15:55 +00:00
|
|
|
*/
|
|
|
|
static int sas_issue_ata_cmd(struct domain_device *dev, u8 command,
|
|
|
|
u8 features, void *buffer, int size,
|
2007-07-26 13:28:37 +00:00
|
|
|
enum dma_data_direction dma_dir)
|
2007-07-22 18:15:55 +00:00
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
struct sas_task *task;
|
|
|
|
struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *)
|
|
|
|
&dev->frame_rcvd[0];
|
|
|
|
|
|
|
|
res = -ENOMEM;
|
|
|
|
task = sas_alloc_task(GFP_KERNEL);
|
|
|
|
if (!task)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
task->dev = dev;
|
|
|
|
|
|
|
|
task->ata_task.fis.fis_type = 0x27;
|
|
|
|
task->ata_task.fis.command = command;
|
|
|
|
task->ata_task.fis.features = features;
|
|
|
|
task->ata_task.fis.device = d2h_fis->device;
|
|
|
|
task->ata_task.retry_count = 1;
|
|
|
|
|
2007-07-26 13:28:37 +00:00
|
|
|
res = sas_execute_task(task, buffer, size, dma_dir);
|
2007-07-22 18:15:55 +00:00
|
|
|
|
|
|
|
sas_free_task(task);
|
|
|
|
out:
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ATA_IDENTIFY_DEV 0xEC
|
|
|
|
#define ATA_IDENTIFY_PACKET_DEV 0xA1
|
|
|
|
#define ATA_SET_FEATURES 0xEF
|
|
|
|
#define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV)
|
|
|
|
* @dev: STP/SATA device of interest (ATA/ATAPI)
|
|
|
|
*
|
|
|
|
* The LLDD has already been notified of this device, so that we can
|
|
|
|
* send FISes to it. Here we try to get IDENTIFY DEVICE or IDENTIFY
|
|
|
|
* PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its
|
|
|
|
* performance for this device.
|
|
|
|
*/
|
|
|
|
static int sas_discover_sata_dev(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
__le16 *identify_x;
|
|
|
|
u8 command;
|
|
|
|
|
|
|
|
identify_x = kzalloc(512, GFP_KERNEL);
|
|
|
|
if (!identify_x)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (dev->sata_dev.command_set == ATA_COMMAND_SET) {
|
|
|
|
dev->sata_dev.identify_device = identify_x;
|
|
|
|
command = ATA_IDENTIFY_DEV;
|
|
|
|
} else {
|
|
|
|
dev->sata_dev.identify_packet_device = identify_x;
|
|
|
|
command = ATA_IDENTIFY_PACKET_DEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
|
2007-07-26 13:28:37 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2007-07-22 18:15:55 +00:00
|
|
|
if (res)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
/* lives on the media? */
|
|
|
|
if (le16_to_cpu(identify_x[0]) & 4) {
|
|
|
|
/* incomplete response */
|
|
|
|
SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to "
|
|
|
|
"dev %llx\n", SAS_ADDR(dev->sas_addr));
|
2008-04-16 22:27:45 +00:00
|
|
|
if (!(identify_x[83] & cpu_to_le16(1<<6)))
|
2007-07-22 18:15:55 +00:00
|
|
|
goto cont1;
|
|
|
|
res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES,
|
|
|
|
ATA_FEATURE_PUP_STBY_SPIN_UP,
|
2007-07-26 13:28:37 +00:00
|
|
|
NULL, 0, DMA_NONE);
|
2007-07-22 18:15:55 +00:00
|
|
|
if (res)
|
|
|
|
goto cont1;
|
|
|
|
|
|
|
|
schedule_timeout_interruptible(5*HZ); /* More time? */
|
|
|
|
res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512,
|
2007-07-26 13:28:37 +00:00
|
|
|
DMA_FROM_DEVICE);
|
2007-07-22 18:15:55 +00:00
|
|
|
if (res)
|
|
|
|
goto out_err;
|
|
|
|
}
|
|
|
|
cont1:
|
|
|
|
/* XXX Hint: register this SATA device with SATL.
|
|
|
|
When this returns, dev->sata_dev->lu is alive and
|
|
|
|
present.
|
|
|
|
sas_satl_register_dev(dev);
|
|
|
|
*/
|
|
|
|
|
|
|
|
sas_fill_in_rphy(dev, dev->rphy);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
out_err:
|
|
|
|
dev->sata_dev.identify_packet_device = NULL;
|
|
|
|
dev->sata_dev.identify_device = NULL;
|
|
|
|
kfree(identify_x);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sas_discover_sata_pm(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sas_discover_sata -- discover an STP/SATA domain device
|
|
|
|
* @dev: pointer to struct domain_device of interest
|
|
|
|
*
|
|
|
|
* First we notify the LLDD of this device, so we can send frames to
|
|
|
|
* it. Then depending on the type of device we call the appropriate
|
|
|
|
* discover functions. Once device discover is done, we notify the
|
|
|
|
* LLDD so that it can fine-tune its parameters for the device, by
|
|
|
|
* removing it and then adding it. That is, the second time around,
|
|
|
|
* the driver would have certain fields, that it is looking at, set.
|
|
|
|
* Finally we initialize the kobj so that the device can be added to
|
|
|
|
* the system at registration time. Devices directly attached to a HA
|
|
|
|
* port, have no parents. All other devices do, and should have their
|
|
|
|
* "parent" pointer set appropriately before calling this function.
|
|
|
|
*/
|
|
|
|
int sas_discover_sata(struct domain_device *dev)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
sas_get_ata_command_set(dev);
|
|
|
|
|
|
|
|
res = sas_notify_lldd_dev_found(dev);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
|
|
|
switch (dev->dev_type) {
|
|
|
|
case SATA_DEV:
|
|
|
|
res = sas_discover_sata_dev(dev);
|
|
|
|
break;
|
|
|
|
case SATA_PM:
|
|
|
|
res = sas_discover_sata_pm(dev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sas_notify_lldd_dev_gone(dev);
|
|
|
|
if (!res) {
|
|
|
|
sas_notify_lldd_dev_found(dev);
|
|
|
|
res = sas_rphy_add(dev->rphy);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|