[SCSI] Migrate libsas ATA code into a separate file (338ec570) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/scsi/libsas/Makefile

+2 −1

Original line number	Original line	Diff line number	Diff line
	@@ -33,4 +33,5 @@ libsas-y += sas_init.o \
	sas_dump.o \		sas_dump.o \
	sas_discover.o \		sas_discover.o \
	sas_expander.o \		sas_expander.o \
	sas_scsi_host.o		sas_scsi_host.o \
			sas_ata.o

drivers/scsi/libsas/sas_ata.c

0 → 100644

+339 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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
			*/

			#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"

			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;

			case SAM_CHECK_COND:
			case SAS_OPEN_TO:
			case SAS_OPEN_REJECT:
			SAS_DPRINTK("%s: Saw error %d. What to do?\n",
			__FUNCTION__, ts->stat);
			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;
			struct domain_device *dev = qc->ap->private_data;
			struct task_status_struct *stat = &task->task_status;
			struct ata_task_resp resp = (struct ata_task_resp )stat->buf;
			enum ata_completion_errors ac;

			if (stat->stat == SAS_PROTO_RESPONSE) {
			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;
			dev->sata_dev.ap->sactive = resp->sactive;
			} else if (stat->stat != SAM_STAT_GOOD) {
			ac = sas_to_ata_err(stat);
			if (ac) {
			SAS_DPRINTK("%s: SAS error %x\n", __FUNCTION__,
			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;
			}
			}

			ata_qc_complete(qc);
			list_del_init(&task->list);
			sas_free_task(task);
			}

			static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
			{
			int res = -ENOMEM;
			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 num = 0;
			unsigned int xfer = 0;

			task = sas_alloc_task(GFP_ATOMIC);
			if (!task)
			goto out;
			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;
			}

			ata_tf_to_fis(&qc->tf, (u8*)&task->ata_task.fis, 0);
			task->uldd_task = qc;
			if (is_atapi_taskfile(&qc->tf)) {
			memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
			task->total_xfer_len = qc->nbytes + qc->pad_len;
			task->num_scatter = qc->pad_len ? qc->n_elem + 1 : qc->n_elem;
			} else {
			ata_for_each_sg(sg, qc) {
			num++;
			xfer += sg->length;
			}

			task->total_xfer_len = xfer;
			task->num_scatter = num;
			}

			task->data_dir = qc->dma_dir;
			task->scatter = qc->__sg;
			task->ata_task.retry_count = 1;
			task->task_state_flags = SAS_TASK_STATE_PENDING;

			switch (qc->tf.protocol) {
			case ATA_PROT_NCQ:
			task->ata_task.use_ncq = 1;
			/* fall through */
			case ATA_PROT_ATAPI_DMA:
			case ATA_PROT_DMA:
			task->ata_task.dma_xfer = 1;
			break;
			}

			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);

			sas_free_task(task);
			if (res == -SAS_QUEUE_FULL)
			return -ENOMEM;
			}

			out:
			return res;
			}

			static u8 sas_ata_check_status(struct ata_port *ap)
			{
			struct domain_device *dev = ap->private_data;
			return dev->sata_dev.tf.command;
			}

			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);
			int res = 0;

			if (i->dft->lldd_I_T_nexus_reset)
			res = i->dft->lldd_I_T_nexus_reset(dev);

			if (res)
			SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __FUNCTION__);

			switch (dev->sata_dev.command_set) {
			case ATA_COMMAND_SET:
			SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__);
			ap->device[0].class = ATA_DEV_ATA;
			break;
			case ATAPI_COMMAND_SET:
			SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__);
			ap->device[0].class = ATA_DEV_ATAPI;
			break;
			default:
			SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
			__FUNCTION__,
			dev->sata_dev.command_set);
			ap->device[0].class = ATA_DEV_ATA;
			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;

			if (qc->err_mask)
			SAS_DPRINTK("%s: Failure; reset phy!\n", __FUNCTION__);
			}

			static void sas_ata_tf_read(struct ata_port ap, struct ata_taskfile tf)
			{
			struct domain_device *dev = ap->private_data;
			memcpy(tf, &dev->sata_dev.tf, sizeof (*tf));
			}

			static void sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
			u32 val)
			{
			struct domain_device *dev = ap->private_data;

			SAS_DPRINTK("STUB %s\n", __FUNCTION__);
			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:
			dev->sata_dev.ap->sactive = val;
			break;
			}
			}

			static u32 sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
			{
			struct domain_device *dev = ap->private_data;

			SAS_DPRINTK("STUB %s\n", __FUNCTION__);
			switch (sc_reg_in) {
			case SCR_STATUS:
			return dev->sata_dev.sstatus;
			case SCR_CONTROL:
			return dev->sata_dev.scontrol;
			case SCR_ERROR:
			return dev->sata_dev.serror;
			case SCR_ACTIVE:
			return dev->sata_dev.ap->sactive;
			default:
			return 0xffffffffU;
			}
			}

			static struct ata_port_operations sas_sata_ops = {
			.port_disable = ata_port_disable,
			.check_status = sas_ata_check_status,
			.check_altstatus = sas_ata_check_status,
			.dev_select = ata_noop_dev_select,
			.phy_reset = sas_ata_phy_reset,
			.post_internal_cmd = sas_ata_post_internal,
			.tf_read = sas_ata_tf_read,
			.qc_prep = ata_noop_qc_prep,
			.qc_issue = sas_ata_qc_issue,
			.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,
			&ha->pcidev->dev,
			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;
			}

drivers/scsi/libsas/sas_scsi_host.c

+6 −307

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,7 @@
	#include <scsi/scsi_eh.h>		#include <scsi/scsi_eh.h>
	#include <scsi/scsi_transport.h>		#include <scsi/scsi_transport.h>
	#include <scsi/scsi_transport_sas.h>		#include <scsi/scsi_transport_sas.h>
			#include <scsi/sas_ata.h>
	#include "../scsi_sas_internal.h"		#include "../scsi_sas_internal.h"
	#include "../scsi_transport_api.h"		#include "../scsi_transport_api.h"
	#include "../scsi_priv.h"		#include "../scsi_priv.h"
	@@ -173,7 +174,7 @@ static struct sas_task sas_create_task(struct scsi_cmnd cmd,
	return task;		return task;
	}		}

	static int sas_queue_up(struct sas_task *task)		int sas_queue_up(struct sas_task *task)
	{		{
	struct sas_ha_struct *sas_ha = task->dev->port->ha;		struct sas_ha_struct *sas_ha = task->dev->port->ha;
	struct scsi_core *core = &sas_ha->core;		struct scsi_core *core = &sas_ha->core;
	@@ -193,11 +194,6 @@ static int sas_queue_up(struct sas_task *task)
	return 0;		return 0;
	}		}

	static inline int dev_is_sata(struct domain_device *dev)
	{
	return (dev->rphy->identify.target_port_protocols & SAS_PROTOCOL_SATA);
	}

	/**		/**
	* sas_queuecommand -- Enqueue a command for processing		* sas_queuecommand -- Enqueue a command for processing
	* @parameters: See SCSI Core documentation		* @parameters: See SCSI Core documentation
	@@ -696,93 +692,6 @@ enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd)
	return EH_NOT_HANDLED;		return EH_NOT_HANDLED;
	}		}


	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;

	case SAM_CHECK_COND:
	case SAS_OPEN_TO:
	case SAS_OPEN_REJECT:
	SAS_DPRINTK("%s: Saw error %d. What to do?\n",
	__FUNCTION__, ts->stat);
	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;
	struct domain_device *dev = qc->ap->private_data;
	struct task_status_struct *stat = &task->task_status;
	struct ata_task_resp resp = (struct ata_task_resp )stat->buf;
	enum ata_completion_errors ac;

	if (stat->stat == SAS_PROTO_RESPONSE) {
	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;
	dev->sata_dev.ap->sactive = resp->sactive;
	} else if (stat->stat != SAM_STAT_GOOD) {
	ac = sas_to_ata_err(stat);
	if (ac) {
	SAS_DPRINTK("%s: SAS error %x\n", __FUNCTION__,
	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;
	}
	}

	ata_qc_complete(qc);
	list_del_init(&task->list);
	sas_free_task(task);
	}

	int sas_ioctl(struct scsi_device sdev, int cmd, void __user arg)		int sas_ioctl(struct scsi_device sdev, int cmd, void __user arg)
	{		{
	struct domain_device *dev = sdev_to_domain_dev(sdev);		struct domain_device *dev = sdev_to_domain_dev(sdev);
	@@ -793,200 +702,6 @@ int sas_ioctl(struct scsi_device sdev, int cmd, void __user arg)
	return -EINVAL;		return -EINVAL;
	}		}

	static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
	{
	int res = -ENOMEM;
	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 num = 0;
	unsigned int xfer = 0;

	task = sas_alloc_task(GFP_ATOMIC);
	if (!task)
	goto out;
	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;
	}

	ata_tf_to_fis(&qc->tf, (u8*)&task->ata_task.fis, 0);
	task->uldd_task = qc;
	if (is_atapi_taskfile(&qc->tf)) {
	memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len);
	task->total_xfer_len = qc->nbytes + qc->pad_len;
	task->num_scatter = qc->pad_len ? qc->n_elem + 1 : qc->n_elem;
	} else {
	ata_for_each_sg(sg, qc) {
	num++;
	xfer += sg->length;
	}

	task->total_xfer_len = xfer;
	task->num_scatter = num;
	}

	task->data_dir = qc->dma_dir;
	task->scatter = qc->__sg;
	task->ata_task.retry_count = 1;
	task->task_state_flags = SAS_TASK_STATE_PENDING;

	switch (qc->tf.protocol) {
	case ATA_PROT_NCQ:
	task->ata_task.use_ncq = 1;
	/* fall through */
	case ATA_PROT_ATAPI_DMA:
	case ATA_PROT_DMA:
	task->ata_task.dma_xfer = 1;
	break;
	}

	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);

	sas_free_task(task);
	if (res == -SAS_QUEUE_FULL)
	return -ENOMEM;
	}

	out:
	return res;
	}

	static u8 sas_ata_check_status(struct ata_port *ap)
	{
	struct domain_device *dev = ap->private_data;
	return dev->sata_dev.tf.command;
	}

	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);
	int res = 0;

	if (i->dft->lldd_I_T_nexus_reset)
	res = i->dft->lldd_I_T_nexus_reset(dev);

	if (res)
	SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __FUNCTION__);

	switch (dev->sata_dev.command_set) {
	case ATA_COMMAND_SET:
	SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__);
	ap->device[0].class = ATA_DEV_ATA;
	break;
	case ATAPI_COMMAND_SET:
	SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__);
	ap->device[0].class = ATA_DEV_ATAPI;
	break;
	default:
	SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
	__FUNCTION__,
	dev->sata_dev.command_set);
	ap->device[0].class = ATA_DEV_ATA;
	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;

	if (qc->err_mask)
	SAS_DPRINTK("%s: Failure; reset phy!\n", __FUNCTION__);
	}

	static void sas_ata_tf_read(struct ata_port ap, struct ata_taskfile tf)
	{
	struct domain_device *dev = ap->private_data;
	memcpy(tf, &dev->sata_dev.tf, sizeof (*tf));
	}

	static void sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in,
	u32 val)
	{
	struct domain_device *dev = ap->private_data;

	SAS_DPRINTK("STUB %s\n", __FUNCTION__);
	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:
	dev->sata_dev.ap->sactive = val;
	break;
	}
	}

	static u32 sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in)
	{
	struct domain_device *dev = ap->private_data;

	SAS_DPRINTK("STUB %s\n", __FUNCTION__);
	switch (sc_reg_in) {
	case SCR_STATUS:
	return dev->sata_dev.sstatus;
	case SCR_CONTROL:
	return dev->sata_dev.scontrol;
	case SCR_ERROR:
	return dev->sata_dev.serror;
	case SCR_ACTIVE:
	return dev->sata_dev.ap->sactive;
	default:
	return 0xffffffffU;
	}
	}

	static struct ata_port_operations sas_sata_ops = {
	.port_disable = ata_port_disable,
	.check_status = sas_ata_check_status,
	.check_altstatus = sas_ata_check_status,
	.dev_select = ata_noop_dev_select,
	.phy_reset = sas_ata_phy_reset,
	.post_internal_cmd = sas_ata_post_internal,
	.tf_read = sas_ata_tf_read,
	.qc_prep = ata_noop_qc_prep,
	.qc_issue = sas_ata_qc_issue,
	.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
	};

	struct domain_device sas_find_dev_by_rphy(struct sas_rphy rphy)		struct domain_device sas_find_dev_by_rphy(struct sas_rphy rphy)
	{		{
	struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);		struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent);
	@@ -1025,32 +740,16 @@ static inline struct domain_device sas_find_target(struct scsi_target starget)

	int sas_target_alloc(struct scsi_target *starget)		int sas_target_alloc(struct scsi_target *starget)
	{		{
	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
	struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
	struct domain_device *found_dev = sas_find_target(starget);		struct domain_device *found_dev = sas_find_target(starget);
			int res;

	if (!found_dev)		if (!found_dev)
	return -ENODEV;		return -ENODEV;

	if (dev_is_sata(found_dev)) {		if (dev_is_sata(found_dev)) {
	struct ata_port *ap;		res = sas_ata_init_host_and_port(found_dev, starget);
			if (res)
	ata_host_init(&found_dev->sata_dev.ata_host,		return res;
	&ha->pcidev->dev,
	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;
	}		}

	starget->hostdata = found_dev;		starget->hostdata = found_dev;

include/scsi/libsas.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -632,6 +632,7 @@ int sas_set_phy_speed(struct sas_phy *phy,
	struct sas_phy_linkrates *rates);		struct sas_phy_linkrates *rates);
	int sas_phy_enable(struct sas_phy *phy, int enabled);		int sas_phy_enable(struct sas_phy *phy, int enabled);
	int sas_phy_reset(struct sas_phy *phy, int hard_reset);		int sas_phy_reset(struct sas_phy *phy, int hard_reset);
			int sas_queue_up(struct sas_task *task);
	extern int sas_queuecommand(struct scsi_cmnd *,		extern int sas_queuecommand(struct scsi_cmnd *,
	void (scsi_done)(struct scsi_cmnd ));		void (scsi_done)(struct scsi_cmnd ));
	extern int sas_target_alloc(struct scsi_target *);		extern int sas_target_alloc(struct scsi_target *);

include/scsi/sas_ata.h

0 → 100644

+39 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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
			*
			*/

			#ifndef _SAS_ATA_H_
			#define _SAS_ATA_H_

			#include <linux/libata.h>
			#include <scsi/libsas.h>

			static inline int dev_is_sata(struct domain_device *dev)
			{
			return (dev->rphy->identify.target_port_protocols & SAS_PROTOCOL_SATA);
			}

			int sas_ata_init_host_and_port(struct domain_device *found_dev,
			struct scsi_target *starget);

			#endif /* _SAS_ATA_H_ */