Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 726980d56908f2e230624394f03743689db3110c

Authored by Jeff Skirvin 2012-03-09 14:41:50 +0800

Committed by Dan Williams 2012-05-18 05:33:37 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

isci: Terminate outstanding TCs on TX/RX RNC suspensions.

TCs must only be terminated when RNCs are suspended.

Signed-off-by: Jeff Skirvin <jeffrey.d.skirvin@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

Showing 7 changed files with 188 additions and 32 deletions Inline Diff

drivers/scsi/isci/host.c
drivers/scsi/isci/remote_device.c
drivers/scsi/isci/remote_device.h
drivers/scsi/isci/remote_node_context.c
drivers/scsi/isci/remote_node_context.h
drivers/scsi/isci/request.c
drivers/scsi/isci/request.h

drivers/scsi/isci/host.c

Diff comments View file @ 726980d

drivers/scsi/isci/remote_device.c

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <scsi/sas.h>
 #include <linux/bitops.h>
 #include "isci.h"
 #include "port.h"
 #include "remote_device.h"
 #include "request.h"
 #include "remote_node_context.h"
 #include "scu_event_codes.h"
 #include "task.h"
 #undef C
 #define C(a) (#a)
 const char *dev_state_name(enum sci_remote_device_states state)
 {
 	static const char * const strings[] = REMOTE_DEV_STATES;
 	return strings[state];
 }
 #undef C
 /**
  * isci_remote_device_not_ready() - This function is called by the ihost when
  *    the remote device is not ready. We mark the isci device as ready (not
  *    "ready_for_io") and signal the waiting proccess.
  * @isci_host: This parameter specifies the isci host object.
  * @isci_device: This parameter specifies the remote device
  *
  * sci_lock is held on entrance to this function.
  */
 static void isci_remote_device_not_ready(struct isci_host *ihost,
 				  struct isci_remote_device *idev, u32 reason)
 {
 	struct isci_request *ireq;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: isci_device = %p\n", __func__, idev);
 	switch (reason) {
 	case SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED:
 		set_bit(IDEV_GONE, &idev->flags);
 		break;
 	case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
 		set_bit(IDEV_IO_NCQERROR, &idev->flags);
 		/* Kill all outstanding requests for the device. */
 		list_for_each_entry(ireq, &idev->reqs_in_process, dev_node) {
 			dev_dbg(&ihost->pdev->dev,
 				"%s: isci_device = %p request = %p\n",
 				__func__, idev, ireq);
 			sci_controller_terminate_request(ihost,
 							  idev,
 							  ireq);
 		}
 		/* Fall through into the default case... */
 	default:
 		clear_bit(IDEV_IO_READY, &idev->flags);
 		break;
 	}
 }
 /**
  * isci_remote_device_ready() - This function is called by the ihost when the
  *    remote device is ready. We mark the isci device as ready and signal the
  *    waiting proccess.
  * @ihost: our valid isci_host
  * @idev: remote device
  *
  */
 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
 {
 	dev_dbg(&ihost->pdev->dev,
 		"%s: idev = %p\n", __func__, idev);
 	clear_bit(IDEV_IO_NCQERROR, &idev->flags);
 	set_bit(IDEV_IO_READY, &idev->flags);
 	if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
 		wake_up(&ihost->eventq);
 }
+static enum sci_status sci_remote_device_suspend(
+	struct isci_remote_device *idev)
+{
+	return sci_remote_node_context_suspend(
+		&idev->rnc,
+		SCI_SOFTWARE_SUSPENSION,
+		SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT,
+		NULL, NULL);
+}
+enum sci_status isci_remote_device_suspend(
+	struct isci_host *ihost,
+	struct isci_remote_device *idev)
+{
+	enum sci_status status;
+	unsigned long flags;
+	spin_lock_irqsave(&ihost->scic_lock, flags);
+	if (isci_lookup_device(idev->domain_dev) == NULL) {
+		spin_unlock_irqrestore(&ihost->scic_lock, flags);
+		status = SCI_FAILURE;
+	} else {
+		status = sci_remote_device_suspend(idev);
+		spin_unlock_irqrestore(&ihost->scic_lock, flags);
+		if (status == SCI_SUCCESS) {
+			wait_event(ihost->eventq,
+				   test_bit(IDEV_TXRX_SUSPENDED, &idev->flags)
+				|| !test_bit(IDEV_ALLOCATED, &idev->flags));
+			status = test_bit(IDEV_TXRX_SUSPENDED, &idev->flags)
+					? SCI_SUCCESS : SCI_FAILURE;
+			dev_dbg(&ihost->pdev->dev,
+				"%s: idev=%p, wait done, device is %s\n",
+				__func__, idev,
+				test_bit(IDEV_TXRX_SUSPENDED, &idev->flags)
+					? "<suspended>" : "<deallocated!>");
+		}
+		isci_put_device(idev);
+	}
+	return status;
+}
 /* called once the remote node context is ready to be freed.
  * The remote device can now report that its stop operation is complete. none
  */
 static void rnc_destruct_done(void *_dev)
 {
 	struct isci_remote_device *idev = _dev;
 	BUG_ON(idev->started_request_count != 0);
 	sci_change_state(&idev->sm, SCI_DEV_STOPPED);
 }
-static enum sci_status sci_remote_device_terminate_requests(struct isci_remote_device *idev)
+static enum sci_status sci_remote_device_terminate_requests_checkabort(
+	struct isci_remote_device *idev,
+	int check_abort_pending)
 {
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	enum sci_status status  = SCI_SUCCESS;
 	u32 i;
 	for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
 		struct isci_request *ireq = ihost->reqs[i];
 		enum sci_status s;
 		if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
-		    ireq->target_device != idev)
+		    (ireq->target_device != idev) ||
+		    (check_abort_pending && !test_bit(IREQ_PENDING_ABORT,
+						      &ireq->flags)))
 			continue;
 		s = sci_controller_terminate_request(ihost, idev, ireq);
 		if (s != SCI_SUCCESS)
 			status = s;
 	}
 	return status;
 }
+enum sci_status sci_remote_device_terminate_requests(
+	struct isci_remote_device *idev)
+{
+	return sci_remote_device_terminate_requests_checkabort(idev, 0);
+}
 enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
 					u32 timeout)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_DEV_STOPPED:
 		return SCI_SUCCESS;
 	case SCI_DEV_STARTING:
 		/* device not started so there had better be no requests */
 		BUG_ON(idev->started_request_count != 0);
 		sci_remote_node_context_destruct(&idev->rnc,
 						      rnc_destruct_done, idev);
 		/* Transition to the stopping state and wait for the
 		 * remote node to complete being posted and invalidated.
 		 */
 		sci_change_state(sm, SCI_DEV_STOPPING);
 		return SCI_SUCCESS;
 	case SCI_DEV_READY:
 	case SCI_STP_DEV_IDLE:
 	case SCI_STP_DEV_CMD:
 	case SCI_STP_DEV_NCQ:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_AWAIT_RESET:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_SMP_DEV_CMD:
 		sci_change_state(sm, SCI_DEV_STOPPING);
 		if (idev->started_request_count == 0) {
 			sci_remote_node_context_destruct(&idev->rnc,
 							      rnc_destruct_done, idev);
 			return SCI_SUCCESS;
 		} else
 			return sci_remote_device_terminate_requests(idev);
 		break;
 	case SCI_DEV_STOPPING:
 		/* All requests should have been terminated, but if there is an
 		 * attempt to stop a device already in the stopping state, then
 		 * try again to terminate.
 		 */
 		return sci_remote_device_terminate_requests(idev);
 	case SCI_DEV_RESETTING:
 		sci_change_state(sm, SCI_DEV_STOPPING);
 		return SCI_SUCCESS;
 	}
 }
 enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_STOPPED:
 	case SCI_DEV_STARTING:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_SMP_DEV_CMD:
 	case SCI_DEV_STOPPING:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_RESETTING:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_DEV_READY:
 	case SCI_STP_DEV_IDLE:
 	case SCI_STP_DEV_CMD:
 	case SCI_STP_DEV_NCQ:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_AWAIT_RESET:
 		sci_change_state(sm, SCI_DEV_RESETTING);
 		return SCI_SUCCESS;
 	}
 }
 enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	if (state != SCI_DEV_RESETTING) {
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	sci_change_state(sm, SCI_DEV_READY);
 	return SCI_SUCCESS;
 }
-enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev)
-{
-	return sci_remote_node_context_suspend(&idev->rnc,
-					       SCI_SOFTWARE_SUSPENSION,
-					       SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT,
-					       NULL, NULL);
-}
 enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
 						     u32 frame_index)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	enum sci_status status;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_STOPPED:
 	case SCI_DEV_STARTING:
 	case SCI_STP_DEV_IDLE:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		/* Return the frame back to the controller */
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_DEV_READY:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_AWAIT_RESET:
 	case SCI_DEV_STOPPING:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_RESETTING: {
 		struct isci_request *ireq;
 		struct ssp_frame_hdr hdr;
 		void *frame_header;
 		ssize_t word_cnt;
 		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 								       frame_index,
 								       &frame_header);
 		if (status != SCI_SUCCESS)
 			return status;
 		word_cnt = sizeof(hdr) / sizeof(u32);
 		sci_swab32_cpy(&hdr, frame_header, word_cnt);
 		ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag));
 		if (ireq && ireq->target_device == idev) {
 			/* The IO request is now in charge of releasing the frame */
 			status = sci_io_request_frame_handler(ireq, frame_index);
 		} else {
 			/* We could not map this tag to a valid IO
 			 * request Just toss the frame and continue
 			 */
 			sci_controller_release_frame(ihost, frame_index);
 		}
 		break;
 	}
 	case SCI_STP_DEV_NCQ: {
 		struct dev_to_host_fis *hdr;
 		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 								       frame_index,
 								       (void **)&hdr);
 		if (status != SCI_SUCCESS)
 			return status;
 		if (hdr->fis_type == FIS_SETDEVBITS &&
 		    (hdr->status & ATA_ERR)) {
 			idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
 			/* TODO Check sactive and complete associated IO if any. */
 			sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
 		} else if (hdr->fis_type == FIS_REGD2H &&
 			   (hdr->status & ATA_ERR)) {
 			/*
 			 * Some devices return D2H FIS when an NCQ error is detected.
 			 * Treat this like an SDB error FIS ready reason.
 			 */
 			idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
 			sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
 		} else
 			status = SCI_FAILURE;
 		sci_controller_release_frame(ihost, frame_index);
 		break;
 	}
 	case SCI_STP_DEV_CMD:
 	case SCI_SMP_DEV_CMD:
 		/* The device does not process any UF received from the hardware while
 		 * in this state.  All unsolicited frames are forwarded to the io request
 		 * object.
 		 */
 		status = sci_io_request_frame_handler(idev->working_request, frame_index);
 		break;
 	}
 	return status;
 }
 static bool is_remote_device_ready(struct isci_remote_device *idev)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	switch (state) {
 	case SCI_DEV_READY:
 	case SCI_STP_DEV_IDLE:
 	case SCI_STP_DEV_CMD:
 	case SCI_STP_DEV_NCQ:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_AWAIT_RESET:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_SMP_DEV_CMD:
 		return true;
 	default:
 		return false;
 	}
 }
 /*
  * called once the remote node context has transisitioned to a ready
  * state (after suspending RX and/or TX due to early D2H fis)
  */
 static void atapi_remote_device_resume_done(void *_dev)
 {
 	struct isci_remote_device *idev = _dev;
 	struct isci_request *ireq = idev->working_request;
 	sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 }
 enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
 						     u32 event_code)
 {
 	enum sci_status status;
 	switch (scu_get_event_type(event_code)) {
 	case SCU_EVENT_TYPE_RNC_OPS_MISC:
 	case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
 	case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
 		status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
 		break;
 	case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
 		if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
 			status = SCI_SUCCESS;
 			/* Suspend the associated RNC */
 			sci_remote_node_context_suspend(
 				&idev->rnc,
 				SCI_SOFTWARE_SUSPENSION,
 				SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT,
 				NULL, NULL);
 			dev_dbg(scirdev_to_dev(idev),
 				"%s: device: %p event code: %x: %s\n",
 				__func__, idev, event_code,
 				is_remote_device_ready(idev)
 				? "I_T_Nexus_Timeout event"
 				: "I_T_Nexus_Timeout event in wrong state");
 			break;
 		}
 	/* Else, fall through and treat as unhandled... */
 	default:
 		dev_dbg(scirdev_to_dev(idev),
 			"%s: device: %p event code: %x: %s\n",
 			__func__, idev, event_code,
 			is_remote_device_ready(idev)
 			? "unexpected event"
 			: "unexpected event in wrong state");
 		status = SCI_FAILURE_INVALID_STATE;
 		break;
 	}
 	if (status != SCI_SUCCESS)
 		return status;
 	return status;
 }
 static void sci_remote_device_start_request(struct isci_remote_device *idev,
 						 struct isci_request *ireq,
 						 enum sci_status status)
 {
 	struct isci_port *iport = idev->owning_port;
 	/* cleanup requests that failed after starting on the port */
 	if (status != SCI_SUCCESS)
 		sci_port_complete_io(iport, idev, ireq);
 	else {
 		kref_get(&idev->kref);
 		idev->started_request_count++;
 	}
 }
 enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
 						struct isci_remote_device *idev,
 						struct isci_request *ireq)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	struct isci_port *iport = idev->owning_port;
 	enum sci_status status;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_STOPPED:
 	case SCI_DEV_STARTING:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_DEV_STOPPING:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_RESETTING:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_DEV_READY:
 		/* attempt to start an io request for this device object. The remote
 		 * device object will issue the start request for the io and if
 		 * successful it will start the request for the port object then
 		 * increment its own request count.
 		 */
 		status = sci_port_start_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			return status;
 		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		status = sci_request_start(ireq);
 		break;
 	case SCI_STP_DEV_IDLE: {
 		/* handle the start io operation for a sata device that is in
 		 * the command idle state. - Evalute the type of IO request to
 		 * be started - If its an NCQ request change to NCQ substate -
 		 * If its any other command change to the CMD substate
 		 *
 		 * If this is a softreset we may want to have a different
 		 * substate.
 		 */
 		enum sci_remote_device_states new_state;
 		struct sas_task *task = isci_request_access_task(ireq);
 		status = sci_port_start_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			return status;
 		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		status = sci_request_start(ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		if (task->ata_task.use_ncq)
 			new_state = SCI_STP_DEV_NCQ;
 		else {
 			idev->working_request = ireq;
 			new_state = SCI_STP_DEV_CMD;
 		}
 		sci_change_state(sm, new_state);
 		break;
 	}
 	case SCI_STP_DEV_NCQ: {
 		struct sas_task *task = isci_request_access_task(ireq);
 		if (task->ata_task.use_ncq) {
 			status = sci_port_start_io(iport, idev, ireq);
 			if (status != SCI_SUCCESS)
 				return status;
 			status = sci_remote_node_context_start_io(&idev->rnc, ireq);
 			if (status != SCI_SUCCESS)
 				break;
 			status = sci_request_start(ireq);
 		} else
 			return SCI_FAILURE_INVALID_STATE;
 		break;
 	}
 	case SCI_STP_DEV_AWAIT_RESET:
 		return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
 	case SCI_SMP_DEV_IDLE:
 		status = sci_port_start_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			return status;
 		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		status = sci_request_start(ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		idev->working_request = ireq;
 		sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
 		break;
 	case SCI_STP_DEV_CMD:
 	case SCI_SMP_DEV_CMD:
 		/* device is already handling a command it can not accept new commands
 		 * until this one is complete.
 		 */
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	sci_remote_device_start_request(idev, ireq, status);
 	return status;
 }
 static enum sci_status common_complete_io(struct isci_port *iport,
 					  struct isci_remote_device *idev,
 					  struct isci_request *ireq)
 {
 	enum sci_status status;
 	status = sci_request_complete(ireq);
 	if (status != SCI_SUCCESS)
 		return status;
 	status = sci_port_complete_io(iport, idev, ireq);
 	if (status != SCI_SUCCESS)
 		return status;
 	sci_remote_device_decrement_request_count(idev);
 	return status;
 }
 enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
 						   struct isci_remote_device *idev,
 						   struct isci_request *ireq)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	struct isci_port *iport = idev->owning_port;
 	enum sci_status status;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_STOPPED:
 	case SCI_DEV_STARTING:
 	case SCI_STP_DEV_IDLE:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_DEV_READY:
 	case SCI_STP_DEV_AWAIT_RESET:
 	case SCI_DEV_RESETTING:
 		status = common_complete_io(iport, idev, ireq);
 		break;
 	case SCI_STP_DEV_CMD:
 	case SCI_STP_DEV_NCQ:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_ATAPI_ERROR:
 		status = common_complete_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
 			/* This request causes hardware error, device needs to be Lun Reset.
 			 * So here we force the state machine to IDLE state so the rest IOs
 			 * can reach RNC state handler, these IOs will be completed by RNC with
 			 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
 			 */
 			sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
 		} else if (idev->started_request_count == 0)
 			sci_change_state(sm, SCI_STP_DEV_IDLE);
 		break;
 	case SCI_SMP_DEV_CMD:
 		status = common_complete_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		sci_change_state(sm, SCI_SMP_DEV_IDLE);
 		break;
 	case SCI_DEV_STOPPING:
 		status = common_complete_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		if (idev->started_request_count == 0)
 			sci_remote_node_context_destruct(&idev->rnc,
 							 rnc_destruct_done,
 							 idev);
 		break;
 	}
 	if (status != SCI_SUCCESS)
 		dev_err(scirdev_to_dev(idev),
 			"%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
 			"could not complete\n", __func__, iport,
 			idev, ireq, status);
 	else
 		isci_put_device(idev);
 	return status;
 }
 static void sci_remote_device_continue_request(void *dev)
 {
 	struct isci_remote_device *idev = dev;
 	/* we need to check if this request is still valid to continue. */
 	if (idev->working_request)
 		sci_controller_continue_io(idev->working_request);
 }
 enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
 						  struct isci_remote_device *idev,
 						  struct isci_request *ireq)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	struct isci_port *iport = idev->owning_port;
 	enum sci_status status;
 	switch (state) {
 	case SCI_DEV_INITIAL:
 	case SCI_DEV_STOPPED:
 	case SCI_DEV_STARTING:
 	case SCI_SMP_DEV_IDLE:
 	case SCI_SMP_DEV_CMD:
 	case SCI_DEV_STOPPING:
 	case SCI_DEV_FAILED:
 	case SCI_DEV_RESETTING:
 	case SCI_DEV_FINAL:
 	default:
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	case SCI_STP_DEV_IDLE:
 	case SCI_STP_DEV_CMD:
 	case SCI_STP_DEV_NCQ:
 	case SCI_STP_DEV_NCQ_ERROR:
 	case SCI_STP_DEV_AWAIT_RESET:
 		status = sci_port_start_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			return status;
 		status = sci_remote_node_context_start_task(&idev->rnc, ireq);
 		if (status != SCI_SUCCESS)
 			goto out;
 		status = sci_request_start(ireq);
 		if (status != SCI_SUCCESS)
 			goto out;
 		/* Note: If the remote device state is not IDLE this will
 		 * replace the request that probably resulted in the task
 		 * management request.
 		 */
 		idev->working_request = ireq;
 		sci_change_state(sm, SCI_STP_DEV_CMD);
 		/* The remote node context must cleanup the TCi to NCQ mapping
 		 * table.  The only way to do this correctly is to either write
 		 * to the TLCR register or to invalidate and repost the RNC. In
 		 * either case the remote node context state machine will take
 		 * the correct action when the remote node context is suspended
 		 * and later resumed.
 		 */
 		sci_remote_node_context_suspend(
 			&idev->rnc, SCI_SOFTWARE_SUSPENSION,
 			SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT, NULL, NULL);
 		sci_remote_node_context_resume(
 			&idev->rnc, sci_remote_device_continue_request, idev);
 	out:
 		sci_remote_device_start_request(idev, ireq, status);
 		/* We need to let the controller start request handler know that
 		 * it can't post TC yet. We will provide a callback function to
 		 * post TC when RNC gets resumed.
 		 */
 		return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
 	case SCI_DEV_READY:
 		status = sci_port_start_io(iport, idev, ireq);
 		if (status != SCI_SUCCESS)
 			return status;
 		status = sci_remote_node_context_start_task(&idev->rnc, ireq);
 		if (status != SCI_SUCCESS)
 			break;
 		status = sci_request_start(ireq);
 		break;
 	}
 	sci_remote_device_start_request(idev, ireq, status);
 	return status;
 }
 void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
 {
 	struct isci_port *iport = idev->owning_port;
 	u32 context;
 	context = request |
 		  (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 		  (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 		  idev->rnc.remote_node_index;
 	sci_controller_post_request(iport->owning_controller, context);
 }
 /* called once the remote node context has transisitioned to a
  * ready state.  This is the indication that the remote device object can also
  * transition to ready.
  */
 static void remote_device_resume_done(void *_dev)
 {
 	struct isci_remote_device *idev = _dev;
 	if (is_remote_device_ready(idev))
 		return;
 	/* go 'ready' if we are not already in a ready state */
 	sci_change_state(&idev->sm, SCI_DEV_READY);
 }
 static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
 {
 	struct isci_remote_device *idev = _dev;
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	/* For NCQ operation we do not issue a isci_remote_device_not_ready().
 	 * As a result, avoid sending the ready notification.
 	 */
 	if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
 		isci_remote_device_ready(ihost, idev);
 }
 static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	/* Initial state is a transitional state to the stopped state */
 	sci_change_state(&idev->sm, SCI_DEV_STOPPED);
 }
 /**
  * sci_remote_device_destruct() - free remote node context and destruct
  * @remote_device: This parameter specifies the remote device to be destructed.
  *
  * Remote device objects are a limited resource.  As such, they must be
  * protected.  Thus calls to construct and destruct are mutually exclusive and
  * non-reentrant. The return value shall indicate if the device was
  * successfully destructed or if some failure occurred. enum sci_status This value
  * is returned if the device is successfully destructed.
  * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
  * device isn't valid (e.g. it's already been destoryed, the handle isn't
  * valid, etc.).
  */
 static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	struct isci_host *ihost;
 	if (state != SCI_DEV_STOPPED) {
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	ihost = idev->owning_port->owning_controller;
 	sci_controller_free_remote_node_context(ihost, idev,
 						     idev->rnc.remote_node_index);
 	idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
 	sci_change_state(sm, SCI_DEV_FINAL);
 	return SCI_SUCCESS;
 }
 /**
  * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
  * @ihost: This parameter specifies the isci host object.
  * @idev: This parameter specifies the remote device to be freed.
  *
  */
 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
 {
 	dev_dbg(&ihost->pdev->dev,
 		"%s: isci_device = %p\n", __func__, idev);
 	/* There should not be any outstanding io's. All paths to
 	 * here should go through isci_remote_device_nuke_requests.
 	 * If we hit this condition, we will need a way to complete
 	 * io requests in process */
 	BUG_ON(!list_empty(&idev->reqs_in_process));
 	sci_remote_device_destruct(idev);
 	list_del_init(&idev->node);
 	isci_put_device(idev);
 }
 static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	u32 prev_state;
 	/* If we are entering from the stopping state let the SCI User know that
 	 * the stop operation has completed.
 	 */
 	prev_state = idev->sm.previous_state_id;
 	if (prev_state == SCI_DEV_STOPPING)
 		isci_remote_device_deconstruct(ihost, idev);
 	sci_controller_remote_device_stopped(ihost, idev);
 }
 static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	isci_remote_device_not_ready(ihost, idev,
 				     SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
 }
 static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	struct domain_device *dev = idev->domain_dev;
 	if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
 		sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
 	} else if (dev_is_expander(dev)) {
 		sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
 	} else
 		isci_remote_device_ready(ihost, idev);
 }
 static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct domain_device *dev = idev->domain_dev;
 	if (dev->dev_type == SAS_END_DEV) {
 		struct isci_host *ihost = idev->owning_port->owning_controller;
 		isci_remote_device_not_ready(ihost, idev,
 					     SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
 	}
 }
 static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: isci_device = %p\n", __func__, idev);
 	sci_remote_node_context_suspend(
 		&idev->rnc, SCI_SOFTWARE_SUSPENSION,
 		SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT, NULL, NULL);
 }
 static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: isci_device = %p\n", __func__, idev);
 	sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
 }
 static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	idev->working_request = NULL;
 	if (sci_remote_node_context_is_ready(&idev->rnc)) {
 		/*
 		 * Since the RNC is ready, it's alright to finish completion
 		 * processing (e.g. signal the remote device is ready). */
 		sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
 	} else {
 		sci_remote_node_context_resume(&idev->rnc,
 			sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
 			idev);
 	}
 }
 static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	BUG_ON(idev->working_request == NULL);
 	isci_remote_device_not_ready(ihost, idev,
 				     SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
 }
 static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
 		isci_remote_device_not_ready(ihost, idev,
 					     idev->not_ready_reason);
 }
 static void sci_stp_remote_device_atapi_error_substate_enter(
 	struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	/* This state is entered when an I/O is decoded with an error
 	 * condition.  By this point the RNC expected suspension state is set.
 	 * The error conditions suspend the device, so unsuspend here if
 	 * possible.
 	 */
 	sci_remote_node_context_resume(&idev->rnc,
 				       atapi_remote_device_resume_done,
 				       idev);
 }
 static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	isci_remote_device_ready(ihost, idev);
 }
 static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	BUG_ON(idev->working_request == NULL);
 	isci_remote_device_not_ready(ihost, idev,
 				     SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
 }
 static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
 {
 	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
 	idev->working_request = NULL;
 }
 static const struct sci_base_state sci_remote_device_state_table[] = {
 	[SCI_DEV_INITIAL] = {
 		.enter_state = sci_remote_device_initial_state_enter,
 	},
 	[SCI_DEV_STOPPED] = {
 		.enter_state = sci_remote_device_stopped_state_enter,
 	},
 	[SCI_DEV_STARTING] = {
 		.enter_state = sci_remote_device_starting_state_enter,
 	},
 	[SCI_DEV_READY] = {
 		.enter_state = sci_remote_device_ready_state_enter,
 		.exit_state  = sci_remote_device_ready_state_exit
 	},
 	[SCI_STP_DEV_IDLE] = {
 		.enter_state = sci_stp_remote_device_ready_idle_substate_enter,
 	},
 	[SCI_STP_DEV_CMD] = {
 		.enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
 	},
 	[SCI_STP_DEV_NCQ] = { },
 	[SCI_STP_DEV_NCQ_ERROR] = {
 		.enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
 	},
 	[SCI_STP_DEV_ATAPI_ERROR] = {
 		.enter_state = sci_stp_remote_device_atapi_error_substate_enter,
 	},
 	[SCI_STP_DEV_AWAIT_RESET] = { },
 	[SCI_SMP_DEV_IDLE] = {
 		.enter_state = sci_smp_remote_device_ready_idle_substate_enter,
 	},
 	[SCI_SMP_DEV_CMD] = {
 		.enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
 		.exit_state  = sci_smp_remote_device_ready_cmd_substate_exit,
 	},
 	[SCI_DEV_STOPPING] = { },
 	[SCI_DEV_FAILED] = { },
 	[SCI_DEV_RESETTING] = {
 		.enter_state = sci_remote_device_resetting_state_enter,
 		.exit_state  = sci_remote_device_resetting_state_exit
 	},
 	[SCI_DEV_FINAL] = { },
 };
 /**
  * sci_remote_device_construct() - common construction
  * @sci_port: SAS/SATA port through which this device is accessed.
  * @sci_dev: remote device to construct
  *
  * This routine just performs benign initialization and does not
  * allocate the remote_node_context which is left to
  * sci_remote_device_[de]a_construct().  sci_remote_device_destruct()
  * frees the remote_node_context(s) for the device.
  */
 static void sci_remote_device_construct(struct isci_port *iport,
 				  struct isci_remote_device *idev)
 {
 	idev->owning_port = iport;
 	idev->started_request_count = 0;
 	sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL);
 	sci_remote_node_context_construct(&idev->rnc,
 					       SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
 }
 /**
  * sci_remote_device_da_construct() - construct direct attached device.
  *
  * The information (e.g. IAF, Signature FIS, etc.) necessary to build
  * the device is known to the SCI Core since it is contained in the
  * sci_phy object.  Remote node context(s) is/are a global resource
  * allocated by this routine, freed by sci_remote_device_destruct().
  *
  * Returns:
  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
  * sata-only controller instance.
  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
  */
 static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
 						       struct isci_remote_device *idev)
 {
 	enum sci_status status;
 	struct sci_port_properties properties;
 	sci_remote_device_construct(iport, idev);
 	sci_port_get_properties(iport, &properties);
 	/* Get accurate port width from port's phy mask for a DA device. */
 	idev->device_port_width = hweight32(properties.phy_mask);
 	status = sci_controller_allocate_remote_node_context(iport->owning_controller,
 							     idev,
 							     &idev->rnc.remote_node_index);
 	if (status != SCI_SUCCESS)
 		return status;
 	idev->connection_rate = sci_port_get_max_allowed_speed(iport);
 	return SCI_SUCCESS;
 }
 /**
  * sci_remote_device_ea_construct() - construct expander attached device
  *
  * Remote node context(s) is/are a global resource allocated by this
  * routine, freed by sci_remote_device_destruct().
  *
  * Returns:
  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
  * sata-only controller instance.
  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
  */
 static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
 						       struct isci_remote_device *idev)
 {
 	struct domain_device *dev = idev->domain_dev;
 	enum sci_status status;
 	sci_remote_device_construct(iport, idev);
 	status = sci_controller_allocate_remote_node_context(iport->owning_controller,
 								  idev,
 								  &idev->rnc.remote_node_index);
 	if (status != SCI_SUCCESS)
 		return status;
 	/* For SAS-2 the physical link rate is actually a logical link
 	 * rate that incorporates multiplexing.  The SCU doesn't
 	 * incorporate multiplexing and for the purposes of the
 	 * connection the logical link rate is that same as the
 	 * physical.  Furthermore, the SAS-2 and SAS-1.1 fields overlay
 	 * one another, so this code works for both situations.
 	 */
 	idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
 					 dev->linkrate);
 	/* / @todo Should I assign the port width by reading all of the phys on the port? */
 	idev->device_port_width = 1;
 	return SCI_SUCCESS;
 }
 /**
  * sci_remote_device_start() - This method will start the supplied remote
  *    device.  This method enables normal IO requests to flow through to the
  *    remote device.
  * @remote_device: This parameter specifies the device to be started.
  * @timeout: This parameter specifies the number of milliseconds in which the
  *    start operation should complete.
  *
  * An indication of whether the device was successfully started. SCI_SUCCESS
  * This value is returned if the device was successfully started.
  * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
  * the device when there have been no phys added to it.
  */
 static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
-						u32 timeout)
+					       u32 timeout)
 {
 	struct sci_base_state_machine *sm = &idev->sm;
 	enum sci_remote_device_states state = sm->current_state_id;
 	enum sci_status status;
 	if (state != SCI_DEV_STOPPED) {
 		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
 			 __func__, dev_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	status = sci_remote_node_context_resume(&idev->rnc,
 						     remote_device_resume_done,
 						     idev);
 	if (status != SCI_SUCCESS)
 		return status;
 	sci_change_state(sm, SCI_DEV_STARTING);
 	return SCI_SUCCESS;
 }
 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
 						    struct isci_remote_device *idev)
 {
 	struct isci_host *ihost = iport->isci_host;
 	struct domain_device *dev = idev->domain_dev;
 	enum sci_status status;
 	if (dev->parent && dev_is_expander(dev->parent))
 		status = sci_remote_device_ea_construct(iport, idev);
 	else
 		status = sci_remote_device_da_construct(iport, idev);
 	if (status != SCI_SUCCESS) {
 		dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
 			__func__, status);
 		return status;
 	}
 	/* start the device. */
 	status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
 	if (status != SCI_SUCCESS)
 		dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
 			 status);
 	return status;
 }
 void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
 {
 	DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
 	dev_dbg(&ihost->pdev->dev,
 		"%s: idev = %p\n", __func__, idev);
 	/* Cleanup all requests pending for this device. */
 	isci_terminate_pending_requests(ihost, idev);
 	dev_dbg(&ihost->pdev->dev,
 		"%s: idev = %p, done\n", __func__, idev);
 }
 /**
  * This function builds the isci_remote_device when a libsas dev_found message
  *    is received.
  * @isci_host: This parameter specifies the isci host object.
  * @port: This parameter specifies the isci_port conected to this device.
  *
  * pointer to new isci_remote_device.
  */
 static struct isci_remote_device *
 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
 {
 	struct isci_remote_device *idev;
 	int i;
 	for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
 		idev = &ihost->devices[i];
 		if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
 			break;
 	}
 	if (i >= SCI_MAX_REMOTE_DEVICES) {
 		dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
 		return NULL;
 	}
 	if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
 		return NULL;
 	if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
 		return NULL;
 	return idev;
 }
 void isci_remote_device_release(struct kref *kref)
 {
 	struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
 	struct isci_host *ihost = idev->isci_port->isci_host;
 	idev->domain_dev = NULL;
 	idev->isci_port = NULL;
 	clear_bit(IDEV_START_PENDING, &idev->flags);
 	clear_bit(IDEV_STOP_PENDING, &idev->flags);
 	clear_bit(IDEV_IO_READY, &idev->flags);
 	clear_bit(IDEV_GONE, &idev->flags);
 	smp_mb__before_clear_bit();
 	clear_bit(IDEV_ALLOCATED, &idev->flags);
 	wake_up(&ihost->eventq);
 }
 /**
  * isci_remote_device_stop() - This function is called internally to stop the
  *    remote device.
  * @isci_host: This parameter specifies the isci host object.
  * @isci_device: This parameter specifies the remote device.
  *
  * The status of the ihost request to stop.
  */
 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
 {
 	enum sci_status status;
 	unsigned long flags;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: isci_device = %p\n", __func__, idev);
 	spin_lock_irqsave(&ihost->scic_lock, flags);
 	idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
 	set_bit(IDEV_GONE, &idev->flags);
 	spin_unlock_irqrestore(&ihost->scic_lock, flags);
 	/* Kill all outstanding requests. */
 	isci_remote_device_nuke_requests(ihost, idev);
 	set_bit(IDEV_STOP_PENDING, &idev->flags);
 	spin_lock_irqsave(&ihost->scic_lock, flags);
 	status = sci_remote_device_stop(idev, 50);
 	spin_unlock_irqrestore(&ihost->scic_lock, flags);
 	/* Wait for the stop complete callback. */
 	if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
 		/* nothing to wait for */;
 	else
 		wait_for_device_stop(ihost, idev);
 	return status;
 }
 /**
  * isci_remote_device_gone() - This function is called by libsas when a domain
  *    device is removed.
  * @domain_device: This parameter specifies the libsas domain device.
  *
  */
 void isci_remote_device_gone(struct domain_device *dev)
 {
 	struct isci_host *ihost = dev_to_ihost(dev);
 	struct isci_remote_device *idev = dev->lldd_dev;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
 		__func__, dev, idev, idev->isci_port);
 	isci_remote_device_stop(ihost, idev);
 }
 /**
  * isci_remote_device_found() - This function is called by libsas when a remote
  *    device is discovered. A remote device object is created and started. the
  *    function then sleeps until the sci core device started message is
  *    received.
  * @domain_device: This parameter specifies the libsas domain device.
  *
  * status, zero indicates success.
  */
 int isci_remote_device_found(struct domain_device *dev)
 {
 	struct isci_host *isci_host = dev_to_ihost(dev);
 	struct isci_port *isci_port = dev->port->lldd_port;
 	struct isci_remote_device *isci_device;
 	enum sci_status status;
 	dev_dbg(&isci_host->pdev->dev,
 		"%s: domain_device = %p\n", __func__, dev);
 	if (!isci_port)
 		return -ENODEV;
 	isci_device = isci_remote_device_alloc(isci_host, isci_port);
 	if (!isci_device)
 		return -ENODEV;
 	kref_init(&isci_device->kref);
 	INIT_LIST_HEAD(&isci_device->node);
 	spin_lock_irq(&isci_host->scic_lock);
 	isci_device->domain_dev = dev;
 	isci_device->isci_port = isci_port;
 	list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
 	set_bit(IDEV_START_PENDING, &isci_device->flags);
 	status = isci_remote_device_construct(isci_port, isci_device);
 	dev_dbg(&isci_host->pdev->dev,
 		"%s: isci_device = %p\n",
 		__func__, isci_device);
 	if (status == SCI_SUCCESS) {
 		/* device came up, advertise it to the world */
 		dev->lldd_dev = isci_device;
 	} else
 		isci_put_device(isci_device);
 	spin_unlock_irq(&isci_host->scic_lock);
 	/* wait for the device ready callback. */
 	wait_for_device_start(isci_host, isci_device);
 	return status == SCI_SUCCESS ? 0 : -ENODEV;
+}
+enum sci_status isci_remote_device_reset(
+	struct isci_remote_device *idev)
+{
+	struct isci_host *ihost = dev_to_ihost(idev->domain_dev);
+	unsigned long flags;
+	enum sci_status status;
+	/* Wait for the device suspend. */
+	status = isci_remote_device_suspend(ihost, idev);
+	if (status != SCI_SUCCESS) {
+		dev_dbg(&ihost->pdev->dev,
+			"%s: isci_remote_device_suspend(%p) returned %d!\n",
+			__func__, idev, status);
+		return status;
+	}
+	spin_lock_irqsave(&ihost->scic_lock, flags);
+	status = sci_remote_device_reset(idev);
+	spin_unlock_irqrestore(&ihost->scic_lock, flags);
+	if (status != SCI_SUCCESS) {
+		dev_dbg(&ihost->pdev->dev,
+			"%s: sci_remote_device_reset(%p) returned %d!\n",
+			__func__, idev, status);
+	}
+	return status;
+}
+int isci_remote_device_is_safe_to_abort(
+	struct isci_remote_device *idev)
+{
+	return sci_remote_node_context_is_safe_to_abort(&idev->rnc);

drivers/scsi/isci/remote_device.h

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _ISCI_REMOTE_DEVICE_H_
 #define _ISCI_REMOTE_DEVICE_H_
 #include <scsi/libsas.h>
 #include <linux/kref.h>
 #include "scu_remote_node_context.h"
 #include "remote_node_context.h"
 #include "port.h"
 enum sci_remote_device_not_ready_reason_code {
 	SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED,
 	SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED,
 	SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED,
 	SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED,
 	SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED,
 	SCIC_REMOTE_DEVICE_NOT_READY_REASON_CODE_MAX
 };
 /**
  * isci_remote_device - isci representation of a sas expander / end point
  * @device_port_width: hw setting for number of simultaneous connections
  * @connection_rate: per-taskcontext connection rate for this device
  * @working_request: SATA requests have no tag we for unaccelerated
  *                   protocols we need a method to associate unsolicited
  *                   frames with a pending request
  */
 struct isci_remote_device {
 	#define IDEV_START_PENDING 0
 	#define IDEV_STOP_PENDING 1
 	#define IDEV_ALLOCATED 2
 	#define IDEV_GONE 3
 	#define IDEV_IO_READY 4
 	#define IDEV_IO_NCQERROR 5
+	#define IDEV_TXRX_SUSPENDED 6
 	unsigned long flags;
 	struct kref kref;
 	struct isci_port *isci_port;
 	struct domain_device *domain_dev;
 	struct list_head node;
 	struct list_head reqs_in_process;
 	struct sci_base_state_machine sm;
 	u32 device_port_width;
 	enum sas_linkrate connection_rate;
 	struct isci_port *owning_port;
 	struct sci_remote_node_context rnc;
 	/* XXX unify with device reference counting and delete */
 	u32 started_request_count;
 	struct isci_request *working_request;
 	u32 not_ready_reason;
 };
 #define ISCI_REMOTE_DEVICE_START_TIMEOUT 5000
 /* device reference routines must be called under sci_lock */
 static inline struct isci_remote_device *isci_lookup_device(struct domain_device *dev)
 {
 	struct isci_remote_device *idev = dev->lldd_dev;
 	if (idev && !test_bit(IDEV_GONE, &idev->flags)) {
 		kref_get(&idev->kref);
 		return idev;
 	}
 	return NULL;
 }
 void isci_remote_device_release(struct kref *kref);
 static inline void isci_put_device(struct isci_remote_device *idev)
 {
 	if (idev)
 		kref_put(&idev->kref, isci_remote_device_release);
 }
 enum sci_status isci_remote_device_stop(struct isci_host *ihost,
 					struct isci_remote_device *idev);
 void isci_remote_device_nuke_requests(struct isci_host *ihost,
 				      struct isci_remote_device *idev);
 void isci_remote_device_gone(struct domain_device *domain_dev);
 int isci_remote_device_found(struct domain_device *domain_dev);
 /**
  * sci_remote_device_stop() - This method will stop both transmission and
  *    reception of link activity for the supplied remote device.  This method
  *    disables normal IO requests from flowing through to the remote device.
  * @remote_device: This parameter specifies the device to be stopped.
  * @timeout: This parameter specifies the number of milliseconds in which the
  *    stop operation should complete.
  *
  * An indication of whether the device was successfully stopped. SCI_SUCCESS
  * This value is returned if the transmission and reception for the device was
  * successfully stopped.
  */
 enum sci_status sci_remote_device_stop(
 	struct isci_remote_device *idev,
 	u32 timeout);
 /**
  * sci_remote_device_reset() - This method will reset the device making it
  *    ready for operation. This method must be called anytime the device is
  *    reset either through a SMP phy control or a port hard reset request.
  * @remote_device: This parameter specifies the device to be reset.
  *
  * This method does not actually cause the device hardware to be reset. This
  * method resets the software object so that it will be operational after a
  * device hardware reset completes. An indication of whether the device reset
  * was accepted. SCI_SUCCESS This value is returned if the device reset is
  * started.
  */
 enum sci_status sci_remote_device_reset(
 	struct isci_remote_device *idev);
 /**
  * sci_remote_device_reset_complete() - This method informs the device object
  *    that the reset operation is complete and the device can resume operation
  *    again.
  * @remote_device: This parameter specifies the device which is to be informed
  *    of the reset complete operation.
  *
  * An indication that the device is resuming operation. SCI_SUCCESS the device
  * is resuming operation.
  */
 enum sci_status sci_remote_device_reset_complete(
 	struct isci_remote_device *idev);
 /**
  * enum sci_remote_device_states - This enumeration depicts all the states
  *    for the common remote device state machine.
  * @SCI_DEV_INITIAL: Simply the initial state for the base remote device
  * state machine.
  *
  * @SCI_DEV_STOPPED: This state indicates that the remote device has
  * successfully been stopped.  In this state no new IO operations are
  * permitted.  This state is entered from the INITIAL state.  This state
  * is entered from the STOPPING state.
  *
  * @SCI_DEV_STARTING: This state indicates the the remote device is in
  * the process of becoming ready (i.e. starting).  In this state no new
  * IO operations are permitted.  This state is entered from the STOPPED
  * state.
  *
  * @SCI_DEV_READY: This state indicates the remote device is now ready.
  * Thus, the user is able to perform IO operations on the remote device.
  * This state is entered from the STARTING state.
  *
  * @SCI_STP_DEV_IDLE: This is the idle substate for the stp remote
  * device.  When there are no active IO for the device it is is in this
  * state.
  *
  * @SCI_STP_DEV_CMD: This is the command state for for the STP remote
  * device.  This state is entered when the device is processing a
  * non-NCQ command.  The device object will fail any new start IO
  * requests until this command is complete.
  *
  * @SCI_STP_DEV_NCQ: This is the NCQ state for the STP remote device.
  * This state is entered when the device is processing an NCQ reuqest.
  * It will remain in this state so long as there is one or more NCQ
  * requests being processed.
  *
  * @SCI_STP_DEV_NCQ_ERROR: This is the NCQ error state for the STP
  * remote device.  This state is entered when an SDB error FIS is
  * received by the device object while in the NCQ state.  The device
  * object will only accept a READ LOG command while in this state.
  *
  * @SCI_STP_DEV_ATAPI_ERROR: This is the ATAPI error state for the STP
  * ATAPI remote device.  This state is entered when ATAPI device sends
  * error status FIS without data while the device object is in CMD
  * state.  A suspension event is expected in this state.  The device
  * object will resume right away.
  *
  * @SCI_STP_DEV_AWAIT_RESET: This is the READY substate indicates the
  * device is waiting for the RESET task coming to be recovered from
  * certain hardware specific error.
  *
  * @SCI_SMP_DEV_IDLE: This is the ready operational substate for the
  * remote device.  This is the normal operational state for a remote
  * device.
  *
  * @SCI_SMP_DEV_CMD: This is the suspended state for the remote device.
  * This is the state that the device is placed in when a RNC suspend is
  * received by the SCU hardware.
  *
  * @SCI_DEV_STOPPING: This state indicates that the remote device is in
  * the process of stopping.  In this state no new IO operations are
  * permitted, but existing IO operations are allowed to complete.  This
  * state is entered from the READY state.  This state is entered from
  * the FAILED state.
  *
  * @SCI_DEV_FAILED: This state indicates that the remote device has
  * failed.  In this state no new IO operations are permitted.  This
  * state is entered from the INITIALIZING state.  This state is entered
  * from the READY state.
  *
  * @SCI_DEV_RESETTING: This state indicates the device is being reset.
  * In this state no new IO operations are permitted.  This state is
  * entered from the READY state.
  *
  * @SCI_DEV_FINAL: Simply the final state for the base remote device
  * state machine.
  */
 #define REMOTE_DEV_STATES {\
 	C(DEV_INITIAL),\
 	C(DEV_STOPPED),\
 	C(DEV_STARTING),\
 	C(DEV_READY),\
 	C(STP_DEV_IDLE),\
 	C(STP_DEV_CMD),\
 	C(STP_DEV_NCQ),\
 	C(STP_DEV_NCQ_ERROR),\
 	C(STP_DEV_ATAPI_ERROR),\
 	C(STP_DEV_AWAIT_RESET),\
 	C(SMP_DEV_IDLE),\
 	C(SMP_DEV_CMD),\
 	C(DEV_STOPPING),\
 	C(DEV_FAILED),\
 	C(DEV_RESETTING),\
 	C(DEV_FINAL),\
 	}
 #undef C
 #define C(a) SCI_##a
 enum sci_remote_device_states REMOTE_DEV_STATES;
 #undef C
 const char *dev_state_name(enum sci_remote_device_states state);
 static inline struct isci_remote_device *rnc_to_dev(struct sci_remote_node_context *rnc)
 {
 	struct isci_remote_device *idev;
 	idev = container_of(rnc, typeof(*idev), rnc);
 	return idev;
 }
 static inline bool dev_is_expander(struct domain_device *dev)
 {
 	return dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV;
 }
 static inline void sci_remote_device_decrement_request_count(struct isci_remote_device *idev)
 {
 	/* XXX delete this voodoo when converting to the top-level device
 	 * reference count
 	 */
 	if (WARN_ONCE(idev->started_request_count == 0,
 		      "%s: tried to decrement started_request_count past 0!?",
 			__func__))
 		/* pass */;
 	else
 		idev->started_request_count--;
 }
 static inline void isci_dev_set_hang_detection_timeout(
 	struct isci_remote_device *idev,
 	u32 timeout)
 {
 	sci_port_set_hang_detection_timeout(idev->owning_port, timeout);
 }
 enum sci_status sci_remote_device_frame_handler(
 	struct isci_remote_device *idev,
 	u32 frame_index);
 enum sci_status sci_remote_device_event_handler(
 	struct isci_remote_device *idev,
 	u32 event_code);
 enum sci_status sci_remote_device_start_io(
 	struct isci_host *ihost,
 	struct isci_remote_device *idev,
 	struct isci_request *ireq);
 enum sci_status sci_remote_device_start_task(
 	struct isci_host *ihost,
 	struct isci_remote_device *idev,
 	struct isci_request *ireq);
 enum sci_status sci_remote_device_complete_io(
 	struct isci_host *ihost,
 	struct isci_remote_device *idev,
 	struct isci_request *ireq);
 void sci_remote_device_post_request(
 	struct isci_remote_device *idev,
 	u32 request);
+enum sci_status sci_remote_device_terminate_requests(
+	struct isci_remote_device *idev);
+int isci_remote_device_is_safe_to_abort(
+	struct isci_remote_device *idev);
+enum sci_status
+sci_remote_device_abort_requests_pending_abort(
+	struct isci_remote_device *idev);
 #endif /* !defined(_ISCI_REMOTE_DEVICE_H_) */

drivers/scsi/isci/remote_node_context.c

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "host.h"
 #include "isci.h"
 #include "remote_device.h"
 #include "remote_node_context.h"
 #include "scu_event_codes.h"
 #include "scu_task_context.h"
 #undef C
 #define C(a) (#a)
 const char *rnc_state_name(enum scis_sds_remote_node_context_states state)
 {
 	static const char * const strings[] = RNC_STATES;
 	return strings[state];
 }
 #undef C
 /**
  *
  * @sci_rnc: The state of the remote node context object to check.
  *
  * This method will return true if the remote node context is in a READY state
  * otherwise it will return false bool true if the remote node context is in
  * the ready state. false if the remote node context is not in the ready state.
  */
 bool sci_remote_node_context_is_ready(
 	struct sci_remote_node_context *sci_rnc)
 {
 	u32 current_state = sci_rnc->sm.current_state_id;
 	if (current_state == SCI_RNC_READY) {
 		return true;
 	}
 	return false;
 }
 static union scu_remote_node_context *sci_rnc_by_id(struct isci_host *ihost, u16 id)
 {
 	if (id < ihost->remote_node_entries &&
 	    ihost->device_table[id])
 		return &ihost->remote_node_context_table[id];
 	return NULL;
 }
 static void sci_remote_node_context_construct_buffer(struct sci_remote_node_context *sci_rnc)
 {
 	struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 	struct domain_device *dev = idev->domain_dev;
 	int rni = sci_rnc->remote_node_index;
 	union scu_remote_node_context *rnc;
 	struct isci_host *ihost;
 	__le64 sas_addr;
 	ihost = idev->owning_port->owning_controller;
 	rnc = sci_rnc_by_id(ihost, rni);
 	memset(rnc, 0, sizeof(union scu_remote_node_context)
 		* sci_remote_device_node_count(idev));
 	rnc->ssp.remote_node_index = rni;
 	rnc->ssp.remote_node_port_width = idev->device_port_width;
 	rnc->ssp.logical_port_index = idev->owning_port->physical_port_index;
 	/* sas address is __be64, context ram format is __le64 */
 	sas_addr = cpu_to_le64(SAS_ADDR(dev->sas_addr));
 	rnc->ssp.remote_sas_address_hi = upper_32_bits(sas_addr);
 	rnc->ssp.remote_sas_address_lo = lower_32_bits(sas_addr);
 	rnc->ssp.nexus_loss_timer_enable = true;
 	rnc->ssp.check_bit               = false;
 	rnc->ssp.is_valid                = false;
 	rnc->ssp.is_remote_node_context  = true;
 	rnc->ssp.function_number         = 0;
 	rnc->ssp.arbitration_wait_time = 0;
 	if (dev_is_sata(dev)) {
 		rnc->ssp.connection_occupancy_timeout =
 			ihost->user_parameters.stp_max_occupancy_timeout;
 		rnc->ssp.connection_inactivity_timeout =
 			ihost->user_parameters.stp_inactivity_timeout;
 	} else {
 		rnc->ssp.connection_occupancy_timeout  =
 			ihost->user_parameters.ssp_max_occupancy_timeout;
 		rnc->ssp.connection_inactivity_timeout =
 			ihost->user_parameters.ssp_inactivity_timeout;
 	}
 	rnc->ssp.initial_arbitration_wait_time = 0;
 	/* Open Address Frame Parameters */
 	rnc->ssp.oaf_connection_rate = idev->connection_rate;
 	rnc->ssp.oaf_features = 0;
 	rnc->ssp.oaf_source_zone_group = 0;
 	rnc->ssp.oaf_more_compatibility_features = 0;
 }
 /**
  *
  * @sci_rnc:
  * @callback:
  * @callback_parameter:
  *
  * This method will setup the remote node context object so it will transition
  * to its ready state.  If the remote node context is already setup to
  * transition to its final state then this function does nothing. none
  */
 static void sci_remote_node_context_setup_to_resume(
 	struct sci_remote_node_context *sci_rnc,
 	scics_sds_remote_node_context_callback callback,
 	void *callback_parameter)
 {
 	if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
 		sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
 		sci_rnc->user_callback     = callback;
 		sci_rnc->user_cookie       = callback_parameter;
 	}
 }
 static void sci_remote_node_context_setup_to_destory(
 	struct sci_remote_node_context *sci_rnc,
 	scics_sds_remote_node_context_callback callback,
 	void *callback_parameter)
 {
 	sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
 	sci_rnc->user_callback     = callback;
 	sci_rnc->user_cookie       = callback_parameter;
 }
 /**
  *
  *
  * This method just calls the user callback function and then resets the
  * callback.
  */
 static void sci_remote_node_context_notify_user(
 	struct sci_remote_node_context *rnc)
 {
 	if (rnc->user_callback != NULL) {
 		(*rnc->user_callback)(rnc->user_cookie);
 		rnc->user_callback = NULL;
 		rnc->user_cookie = NULL;
 	}
 }
 static void sci_remote_node_context_continue_state_transitions(struct sci_remote_node_context *rnc)
 {
 	if (rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
 		sci_remote_node_context_resume(rnc, rnc->user_callback,
 						    rnc->user_cookie);
 }
 static void sci_remote_node_context_validate_context_buffer(struct sci_remote_node_context *sci_rnc)
 {
 	union scu_remote_node_context *rnc_buffer;
 	struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 	struct domain_device *dev = idev->domain_dev;
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	rnc_buffer = sci_rnc_by_id(ihost, sci_rnc->remote_node_index);
 	rnc_buffer->ssp.is_valid = true;
 	if (dev_is_sata(dev) && dev->parent) {
 		sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_96);
 	} else {
 		sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_32);
 		if (!dev->parent)
 			sci_port_setup_transports(idev->owning_port,
 						  sci_rnc->remote_node_index);
 	}
 }
 static void sci_remote_node_context_invalidate_context_buffer(struct sci_remote_node_context *sci_rnc)
 {
 	union scu_remote_node_context *rnc_buffer;
 	struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 	struct isci_host *ihost = idev->owning_port->owning_controller;
 	rnc_buffer = sci_rnc_by_id(ihost, sci_rnc->remote_node_index);
 	rnc_buffer->ssp.is_valid = false;
 	sci_remote_device_post_request(rnc_to_dev(sci_rnc),
 				       SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE);
 }
 static void sci_remote_node_context_initial_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 	/* Check to see if we have gotten back to the initial state because
 	 * someone requested to destroy the remote node context object.
 	 */
 	if (sm->previous_state_id == SCI_RNC_INVALIDATING) {
 		rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 		sci_remote_node_context_notify_user(rnc);
 	}
 }
 static void sci_remote_node_context_posting_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *sci_rnc = container_of(sm, typeof(*sci_rnc), sm);
 	sci_remote_node_context_validate_context_buffer(sci_rnc);
 }
 static void sci_remote_node_context_invalidating_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
+	/* Terminate outstanding requests pending abort. */
+	sci_remote_device_abort_requests_pending_abort(rnc_to_dev(rnc));
 	sci_remote_node_context_invalidate_context_buffer(rnc);
 }
 static void sci_remote_node_context_resuming_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 	struct isci_remote_device *idev;
 	struct domain_device *dev;
 	idev = rnc_to_dev(rnc);
 	dev = idev->domain_dev;
 	/*
 	 * For direct attached SATA devices we need to clear the TLCR
 	 * NCQ to TCi tag mapping on the phy and in cases where we
 	 * resume because of a target reset we also need to update
 	 * the STPTLDARNI register with the RNi of the device
 	 */
 	if (dev_is_sata(dev) && !dev->parent)
 		sci_port_setup_transports(idev->owning_port, rnc->remote_node_index);
 	sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_RESUME);
 }
 static void sci_remote_node_context_ready_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 	rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 	if (rnc->user_callback)
 		sci_remote_node_context_notify_user(rnc);
 }
 static void sci_remote_node_context_tx_suspended_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 	sci_remote_node_context_continue_state_transitions(rnc);
 }
 static void sci_remote_node_context_tx_rx_suspended_state_enter(struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
+	struct isci_remote_device *idev = rnc_to_dev(rnc);
+	struct isci_host *ihost = idev->owning_port->owning_controller;
+	set_bit(IDEV_TXRX_SUSPENDED, &idev->flags);
+	/* Terminate outstanding requests pending abort. */
+	sci_remote_device_abort_requests_pending_abort(idev);
+	wake_up(&ihost->eventq);
 	sci_remote_node_context_continue_state_transitions(rnc);
 }
+static void sci_remote_node_context_tx_rx_suspended_state_exit(
+	struct sci_base_state_machine *sm)
+{
+	struct sci_remote_node_context *rnc
+		= container_of(sm, typeof(*rnc), sm);
+	struct isci_remote_device *idev = rnc_to_dev(rnc);
+	clear_bit(IDEV_TXRX_SUSPENDED, &idev->flags);
+}
 static void sci_remote_node_context_await_suspend_state_exit(
 	struct sci_base_state_machine *sm)
 {
 	struct sci_remote_node_context *rnc
 		= container_of(sm, typeof(*rnc), sm);
 	isci_dev_set_hang_detection_timeout(rnc_to_dev(rnc), 0);
 }
 static const struct sci_base_state sci_remote_node_context_state_table[] = {
 	[SCI_RNC_INITIAL] = {
 		.enter_state = sci_remote_node_context_initial_state_enter,
 	},
 	[SCI_RNC_POSTING] = {
 		.enter_state = sci_remote_node_context_posting_state_enter,
 	},
 	[SCI_RNC_INVALIDATING] = {
 		.enter_state = sci_remote_node_context_invalidating_state_enter,
 	},
 	[SCI_RNC_RESUMING] = {
 		.enter_state = sci_remote_node_context_resuming_state_enter,
 	},
 	[SCI_RNC_READY] = {
 		.enter_state = sci_remote_node_context_ready_state_enter,
 	},
 	[SCI_RNC_TX_SUSPENDED] = {
 		.enter_state = sci_remote_node_context_tx_suspended_state_enter,
 	},
 	[SCI_RNC_TX_RX_SUSPENDED] = {
 		.enter_state = sci_remote_node_context_tx_rx_suspended_state_enter,
+		.exit_state
+			= sci_remote_node_context_tx_rx_suspended_state_exit,
 	},
 	[SCI_RNC_AWAIT_SUSPENSION] = {
 		.exit_state = sci_remote_node_context_await_suspend_state_exit,
 	},
 };
 void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
 					    u16 remote_node_index)
 {
 	memset(rnc, 0, sizeof(struct sci_remote_node_context));
 	rnc->remote_node_index = remote_node_index;
 	rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 	sci_init_sm(&rnc->sm, sci_remote_node_context_state_table, SCI_RNC_INITIAL);
 }
 enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_context *sci_rnc,
 							   u32 event_code)
 {
 	enum scis_sds_remote_node_context_states state;
 	u32 next_state;
 	state = sci_rnc->sm.current_state_id;
 	switch (state) {
 	case SCI_RNC_POSTING:
 		switch (scu_get_event_code(event_code)) {
 		case SCU_EVENT_POST_RNC_COMPLETE:
 			sci_change_state(&sci_rnc->sm, SCI_RNC_READY);
 			break;
 		default:
 			goto out;
 		}
 		break;
 	case SCI_RNC_INVALIDATING:
 		if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
 			if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL)
 				state = SCI_RNC_INITIAL;
 			else
 				state = SCI_RNC_POSTING;
 			sci_change_state(&sci_rnc->sm, state);
 		} else {
 			switch (scu_get_event_type(event_code)) {
 			case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
 			case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
 				/* We really dont care if the hardware is going to suspend
 				 * the device since it's being invalidated anyway */
 				dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 					"%s: SCIC Remote Node Context 0x%p was "
 					"suspeneded by hardware while being "
 					"invalidated.\n", __func__, sci_rnc);
 				break;
 			default:
 				goto out;
 			}
 		}
 		break;
 	case SCI_RNC_RESUMING:
 		if (scu_get_event_code(event_code) == SCU_EVENT_POST_RCN_RELEASE) {
 			sci_change_state(&sci_rnc->sm, SCI_RNC_READY);
 		} else {
 			switch (scu_get_event_type(event_code)) {
 			case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
 			case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
 				/* We really dont care if the hardware is going to suspend
 				 * the device since it's being resumed anyway */
 				dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 					"%s: SCIC Remote Node Context 0x%p was "
 					"suspeneded by hardware while being resumed.\n",
 					__func__, sci_rnc);
 				break;
 			default:
 				goto out;
 			}
 		}
 		break;
 	case SCI_RNC_READY:
 		switch (scu_get_event_type(event_code)) {
 		case SCU_EVENT_TL_RNC_SUSPEND_TX:
 			sci_change_state(&sci_rnc->sm, SCI_RNC_TX_SUSPENDED);
 			sci_rnc->suspend_type = scu_get_event_type(event_code);
 			break;
 		case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
 			sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
 			sci_rnc->suspend_type = scu_get_event_type(event_code);
 			break;
 		default:
 			goto out;
 		}
 		break;
 	case SCI_RNC_AWAIT_SUSPENSION:
 		switch (scu_get_event_type(event_code)) {
 		case SCU_EVENT_TL_RNC_SUSPEND_TX:
 			next_state = SCI_RNC_TX_SUSPENDED;
 			break;
 		case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
 			next_state = SCI_RNC_TX_RX_SUSPENDED;
 			break;
 		default:
 			goto out;
 		}
 		if (sci_rnc->suspend_type == scu_get_event_type(event_code))
 			sci_change_state(&sci_rnc->sm, next_state);
 		break;
 	default:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state: %s\n", __func__,
 			 rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	return SCI_SUCCESS;
  out:
 	dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 		 "%s: code: %#x state: %s\n", __func__, event_code,
 		 rnc_state_name(state));
 	return SCI_FAILURE;
 }
 enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context *sci_rnc,
 						      scics_sds_remote_node_context_callback cb_fn,
 						      void *cb_p)
 {
 	enum scis_sds_remote_node_context_states state;
 	state = sci_rnc->sm.current_state_id;
 	switch (state) {
 	case SCI_RNC_INVALIDATING:
 		sci_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
 		return SCI_SUCCESS;
 	case SCI_RNC_POSTING:
 	case SCI_RNC_RESUMING:
 	case SCI_RNC_READY:
 	case SCI_RNC_TX_SUSPENDED:
 	case SCI_RNC_TX_RX_SUSPENDED:
 	case SCI_RNC_AWAIT_SUSPENSION:
 		sci_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
 		sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
 		return SCI_SUCCESS;
 	case SCI_RNC_INITIAL:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state: %s\n", __func__,
 			 rnc_state_name(state));
 		/* We have decided that the destruct request on the remote node context
 		 * can not fail since it is either in the initial/destroyed state or is
 		 * can be destroyed.
 		 */
 		return SCI_SUCCESS;
 	default:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state %s\n", __func__,
 			 rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 }
 enum sci_status sci_remote_node_context_suspend(
 			struct sci_remote_node_context *sci_rnc,
 			enum sci_remote_node_suspension_reasons suspend_reason,
 			u32 suspend_type,
 			scics_sds_remote_node_context_callback cb_fn,
 			void *cb_p)
 {
 	enum scis_sds_remote_node_context_states state
 		= sci_rnc->sm.current_state_id;
 	struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 	enum sci_status status = SCI_FAILURE_INVALID_STATE;
+	dev_dbg(scirdev_to_dev(idev),
+		"%s: current state %d, current suspend_type %x dest state %d,"
+			" arg suspend_reason %d, arg suspend_type %x",
+		__func__, state, sci_rnc->suspend_type,
+		sci_rnc->destination_state, suspend_reason,
+		suspend_type);
 	/* Disable automatic state continuations if explicitly suspending. */
 	if (suspend_reason == SCI_SOFTWARE_SUSPENSION)
 		sci_rnc->destination_state
 			= SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 	switch (state) {
 	case SCI_RNC_READY:
 		break;
 	case SCI_RNC_TX_SUSPENDED:
 		if (suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX)
 			status = SCI_SUCCESS;
 		break;
 	case SCI_RNC_TX_RX_SUSPENDED:
 		if (suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX_RX)
 			status = SCI_SUCCESS;
 		break;
 	case SCI_RNC_AWAIT_SUSPENSION:
 		if ((sci_rnc->suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX_RX)
 		    || (suspend_type == sci_rnc->suspend_type))
 			return SCI_SUCCESS;
 		break;
 	default:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state %s\n", __func__,
 			 rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	sci_rnc->user_callback = cb_fn;
 	sci_rnc->user_cookie   = cb_p;
 	sci_rnc->suspend_type  = suspend_type;
 	if (status == SCI_SUCCESS) { /* Already in the destination state? */
+		struct isci_host *ihost = idev->owning_port->owning_controller;
 		sci_remote_node_context_notify_user(sci_rnc);
+		wake_up_all(&ihost->eventq); /* Let observers look. */
 		return SCI_SUCCESS;
 	}
 	if (suspend_reason == SCI_SOFTWARE_SUSPENSION) {
 		isci_dev_set_hang_detection_timeout(idev, 0x00000001);
 		sci_remote_device_post_request(
 			idev, SCI_SOFTWARE_SUSPEND_CMD);
 	}
 	if (state != SCI_RNC_AWAIT_SUSPENSION)
 		sci_change_state(&sci_rnc->sm, SCI_RNC_AWAIT_SUSPENSION);
 	return SCI_SUCCESS;
 }
 enum sci_status sci_remote_node_context_resume(struct sci_remote_node_context *sci_rnc,
 						    scics_sds_remote_node_context_callback cb_fn,
 						    void *cb_p)
 {
 	enum scis_sds_remote_node_context_states state;
 	state = sci_rnc->sm.current_state_id;
 	switch (state) {
 	case SCI_RNC_INITIAL:
 		if (sci_rnc->remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
 			return SCI_FAILURE_INVALID_STATE;
 		sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
 		sci_remote_node_context_construct_buffer(sci_rnc);
 		sci_change_state(&sci_rnc->sm, SCI_RNC_POSTING);
 		return SCI_SUCCESS;
 	case SCI_RNC_POSTING:
 	case SCI_RNC_INVALIDATING:
 	case SCI_RNC_RESUMING:
 		if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
 			return SCI_FAILURE_INVALID_STATE;
 		sci_rnc->user_callback = cb_fn;
 		sci_rnc->user_cookie   = cb_p;
 		return SCI_SUCCESS;
 	case SCI_RNC_TX_SUSPENDED:
 	case SCI_RNC_TX_RX_SUSPENDED: {
 		struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 		struct domain_device *dev = idev->domain_dev;
 		/* If this is an expander attached SATA device we must
 		 * invalidate and repost the RNC since this is the only way
 		 * to clear the TCi to NCQ tag mapping table for the RNi.
 		 * All other device types we can just resume.
 		 */
 		sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
 		if (dev_is_sata(dev) && dev->parent)
 			sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
 		else
 			sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
 		return SCI_SUCCESS;
 	}
 	case SCI_RNC_AWAIT_SUSPENSION:
 		sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
 		return SCI_SUCCESS;
 	default:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state %s\n", __func__,
 			 rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 }
 enum sci_status sci_remote_node_context_start_io(struct sci_remote_node_context *sci_rnc,
 							     struct isci_request *ireq)
 {
 	enum scis_sds_remote_node_context_states state;
 	state = sci_rnc->sm.current_state_id;
 	switch (state) {
 	case SCI_RNC_READY:
 		return SCI_SUCCESS;
 	case SCI_RNC_TX_SUSPENDED:
 	case SCI_RNC_TX_RX_SUSPENDED:
 	case SCI_RNC_AWAIT_SUSPENSION:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			 "%s: invalid state %s\n", __func__,
 			 rnc_state_name(state));
 		return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
 	default:
 		dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			"%s: invalid state %s\n", __func__,
 			rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 }
 enum sci_status sci_remote_node_context_start_task(struct sci_remote_node_context *sci_rnc,
 							struct isci_request *ireq)
 {
 	enum scis_sds_remote_node_context_states state;
 	state = sci_rnc->sm.current_state_id;
 	switch (state) {
 	case SCI_RNC_RESUMING:
 	case SCI_RNC_READY:
 	case SCI_RNC_AWAIT_SUSPENSION:
 		return SCI_SUCCESS;
 	case SCI_RNC_TX_SUSPENDED:
 	case SCI_RNC_TX_RX_SUSPENDED:
 		sci_remote_node_context_resume(sci_rnc, NULL, NULL);
 		return SCI_SUCCESS;
 	default:
 		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
 			"%s: invalid state %s\n", __func__,
 			rnc_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
+	}
+}
+int sci_remote_node_context_is_safe_to_abort(
+	struct sci_remote_node_context *sci_rnc)
+{
+	enum scis_sds_remote_node_context_states state;
+	state = sci_rnc->sm.current_state_id;
+	switch (state) {
+	case SCI_RNC_INVALIDATING:
+	case SCI_RNC_TX_RX_SUSPENDED:
+		return 1;
+	case SCI_RNC_POSTING:
+	case SCI_RNC_RESUMING:
+	case SCI_RNC_READY:
+	case SCI_RNC_TX_SUSPENDED:
+	case SCI_RNC_AWAIT_SUSPENSION:
+	case SCI_RNC_INITIAL:
+		return 0;
+	default:
+		dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+			 "%s: invalid state %d\n", __func__, state);
+		return 0;
 	}
 }

drivers/scsi/isci/remote_node_context.h

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _SCIC_SDS_REMOTE_NODE_CONTEXT_H_
 #define _SCIC_SDS_REMOTE_NODE_CONTEXT_H_
 /**
  * This file contains the structures, constants, and prototypes associated with
  *    the remote node context in the silicon.  It exists to model and manage
  *    the remote node context in the silicon.
  *
  *
  */
 #include "isci.h"
 /**
  *
  *
  * This constant represents an invalid remote device id, it is used to program
  * the STPDARNI register so the driver knows when it has received a SIGNATURE
  * FIS from the SCU.
  */
 #define SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX    0x0FFF
 enum sci_remote_node_suspension_reasons {
 	SCU_HARDWARE_SUSPENSION,
 	SCI_SOFTWARE_SUSPENSION
 };
 #define SCI_SOFTWARE_SUSPEND_CMD SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX
 #define SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT SCU_EVENT_TL_RNC_SUSPEND_TX_RX
 struct isci_request;
 struct isci_remote_device;
 struct sci_remote_node_context;
 typedef void (*scics_sds_remote_node_context_callback)(void *);
 /**
  * enum sci_remote_node_context_states
  * @SCI_RNC_INITIAL initial state for a remote node context.  On a resume
  * request the remote node context will transition to the posting state.
  *
  * @SCI_RNC_POSTING: transition state that posts the RNi to the hardware. Once
  * the RNC is posted the remote node context will be made ready.
  *
  * @SCI_RNC_INVALIDATING: transition state that will post an RNC invalidate to
  * the hardware.  Once the invalidate is complete the remote node context will
  * transition to the posting state.
  *
  * @SCI_RNC_RESUMING: transition state that will post an RNC resume to the
  * hardare.  Once the event notification of resume complete is received the
  * remote node context will transition to the ready state.
  *
  * @SCI_RNC_READY: state that the remote node context must be in to accept io
  * request operations.
  *
  * @SCI_RNC_TX_SUSPENDED: state that the remote node context transitions to when
  * it gets a TX suspend notification from the hardware.
  *
  * @SCI_RNC_TX_RX_SUSPENDED: state that the remote node context transitions to
  * when it gets a TX RX suspend notification from the hardware.
  *
  * @SCI_RNC_AWAIT_SUSPENSION: wait state for the remote node context that waits
  * for a suspend notification from the hardware.  This state is entered when
  * either there is a request to supend the remote node context or when there is
  * a TC completion where the remote node will be suspended by the hardware.
  */
 #define RNC_STATES {\
 	C(RNC_INITIAL),\
 	C(RNC_POSTING),\
 	C(RNC_INVALIDATING),\
 	C(RNC_RESUMING),\
 	C(RNC_READY),\
 	C(RNC_TX_SUSPENDED),\
 	C(RNC_TX_RX_SUSPENDED),\
 	C(RNC_AWAIT_SUSPENSION),\
 	}
 #undef C
 #define C(a) SCI_##a
 enum scis_sds_remote_node_context_states RNC_STATES;
 #undef C
 const char *rnc_state_name(enum scis_sds_remote_node_context_states state);
 /**
  *
  *
  * This enumeration is used to define the end destination state for the remote
  * node context.
  */
 enum sci_remote_node_context_destination_state {
 	SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED,
 	SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY,
 	SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL
 };
 /**
  * struct sci_remote_node_context - This structure contains the data
  *    associated with the remote node context object.  The remote node context
  *    (RNC) object models the the remote device information necessary to manage
  *    the silicon RNC.
  */
 struct sci_remote_node_context {
 	/**
 	 * This field indicates the remote node index (RNI) associated with
 	 * this RNC.
 	 */
 	u16 remote_node_index;
 	/**
 	 * This field is the recored suspension type of the remote node
 	 * context suspension.
 	 */
 	u32 suspend_type;
 	/**
 	 * This field is true if the remote node context is resuming from its current
 	 * state.  This can cause an automatic resume on receiving a suspension
 	 * notification.
 	 */
 	enum sci_remote_node_context_destination_state destination_state;
 	/**
 	 * This field contains the callback function that the user requested to be
 	 * called when the requested state transition is complete.
 	 */
 	scics_sds_remote_node_context_callback user_callback;
 	/**
 	 * This field contains the parameter that is called when the user requested
 	 * state transition is completed.
 	 */
 	void *user_cookie;
 	/**
 	 * This field contains the data for the object's state machine.
 	 */
 	struct sci_base_state_machine sm;
 };
 void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
 					    u16 remote_node_index);
 bool sci_remote_node_context_is_ready(
 	struct sci_remote_node_context *sci_rnc);
 enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_context *sci_rnc,
 							   u32 event_code);
 enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context *sci_rnc,
 						      scics_sds_remote_node_context_callback callback,
 						      void *callback_parameter);
 enum sci_status sci_remote_node_context_suspend(struct sci_remote_node_context *sci_rnc,
 						     u32 suspend_type,
 						     u32 suspension_code,
 						     scics_sds_remote_node_context_callback cb_fn,
 						     void *cb_p);
 enum sci_status sci_remote_node_context_resume(struct sci_remote_node_context *sci_rnc,
 						    scics_sds_remote_node_context_callback cb_fn,
 						    void *cb_p);
 enum sci_status sci_remote_node_context_start_task(struct sci_remote_node_context *sci_rnc,
 							struct isci_request *ireq);
 enum sci_status sci_remote_node_context_start_io(struct sci_remote_node_context *sci_rnc,
 						      struct isci_request *ireq);
+int sci_remote_node_context_is_safe_to_abort(
+	struct sci_remote_node_context *sci_rnc);
 #endif  /* _SCIC_SDS_REMOTE_NODE_CONTEXT_H_ */

drivers/scsi/isci/request.c

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <scsi/scsi_cmnd.h>
 #include "isci.h"
 #include "task.h"
 #include "request.h"
 #include "scu_completion_codes.h"
 #include "scu_event_codes.h"
 #include "sas.h"
 #undef C
 #define C(a) (#a)
 const char *req_state_name(enum sci_base_request_states state)
 {
 	static const char * const strings[] = REQUEST_STATES;
 	return strings[state];
 }
 #undef C
 static struct scu_sgl_element_pair *to_sgl_element_pair(struct isci_request *ireq,
 							int idx)
 {
 	if (idx == 0)
 		return &ireq->tc->sgl_pair_ab;
 	else if (idx == 1)
 		return &ireq->tc->sgl_pair_cd;
 	else if (idx < 0)
 		return NULL;
 	else
 		return &ireq->sg_table[idx - 2];
 }
 static dma_addr_t to_sgl_element_pair_dma(struct isci_host *ihost,
 					  struct isci_request *ireq, u32 idx)
 {
 	u32 offset;
 	if (idx == 0) {
 		offset = (void *) &ireq->tc->sgl_pair_ab -
 			 (void *) &ihost->task_context_table[0];
 		return ihost->tc_dma + offset;
 	} else if (idx == 1) {
 		offset = (void *) &ireq->tc->sgl_pair_cd -
 			 (void *) &ihost->task_context_table[0];
 		return ihost->tc_dma + offset;
 	}
 	return sci_io_request_get_dma_addr(ireq, &ireq->sg_table[idx - 2]);
 }
 static void init_sgl_element(struct scu_sgl_element *e, struct scatterlist *sg)
 {
 	e->length = sg_dma_len(sg);
 	e->address_upper = upper_32_bits(sg_dma_address(sg));
 	e->address_lower = lower_32_bits(sg_dma_address(sg));
 	e->address_modifier = 0;
 }
 static void sci_request_build_sgl(struct isci_request *ireq)
 {
 	struct isci_host *ihost = ireq->isci_host;
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct scatterlist *sg = NULL;
 	dma_addr_t dma_addr;
 	u32 sg_idx = 0;
 	struct scu_sgl_element_pair *scu_sg   = NULL;
 	struct scu_sgl_element_pair *prev_sg  = NULL;
 	if (task->num_scatter > 0) {
 		sg = task->scatter;
 		while (sg) {
 			scu_sg = to_sgl_element_pair(ireq, sg_idx);
 			init_sgl_element(&scu_sg->A, sg);
 			sg = sg_next(sg);
 			if (sg) {
 				init_sgl_element(&scu_sg->B, sg);
 				sg = sg_next(sg);
 			} else
 				memset(&scu_sg->B, 0, sizeof(scu_sg->B));
 			if (prev_sg) {
 				dma_addr = to_sgl_element_pair_dma(ihost,
 								   ireq,
 								   sg_idx);
 				prev_sg->next_pair_upper =
 					upper_32_bits(dma_addr);
 				prev_sg->next_pair_lower =
 					lower_32_bits(dma_addr);
 			}
 			prev_sg = scu_sg;
 			sg_idx++;
 		}
 	} else {	/* handle when no sg */
 		scu_sg = to_sgl_element_pair(ireq, sg_idx);
 		dma_addr = dma_map_single(&ihost->pdev->dev,
 					  task->scatter,
 					  task->total_xfer_len,
 					  task->data_dir);
 		ireq->zero_scatter_daddr = dma_addr;
 		scu_sg->A.length = task->total_xfer_len;
 		scu_sg->A.address_upper = upper_32_bits(dma_addr);
 		scu_sg->A.address_lower = lower_32_bits(dma_addr);
 	}
 	if (scu_sg) {
 		scu_sg->next_pair_upper = 0;
 		scu_sg->next_pair_lower = 0;
 	}
 }
 static void sci_io_request_build_ssp_command_iu(struct isci_request *ireq)
 {
 	struct ssp_cmd_iu *cmd_iu;
 	struct sas_task *task = isci_request_access_task(ireq);
 	cmd_iu = &ireq->ssp.cmd;
 	memcpy(cmd_iu->LUN, task->ssp_task.LUN, 8);
 	cmd_iu->add_cdb_len = 0;
 	cmd_iu->_r_a = 0;
 	cmd_iu->_r_b = 0;
 	cmd_iu->en_fburst = 0; /* unsupported */
 	cmd_iu->task_prio = task->ssp_task.task_prio;
 	cmd_iu->task_attr = task->ssp_task.task_attr;
 	cmd_iu->_r_c = 0;
 	sci_swab32_cpy(&cmd_iu->cdb, task->ssp_task.cdb,
 		       sizeof(task->ssp_task.cdb) / sizeof(u32));
 }
 static void sci_task_request_build_ssp_task_iu(struct isci_request *ireq)
 {
 	struct ssp_task_iu *task_iu;
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
 	task_iu = &ireq->ssp.tmf;
 	memset(task_iu, 0, sizeof(struct ssp_task_iu));
 	memcpy(task_iu->LUN, task->ssp_task.LUN, 8);
 	task_iu->task_func = isci_tmf->tmf_code;
 	task_iu->task_tag =
 		(test_bit(IREQ_TMF, &ireq->flags)) ?
 		isci_tmf->io_tag :
 		SCI_CONTROLLER_INVALID_IO_TAG;
 }
 /**
  * This method is will fill in the SCU Task Context for any type of SSP request.
  * @sci_req:
  * @task_context:
  *
  */
 static void scu_ssp_reqeust_construct_task_context(
 	struct isci_request *ireq,
 	struct scu_task_context *task_context)
 {
 	dma_addr_t dma_addr;
 	struct isci_remote_device *idev;
 	struct isci_port *iport;
 	idev = ireq->target_device;
 	iport = idev->owning_port;
 	/* Fill in the TC with the its required data */
 	task_context->abort = 0;
 	task_context->priority = 0;
 	task_context->initiator_request = 1;
 	task_context->connection_rate = idev->connection_rate;
 	task_context->protocol_engine_index = ISCI_PEG;
 	task_context->logical_port_index = iport->physical_port_index;
 	task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
 	task_context->valid = SCU_TASK_CONTEXT_VALID;
 	task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 	task_context->remote_node_index = idev->rnc.remote_node_index;
 	task_context->command_code = 0;
 	task_context->link_layer_control = 0;
 	task_context->do_not_dma_ssp_good_response = 1;
 	task_context->strict_ordering = 0;
 	task_context->control_frame = 0;
 	task_context->timeout_enable = 0;
 	task_context->block_guard_enable = 0;
 	task_context->address_modifier = 0;
 	/* task_context->type.ssp.tag = ireq->io_tag; */
 	task_context->task_phase = 0x01;
 	ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 			      (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 			      (iport->physical_port_index <<
 			       SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 			      ISCI_TAG_TCI(ireq->io_tag));
 	/*
 	 * Copy the physical address for the command buffer to the
 	 * SCU Task Context
 	 */
 	dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.cmd);
 	task_context->command_iu_upper = upper_32_bits(dma_addr);
 	task_context->command_iu_lower = lower_32_bits(dma_addr);
 	/*
 	 * Copy the physical address for the response buffer to the
 	 * SCU Task Context
 	 */
 	dma_addr = sci_io_request_get_dma_addr(ireq, &ireq->ssp.rsp);
 	task_context->response_iu_upper = upper_32_bits(dma_addr);
 	task_context->response_iu_lower = lower_32_bits(dma_addr);
 }
 static u8 scu_bg_blk_size(struct scsi_device *sdp)
 {
 	switch (sdp->sector_size) {
 	case 512:
 		return 0;
 	case 1024:
 		return 1;
 	case 4096:
 		return 3;
 	default:
 		return 0xff;
 	}
 }
 static u32 scu_dif_bytes(u32 len, u32 sector_size)
 {
 	return (len >> ilog2(sector_size)) * 8;
 }
 static void scu_ssp_ireq_dif_insert(struct isci_request *ireq, u8 type, u8 op)
 {
 	struct scu_task_context *tc = ireq->tc;
 	struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
 	u8 blk_sz = scu_bg_blk_size(scmd->device);
 	tc->block_guard_enable = 1;
 	tc->blk_prot_en = 1;
 	tc->blk_sz = blk_sz;
 	/* DIF write insert */
 	tc->blk_prot_func = 0x2;
 	tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
 						   scmd->device->sector_size);
 	/* always init to 0, used by hw */
 	tc->interm_crc_val = 0;
 	tc->init_crc_seed = 0;
 	tc->app_tag_verify = 0;
 	tc->app_tag_gen = 0;
 	tc->ref_tag_seed_verify = 0;
 	/* always init to same as bg_blk_sz */
 	tc->UD_bytes_immed_val = scmd->device->sector_size;
 	tc->reserved_DC_0 = 0;
 	/* always init to 8 */
 	tc->DIF_bytes_immed_val = 8;
 	tc->reserved_DC_1 = 0;
 	tc->bgc_blk_sz = scmd->device->sector_size;
 	tc->reserved_E0_0 = 0;
 	tc->app_tag_gen_mask = 0;
 	/** setup block guard control **/
 	tc->bgctl = 0;
 	/* DIF write insert */
 	tc->bgctl_f.op = 0x2;
 	tc->app_tag_verify_mask = 0;
 	/* must init to 0 for hw */
 	tc->blk_guard_err = 0;
 	tc->reserved_E8_0 = 0;
 	if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
 		tc->ref_tag_seed_gen = scsi_get_lba(scmd) & 0xffffffff;
 	else if (type & SCSI_PROT_DIF_TYPE3)
 		tc->ref_tag_seed_gen = 0;
 }
 static void scu_ssp_ireq_dif_strip(struct isci_request *ireq, u8 type, u8 op)
 {
 	struct scu_task_context *tc = ireq->tc;
 	struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
 	u8 blk_sz = scu_bg_blk_size(scmd->device);
 	tc->block_guard_enable = 1;
 	tc->blk_prot_en = 1;
 	tc->blk_sz = blk_sz;
 	/* DIF read strip */
 	tc->blk_prot_func = 0x1;
 	tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
 						   scmd->device->sector_size);
 	/* always init to 0, used by hw */
 	tc->interm_crc_val = 0;
 	tc->init_crc_seed = 0;
 	tc->app_tag_verify = 0;
 	tc->app_tag_gen = 0;
 	if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
 		tc->ref_tag_seed_verify = scsi_get_lba(scmd) & 0xffffffff;
 	else if (type & SCSI_PROT_DIF_TYPE3)
 		tc->ref_tag_seed_verify = 0;
 	/* always init to same as bg_blk_sz */
 	tc->UD_bytes_immed_val = scmd->device->sector_size;
 	tc->reserved_DC_0 = 0;
 	/* always init to 8 */
 	tc->DIF_bytes_immed_val = 8;
 	tc->reserved_DC_1 = 0;
 	tc->bgc_blk_sz = scmd->device->sector_size;
 	tc->reserved_E0_0 = 0;
 	tc->app_tag_gen_mask = 0;
 	/** setup block guard control **/
 	tc->bgctl = 0;
 	/* DIF read strip */
 	tc->bgctl_f.crc_verify = 1;
 	tc->bgctl_f.op = 0x1;
 	if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2)) {
 		tc->bgctl_f.ref_tag_chk = 1;
 		tc->bgctl_f.app_f_detect = 1;
 	} else if (type & SCSI_PROT_DIF_TYPE3)
 		tc->bgctl_f.app_ref_f_detect = 1;
 	tc->app_tag_verify_mask = 0;
 	/* must init to 0 for hw */
 	tc->blk_guard_err = 0;
 	tc->reserved_E8_0 = 0;
 	tc->ref_tag_seed_gen = 0;
 }
 /**
  * This method is will fill in the SCU Task Context for a SSP IO request.
  * @sci_req:
  *
  */
 static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
 						      enum dma_data_direction dir,
 						      u32 len)
 {
 	struct scu_task_context *task_context = ireq->tc;
 	struct sas_task *sas_task = ireq->ttype_ptr.io_task_ptr;
 	struct scsi_cmnd *scmd = sas_task->uldd_task;
 	u8 prot_type = scsi_get_prot_type(scmd);
 	u8 prot_op = scsi_get_prot_op(scmd);
 	scu_ssp_reqeust_construct_task_context(ireq, task_context);
 	task_context->ssp_command_iu_length =
 		sizeof(struct ssp_cmd_iu) / sizeof(u32);
 	task_context->type.ssp.frame_type = SSP_COMMAND;
 	switch (dir) {
 	case DMA_FROM_DEVICE:
 	case DMA_NONE:
 	default:
 		task_context->task_type = SCU_TASK_TYPE_IOREAD;
 		break;
 	case DMA_TO_DEVICE:
 		task_context->task_type = SCU_TASK_TYPE_IOWRITE;
 		break;
 	}
 	task_context->transfer_length_bytes = len;
 	if (task_context->transfer_length_bytes > 0)
 		sci_request_build_sgl(ireq);
 	if (prot_type != SCSI_PROT_DIF_TYPE0) {
 		if (prot_op == SCSI_PROT_READ_STRIP)
 			scu_ssp_ireq_dif_strip(ireq, prot_type, prot_op);
 		else if (prot_op == SCSI_PROT_WRITE_INSERT)
 			scu_ssp_ireq_dif_insert(ireq, prot_type, prot_op);
 	}
 }
 /**
  * This method will fill in the SCU Task Context for a SSP Task request.  The
  *    following important settings are utilized: -# priority ==
  *    SCU_TASK_PRIORITY_HIGH.  This ensures that the task request is issued
  *    ahead of other task destined for the same Remote Node. -# task_type ==
  *    SCU_TASK_TYPE_IOREAD.  This simply indicates that a normal request type
  *    (i.e. non-raw frame) is being utilized to perform task management. -#
  *    control_frame == 1.  This ensures that the proper endianess is set so
  *    that the bytes are transmitted in the right order for a task frame.
  * @sci_req: This parameter specifies the task request object being
  *    constructed.
  *
  */
 static void scu_ssp_task_request_construct_task_context(struct isci_request *ireq)
 {
 	struct scu_task_context *task_context = ireq->tc;
 	scu_ssp_reqeust_construct_task_context(ireq, task_context);
 	task_context->control_frame                = 1;
 	task_context->priority                     = SCU_TASK_PRIORITY_HIGH;
 	task_context->task_type                    = SCU_TASK_TYPE_RAW_FRAME;
 	task_context->transfer_length_bytes        = 0;
 	task_context->type.ssp.frame_type          = SSP_TASK;
 	task_context->ssp_command_iu_length =
 		sizeof(struct ssp_task_iu) / sizeof(u32);
 }
 /**
  * This method is will fill in the SCU Task Context for any type of SATA
  *    request.  This is called from the various SATA constructors.
  * @sci_req: The general IO request object which is to be used in
  *    constructing the SCU task context.
  * @task_context: The buffer pointer for the SCU task context which is being
  *    constructed.
  *
  * The general io request construction is complete. The buffer assignment for
  * the command buffer is complete. none Revisit task context construction to
  * determine what is common for SSP/SMP/STP task context structures.
  */
 static void scu_sata_reqeust_construct_task_context(
 	struct isci_request *ireq,
 	struct scu_task_context *task_context)
 {
 	dma_addr_t dma_addr;
 	struct isci_remote_device *idev;
 	struct isci_port *iport;
 	idev = ireq->target_device;
 	iport = idev->owning_port;
 	/* Fill in the TC with the its required data */
 	task_context->abort = 0;
 	task_context->priority = SCU_TASK_PRIORITY_NORMAL;
 	task_context->initiator_request = 1;
 	task_context->connection_rate = idev->connection_rate;
 	task_context->protocol_engine_index = ISCI_PEG;
 	task_context->logical_port_index = iport->physical_port_index;
 	task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_STP;
 	task_context->valid = SCU_TASK_CONTEXT_VALID;
 	task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 	task_context->remote_node_index = idev->rnc.remote_node_index;
 	task_context->command_code = 0;
 	task_context->link_layer_control = 0;
 	task_context->do_not_dma_ssp_good_response = 1;
 	task_context->strict_ordering = 0;
 	task_context->control_frame = 0;
 	task_context->timeout_enable = 0;
 	task_context->block_guard_enable = 0;
 	task_context->address_modifier = 0;
 	task_context->task_phase = 0x01;
 	task_context->ssp_command_iu_length =
 		(sizeof(struct host_to_dev_fis) - sizeof(u32)) / sizeof(u32);
 	/* Set the first word of the H2D REG FIS */
 	task_context->type.words[0] = *(u32 *)&ireq->stp.cmd;
 	ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 			      (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 			      (iport->physical_port_index <<
 			       SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 			      ISCI_TAG_TCI(ireq->io_tag));
 	/*
 	 * Copy the physical address for the command buffer to the SCU Task
 	 * Context. We must offset the command buffer by 4 bytes because the
 	 * first 4 bytes are transfered in the body of the TC.
 	 */
 	dma_addr = sci_io_request_get_dma_addr(ireq,
 						((char *) &ireq->stp.cmd) +
 						sizeof(u32));
 	task_context->command_iu_upper = upper_32_bits(dma_addr);
 	task_context->command_iu_lower = lower_32_bits(dma_addr);
 	/* SATA Requests do not have a response buffer */
 	task_context->response_iu_upper = 0;
 	task_context->response_iu_lower = 0;
 }
 static void scu_stp_raw_request_construct_task_context(struct isci_request *ireq)
 {
 	struct scu_task_context *task_context = ireq->tc;
 	scu_sata_reqeust_construct_task_context(ireq, task_context);
 	task_context->control_frame         = 0;
 	task_context->priority              = SCU_TASK_PRIORITY_NORMAL;
 	task_context->task_type             = SCU_TASK_TYPE_SATA_RAW_FRAME;
 	task_context->type.stp.fis_type     = FIS_REGH2D;
 	task_context->transfer_length_bytes = sizeof(struct host_to_dev_fis) - sizeof(u32);
 }
 static enum sci_status sci_stp_pio_request_construct(struct isci_request *ireq,
 							  bool copy_rx_frame)
 {
 	struct isci_stp_request *stp_req = &ireq->stp.req;
 	scu_stp_raw_request_construct_task_context(ireq);
 	stp_req->status = 0;
 	stp_req->sgl.offset = 0;
 	stp_req->sgl.set = SCU_SGL_ELEMENT_PAIR_A;
 	if (copy_rx_frame) {
 		sci_request_build_sgl(ireq);
 		stp_req->sgl.index = 0;
 	} else {
 		/* The user does not want the data copied to the SGL buffer location */
 		stp_req->sgl.index = -1;
 	}
 	return SCI_SUCCESS;
 }
 /**
  *
  * @sci_req: This parameter specifies the request to be constructed as an
  *    optimized request.
  * @optimized_task_type: This parameter specifies whether the request is to be
  *    an UDMA request or a NCQ request. - A value of 0 indicates UDMA. - A
  *    value of 1 indicates NCQ.
  *
  * This method will perform request construction common to all types of STP
  * requests that are optimized by the silicon (i.e. UDMA, NCQ). This method
  * returns an indication as to whether the construction was successful.
  */
 static void sci_stp_optimized_request_construct(struct isci_request *ireq,
 						     u8 optimized_task_type,
 						     u32 len,
 						     enum dma_data_direction dir)
 {
 	struct scu_task_context *task_context = ireq->tc;
 	/* Build the STP task context structure */
 	scu_sata_reqeust_construct_task_context(ireq, task_context);
 	/* Copy over the SGL elements */
 	sci_request_build_sgl(ireq);
 	/* Copy over the number of bytes to be transfered */
 	task_context->transfer_length_bytes = len;
 	if (dir == DMA_TO_DEVICE) {
 		/*
 		 * The difference between the DMA IN and DMA OUT request task type
 		 * values are consistent with the difference between FPDMA READ
 		 * and FPDMA WRITE values.  Add the supplied task type parameter
 		 * to this difference to set the task type properly for this
 		 * DATA OUT (WRITE) case. */
 		task_context->task_type = optimized_task_type + (SCU_TASK_TYPE_DMA_OUT
 								 - SCU_TASK_TYPE_DMA_IN);
 	} else {
 		/*
 		 * For the DATA IN (READ) case, simply save the supplied
 		 * optimized task type. */
 		task_context->task_type = optimized_task_type;
 	}
 }
 static void sci_atapi_construct(struct isci_request *ireq)
 {
 	struct host_to_dev_fis *h2d_fis = &ireq->stp.cmd;
 	struct sas_task *task;
 	/* To simplify the implementation we take advantage of the
 	 * silicon's partial acceleration of atapi protocol (dma data
 	 * transfers), so we promote all commands to dma protocol.  This
 	 * breaks compatibility with ATA_HORKAGE_ATAPI_MOD16_DMA drives.
 	 */
 	h2d_fis->features |= ATAPI_PKT_DMA;
 	scu_stp_raw_request_construct_task_context(ireq);
 	task = isci_request_access_task(ireq);
 	if (task->data_dir == DMA_NONE)
 		task->total_xfer_len = 0;
 	/* clear the response so we can detect arrivial of an
 	 * unsolicited h2d fis
 	 */
 	ireq->stp.rsp.fis_type = 0;
 }
 static enum sci_status
 sci_io_request_construct_sata(struct isci_request *ireq,
 			       u32 len,
 			       enum dma_data_direction dir,
 			       bool copy)
 {
 	enum sci_status status = SCI_SUCCESS;
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct domain_device *dev = ireq->target_device->domain_dev;
 	/* check for management protocols */
 	if (test_bit(IREQ_TMF, &ireq->flags)) {
 		struct isci_tmf *tmf = isci_request_access_tmf(ireq);
 		dev_err(&ireq->owning_controller->pdev->dev,
 			"%s: Request 0x%p received un-handled SAT "
 			"management protocol 0x%x.\n",
 			__func__, ireq, tmf->tmf_code);
 		return SCI_FAILURE;
 	}
 	if (!sas_protocol_ata(task->task_proto)) {
 		dev_err(&ireq->owning_controller->pdev->dev,
 			"%s: Non-ATA protocol in SATA path: 0x%x\n",
 			__func__,
 			task->task_proto);
 		return SCI_FAILURE;
 	}
 	/* ATAPI */
 	if (dev->sata_dev.command_set == ATAPI_COMMAND_SET &&
 	    task->ata_task.fis.command == ATA_CMD_PACKET) {
 		sci_atapi_construct(ireq);
 		return SCI_SUCCESS;
 	}
 	/* non data */
 	if (task->data_dir == DMA_NONE) {
 		scu_stp_raw_request_construct_task_context(ireq);
 		return SCI_SUCCESS;
 	}
 	/* NCQ */
 	if (task->ata_task.use_ncq) {
 		sci_stp_optimized_request_construct(ireq,
 							 SCU_TASK_TYPE_FPDMAQ_READ,
 							 len, dir);
 		return SCI_SUCCESS;
 	}
 	/* DMA */
 	if (task->ata_task.dma_xfer) {
 		sci_stp_optimized_request_construct(ireq,
 							 SCU_TASK_TYPE_DMA_IN,
 							 len, dir);
 		return SCI_SUCCESS;
 	} else /* PIO */
 		return sci_stp_pio_request_construct(ireq, copy);
 	return status;
 }
 static enum sci_status sci_io_request_construct_basic_ssp(struct isci_request *ireq)
 {
 	struct sas_task *task = isci_request_access_task(ireq);
 	ireq->protocol = SAS_PROTOCOL_SSP;
 	scu_ssp_io_request_construct_task_context(ireq,
 						  task->data_dir,
 						  task->total_xfer_len);
 	sci_io_request_build_ssp_command_iu(ireq);
 	sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 	return SCI_SUCCESS;
 }
 enum sci_status sci_task_request_construct_ssp(
 	struct isci_request *ireq)
 {
 	/* Construct the SSP Task SCU Task Context */
 	scu_ssp_task_request_construct_task_context(ireq);
 	/* Fill in the SSP Task IU */
 	sci_task_request_build_ssp_task_iu(ireq);
 	sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 	return SCI_SUCCESS;
 }
 static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *ireq)
 {
 	enum sci_status status;
 	bool copy = false;
 	struct sas_task *task = isci_request_access_task(ireq);
 	ireq->protocol = SAS_PROTOCOL_STP;
 	copy = (task->data_dir == DMA_NONE) ? false : true;
 	status = sci_io_request_construct_sata(ireq,
 						task->total_xfer_len,
 						task->data_dir,
 						copy);
 	if (status == SCI_SUCCESS)
 		sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 	return status;
 }
 /**
  * sci_req_tx_bytes - bytes transferred when reply underruns request
  * @ireq: request that was terminated early
  */
 #define SCU_TASK_CONTEXT_SRAM 0x200000
 static u32 sci_req_tx_bytes(struct isci_request *ireq)
 {
 	struct isci_host *ihost = ireq->owning_controller;
 	u32 ret_val = 0;
 	if (readl(&ihost->smu_registers->address_modifier) == 0) {
 		void __iomem *scu_reg_base = ihost->scu_registers;
 		/* get the bytes of data from the Address == BAR1 + 20002Ch + (256*TCi) where
 		 *   BAR1 is the scu_registers
 		 *   0x20002C = 0x200000 + 0x2c
 		 *            = start of task context SRAM + offset of (type.ssp.data_offset)
 		 *   TCi is the io_tag of struct sci_request
 		 */
 		ret_val = readl(scu_reg_base +
 				(SCU_TASK_CONTEXT_SRAM + offsetof(struct scu_task_context, type.ssp.data_offset)) +
 				((sizeof(struct scu_task_context)) * ISCI_TAG_TCI(ireq->io_tag)));
 	}
 	return ret_val;
 }
 enum sci_status sci_request_start(struct isci_request *ireq)
 {
 	enum sci_base_request_states state;
 	struct scu_task_context *tc = ireq->tc;
 	struct isci_host *ihost = ireq->owning_controller;
 	state = ireq->sm.current_state_id;
 	if (state != SCI_REQ_CONSTRUCTED) {
 		dev_warn(&ihost->pdev->dev,
 			"%s: SCIC IO Request requested to start while in wrong "
 			 "state %d\n", __func__, state);
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	tc->task_index = ISCI_TAG_TCI(ireq->io_tag);
 	switch (tc->protocol_type) {
 	case SCU_TASK_CONTEXT_PROTOCOL_SMP:
 	case SCU_TASK_CONTEXT_PROTOCOL_SSP:
 		/* SSP/SMP Frame */
 		tc->type.ssp.tag = ireq->io_tag;
 		tc->type.ssp.target_port_transfer_tag = 0xFFFF;
 		break;
 	case SCU_TASK_CONTEXT_PROTOCOL_STP:
 		/* STP/SATA Frame
 		 * tc->type.stp.ncq_tag = ireq->ncq_tag;
 		 */
 		break;
 	case SCU_TASK_CONTEXT_PROTOCOL_NONE:
 		/* / @todo When do we set no protocol type? */
 		break;
 	default:
 		/* This should never happen since we build the IO
 		 * requests */
 		break;
 	}
 	/* Add to the post_context the io tag value */
 	ireq->post_context |= ISCI_TAG_TCI(ireq->io_tag);
 	/* Everything is good go ahead and change state */
 	sci_change_state(&ireq->sm, SCI_REQ_STARTED);
 	return SCI_SUCCESS;
 }
 enum sci_status
 sci_io_request_terminate(struct isci_request *ireq)
 {
 	enum sci_base_request_states state;
 	state = ireq->sm.current_state_id;
 	switch (state) {
 	case SCI_REQ_CONSTRUCTED:
+		/* Set to make sure no HW terminate posting is done: */
+		set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
 		ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
 		ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		return SCI_SUCCESS;
 	case SCI_REQ_STARTED:
 	case SCI_REQ_TASK_WAIT_TC_COMP:
 	case SCI_REQ_SMP_WAIT_RESP:
 	case SCI_REQ_SMP_WAIT_TC_COMP:
 	case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
 	case SCI_REQ_STP_UDMA_WAIT_D2H:
 	case SCI_REQ_STP_NON_DATA_WAIT_H2D:
 	case SCI_REQ_STP_NON_DATA_WAIT_D2H:
 	case SCI_REQ_STP_PIO_WAIT_H2D:
 	case SCI_REQ_STP_PIO_WAIT_FRAME:
 	case SCI_REQ_STP_PIO_DATA_IN:
 	case SCI_REQ_STP_PIO_DATA_OUT:
 	case SCI_REQ_ATAPI_WAIT_H2D:
 	case SCI_REQ_ATAPI_WAIT_PIO_SETUP:
 	case SCI_REQ_ATAPI_WAIT_D2H:
 	case SCI_REQ_ATAPI_WAIT_TC_COMP:
-		sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
+		/* Fall through and change state to ABORTING... */
-		return SCI_SUCCESS;
 	case SCI_REQ_TASK_WAIT_TC_RESP:
 		/* The task frame was already confirmed to have been
 		 * sent by the SCU HW.  Since the state machine is
 		 * now only waiting for the task response itself,
 		 * abort the request and complete it immediately
 		 * and don't wait for the task response.
 		 */
 		sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
-		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
+		/* Fall through and handle like ABORTING... */
-		return SCI_SUCCESS;
 	case SCI_REQ_ABORTING:
-		/* If a request has a termination requested twice, return
+		if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
-		 * a failure indication, since HW confirmation of the first
+			set_bit(IREQ_PENDING_ABORT, &ireq->flags);
-		 * abort is still outstanding.
+		else
+			clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
+		/* If the request is only waiting on the remote device
+		 * suspension, return SUCCESS so the caller will wait too.
 		 */
+		return SCI_SUCCESS;
 	case SCI_REQ_COMPLETED:
 	default:
 		dev_warn(&ireq->owning_controller->pdev->dev,
 			 "%s: SCIC IO Request requested to abort while in wrong "
-			 "state %d\n",
+			 "state %d\n", __func__, ireq->sm.current_state_id);
-			 __func__,
-			 ireq->sm.current_state_id);
 		break;
 	}
 	return SCI_FAILURE_INVALID_STATE;
 }
 enum sci_status sci_request_complete(struct isci_request *ireq)
 {
 	enum sci_base_request_states state;
 	struct isci_host *ihost = ireq->owning_controller;
 	state = ireq->sm.current_state_id;
 	if (WARN_ONCE(state != SCI_REQ_COMPLETED,
 		      "isci: request completion from wrong state (%s)\n",
 		      req_state_name(state)))
 		return SCI_FAILURE_INVALID_STATE;
 	if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
 		sci_controller_release_frame(ihost,
 						  ireq->saved_rx_frame_index);
 	/* XXX can we just stop the machine and remove the 'final' state? */
 	sci_change_state(&ireq->sm, SCI_REQ_FINAL);
 	return SCI_SUCCESS;
 }
 enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
 						  u32 event_code)
 {
 	enum sci_base_request_states state;
 	struct isci_host *ihost = ireq->owning_controller;
 	state = ireq->sm.current_state_id;
 	if (state != SCI_REQ_STP_PIO_DATA_IN) {
 		dev_warn(&ihost->pdev->dev, "%s: (%x) in wrong state %s\n",
 			 __func__, event_code, req_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 	switch (scu_get_event_specifier(event_code)) {
 	case SCU_TASK_DONE_CRC_ERR << SCU_EVENT_SPECIFIC_CODE_SHIFT:
 		/* We are waiting for data and the SCU has R_ERR the data frame.
 		 * Go back to waiting for the D2H Register FIS
 		 */
 		sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 		return SCI_SUCCESS;
 	default:
 		dev_err(&ihost->pdev->dev,
 			"%s: pio request unexpected event %#x\n",
 			__func__, event_code);
 		/* TODO Should we fail the PIO request when we get an
 		 * unexpected event?
 		 */
 		return SCI_FAILURE;
 	}
 }
 /*
  * This function copies response data for requests returning response data
  *    instead of sense data.
  * @sci_req: This parameter specifies the request object for which to copy
  *    the response data.
  */
 static void sci_io_request_copy_response(struct isci_request *ireq)
 {
 	void *resp_buf;
 	u32 len;
 	struct ssp_response_iu *ssp_response;
 	struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
 	ssp_response = &ireq->ssp.rsp;
 	resp_buf = &isci_tmf->resp.resp_iu;
 	len = min_t(u32,
 		    SSP_RESP_IU_MAX_SIZE,
 		    be32_to_cpu(ssp_response->response_data_len));
 	memcpy(resp_buf, ssp_response->resp_data, len);
 }
 static enum sci_status
 request_started_state_tc_event(struct isci_request *ireq,
 			       u32 completion_code)
 {
 	struct ssp_response_iu *resp_iu;
 	u8 datapres;
 	/* TODO: Any SDMA return code of other than 0 is bad decode 0x003C0000
 	 * to determine SDMA status
 	 */
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		break;
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EARLY_RESP): {
 		/* There are times when the SCU hardware will return an early
 		 * response because the io request specified more data than is
 		 * returned by the target device (mode pages, inquiry data,
 		 * etc.).  We must check the response stats to see if this is
 		 * truly a failed request or a good request that just got
 		 * completed early.
 		 */
 		struct ssp_response_iu *resp = &ireq->ssp.rsp;
 		ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
 		sci_swab32_cpy(&ireq->ssp.rsp,
 			       &ireq->ssp.rsp,
 			       word_cnt);
 		if (resp->status == 0) {
 			ireq->scu_status = SCU_TASK_DONE_GOOD;
 			ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
 		} else {
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 		}
 		break;
 	}
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE): {
 		ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
 		sci_swab32_cpy(&ireq->ssp.rsp,
 			       &ireq->ssp.rsp,
 			       word_cnt);
 		ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 		ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 		break;
 	}
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RESP_LEN_ERR):
 		/* TODO With TASK_DONE_RESP_LEN_ERR is the response frame
 		 * guaranteed to be received before this completion status is
 		 * posted?
 		 */
 		resp_iu = &ireq->ssp.rsp;
 		datapres = resp_iu->datapres;
 		if (datapres == 1 || datapres == 2) {
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 		} else {
 			ireq->scu_status = SCU_TASK_DONE_GOOD;
 			ireq->sci_status = SCI_SUCCESS;
 		}
 		break;
 	/* only stp device gets suspended. */
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_PERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_DATA_LEN_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_ABORT_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_WD_LEN):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_RESP):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
 		if (ireq->protocol == SAS_PROTOCOL_STP) {
 			ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
 					   SCU_COMPLETION_TL_STATUS_SHIFT;
 			ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
 		} else {
 			ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
 					   SCU_COMPLETION_TL_STATUS_SHIFT;
 			ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		}
 		break;
 	/* both stp/ssp device gets suspended */
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LF_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_WRONG_DESTINATION):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_BAD_DESTINATION):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_ZONE_VIOLATION):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED):
 		ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
 				   SCU_COMPLETION_TL_STATUS_SHIFT;
 		ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
 		break;
 	/* neither ssp nor stp gets suspended. */
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_CMD_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_XR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_IU_LEN_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDMA_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OFFSET_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EXCESS_DATA):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_DATA):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OPEN_FAIL):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_VIIT_ENTRY_NV):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_IIT_ENTRY_NV):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND):
 	default:
 		ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
 				   SCU_COMPLETION_TL_STATUS_SHIFT;
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		break;
 	}
 	/*
 	 * TODO: This is probably wrong for ACK/NAK timeout conditions
 	 */
 	/* In all cases we will treat this as the completion of the IO req. */
 	sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 	return SCI_SUCCESS;
 }
 static enum sci_status
 request_aborting_state_tc_event(struct isci_request *ireq,
 				u32 completion_code)
 {
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
 	case (SCU_TASK_DONE_TASK_ABORT << SCU_COMPLETION_TL_STATUS_SHIFT):
 		ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
 		ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	default:
 		/* Unless we get some strange error wait for the task abort to complete
 		 * TODO: Should there be a state change for this completion?
 		 */
 		break;
 	}
 	return SCI_SUCCESS;
 }
 static enum sci_status ssp_task_request_await_tc_event(struct isci_request *ireq,
 						       u32 completion_code)
 {
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
 		break;
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
 		/* Currently, the decision is to simply allow the task request
 		 * to timeout if the task IU wasn't received successfully.
 		 * There is a potential for receiving multiple task responses if
 		 * we decide to send the task IU again.
 		 */
 		dev_warn(&ireq->owning_controller->pdev->dev,
 			 "%s: TaskRequest:0x%p CompletionCode:%x - "
 			 "ACK/NAK timeout\n", __func__, ireq,
 			 completion_code);
 		sci_change_state(&ireq->sm, SCI_REQ_TASK_WAIT_TC_RESP);
 		break;
 	default:
 		/*
 		 * All other completion status cause the IO to be complete.
 		 * If a NAK was received, then it is up to the user to retry
 		 * the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return SCI_SUCCESS;
 }
 static enum sci_status
 smp_request_await_response_tc_event(struct isci_request *ireq,
 				    u32 completion_code)
 {
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		/* In the AWAIT RESPONSE state, any TC completion is
 		 * unexpected.  but if the TC has success status, we
 		 * complete the IO anyway.
 		 */
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
 		/* These status has been seen in a specific LSI
 		 * expander, which sometimes is not able to send smp
 		 * response within 2 ms. This causes our hardware break
 		 * the connection and set TC completion with one of
 		 * these SMP_XXX_XX_ERR status. For these type of error,
 		 * we ask ihost user to retry the request.
 		 */
 		ireq->scu_status = SCU_TASK_DONE_SMP_RESP_TO_ERR;
 		ireq->sci_status = SCI_FAILURE_RETRY_REQUIRED;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	default:
 		/* All other completion status cause the IO to be complete.  If a NAK
 		 * was received, then it is up to the user to retry the request
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return SCI_SUCCESS;
 }
 static enum sci_status
 smp_request_await_tc_event(struct isci_request *ireq,
 			   u32 completion_code)
 {
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	default:
 		/* All other completion status cause the IO to be
 		 * complete.  If a NAK was received, then it is up to
 		 * the user to retry the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return SCI_SUCCESS;
 }
 static struct scu_sgl_element *pio_sgl_next(struct isci_stp_request *stp_req)
 {
 	struct scu_sgl_element *sgl;
 	struct scu_sgl_element_pair *sgl_pair;
 	struct isci_request *ireq = to_ireq(stp_req);
 	struct isci_stp_pio_sgl *pio_sgl = &stp_req->sgl;
 	sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
 	if (!sgl_pair)
 		sgl = NULL;
 	else if (pio_sgl->set == SCU_SGL_ELEMENT_PAIR_A) {
 		if (sgl_pair->B.address_lower == 0 &&
 		    sgl_pair->B.address_upper == 0) {
 			sgl = NULL;
 		} else {
 			pio_sgl->set = SCU_SGL_ELEMENT_PAIR_B;
 			sgl = &sgl_pair->B;
 		}
 	} else {
 		if (sgl_pair->next_pair_lower == 0 &&
 		    sgl_pair->next_pair_upper == 0) {
 			sgl = NULL;
 		} else {
 			pio_sgl->index++;
 			pio_sgl->set = SCU_SGL_ELEMENT_PAIR_A;
 			sgl_pair = to_sgl_element_pair(ireq, pio_sgl->index);
 			sgl = &sgl_pair->A;
 		}
 	}
 	return sgl;
 }
 static enum sci_status
 stp_request_non_data_await_h2d_tc_event(struct isci_request *ireq,
 					u32 completion_code)
 {
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
 		break;
 	default:
 		/* All other completion status cause the IO to be
 		 * complete.  If a NAK was received, then it is up to
 		 * the user to retry the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return SCI_SUCCESS;
 }
 #define SCU_MAX_FRAME_BUFFER_SIZE  0x400  /* 1K is the maximum SCU frame data payload */
 /* transmit DATA_FIS from (current sgl + offset) for input
  * parameter length. current sgl and offset is alreay stored in the IO request
  */
 static enum sci_status sci_stp_request_pio_data_out_trasmit_data_frame(
 	struct isci_request *ireq,
 	u32 length)
 {
 	struct isci_stp_request *stp_req = &ireq->stp.req;
 	struct scu_task_context *task_context = ireq->tc;
 	struct scu_sgl_element_pair *sgl_pair;
 	struct scu_sgl_element *current_sgl;
 	/* Recycle the TC and reconstruct it for sending out DATA FIS containing
 	 * for the data from current_sgl+offset for the input length
 	 */
 	sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
 	if (stp_req->sgl.set == SCU_SGL_ELEMENT_PAIR_A)
 		current_sgl = &sgl_pair->A;
 	else
 		current_sgl = &sgl_pair->B;
 	/* update the TC */
 	task_context->command_iu_upper = current_sgl->address_upper;
 	task_context->command_iu_lower = current_sgl->address_lower;
 	task_context->transfer_length_bytes = length;
 	task_context->type.stp.fis_type = FIS_DATA;
 	/* send the new TC out. */
 	return sci_controller_continue_io(ireq);
 }
 static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_request *ireq)
 {
 	struct isci_stp_request *stp_req = &ireq->stp.req;
 	struct scu_sgl_element_pair *sgl_pair;
 	enum sci_status status = SCI_SUCCESS;
 	struct scu_sgl_element *sgl;
 	u32 offset;
 	u32 len = 0;
 	offset = stp_req->sgl.offset;
 	sgl_pair = to_sgl_element_pair(ireq, stp_req->sgl.index);
 	if (WARN_ONCE(!sgl_pair, "%s: null sgl element", __func__))
 		return SCI_FAILURE;
 	if (stp_req->sgl.set == SCU_SGL_ELEMENT_PAIR_A) {
 		sgl = &sgl_pair->A;
 		len = sgl_pair->A.length - offset;
 	} else {
 		sgl = &sgl_pair->B;
 		len = sgl_pair->B.length - offset;
 	}
 	if (stp_req->pio_len == 0)
 		return SCI_SUCCESS;
 	if (stp_req->pio_len >= len) {
 		status = sci_stp_request_pio_data_out_trasmit_data_frame(ireq, len);
 		if (status != SCI_SUCCESS)
 			return status;
 		stp_req->pio_len -= len;
 		/* update the current sgl, offset and save for future */
 		sgl = pio_sgl_next(stp_req);
 		offset = 0;
 	} else if (stp_req->pio_len < len) {
 		sci_stp_request_pio_data_out_trasmit_data_frame(ireq, stp_req->pio_len);
 		/* Sgl offset will be adjusted and saved for future */
 		offset += stp_req->pio_len;
 		sgl->address_lower += stp_req->pio_len;
 		stp_req->pio_len = 0;
 	}
 	stp_req->sgl.offset = offset;
 	return status;
 }
 /**
  *
  * @stp_request: The request that is used for the SGL processing.
  * @data_buffer: The buffer of data to be copied.
  * @length: The length of the data transfer.
  *
  * Copy the data from the buffer for the length specified to the IO reqeust SGL
  * specified data region. enum sci_status
  */
 static enum sci_status
 sci_stp_request_pio_data_in_copy_data_buffer(struct isci_stp_request *stp_req,
 					     u8 *data_buf, u32 len)
 {
 	struct isci_request *ireq;
 	u8 *src_addr;
 	int copy_len;
 	struct sas_task *task;
 	struct scatterlist *sg;
 	void *kaddr;
 	int total_len = len;
 	ireq = to_ireq(stp_req);
 	task = isci_request_access_task(ireq);
 	src_addr = data_buf;
 	if (task->num_scatter > 0) {
 		sg = task->scatter;
 		while (total_len > 0) {
 			struct page *page = sg_page(sg);
 			copy_len = min_t(int, total_len, sg_dma_len(sg));
 			kaddr = kmap_atomic(page);
 			memcpy(kaddr + sg->offset, src_addr, copy_len);
 			kunmap_atomic(kaddr);
 			total_len -= copy_len;
 			src_addr += copy_len;
 			sg = sg_next(sg);
 		}
 	} else {
 		BUG_ON(task->total_xfer_len < total_len);
 		memcpy(task->scatter, src_addr, total_len);
 	}
 	return SCI_SUCCESS;
 }
 /**
  *
  * @sci_req: The PIO DATA IN request that is to receive the data.
  * @data_buffer: The buffer to copy from.
  *
  * Copy the data buffer to the io request data region. enum sci_status
  */
 static enum sci_status sci_stp_request_pio_data_in_copy_data(
 	struct isci_stp_request *stp_req,
 	u8 *data_buffer)
 {
 	enum sci_status status;
 	/*
 	 * If there is less than 1K remaining in the transfer request
 	 * copy just the data for the transfer */
 	if (stp_req->pio_len < SCU_MAX_FRAME_BUFFER_SIZE) {
 		status = sci_stp_request_pio_data_in_copy_data_buffer(
 			stp_req, data_buffer, stp_req->pio_len);
 		if (status == SCI_SUCCESS)
 			stp_req->pio_len = 0;
 	} else {
 		/* We are transfering the whole frame so copy */
 		status = sci_stp_request_pio_data_in_copy_data_buffer(
 			stp_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
 		if (status == SCI_SUCCESS)
 			stp_req->pio_len -= SCU_MAX_FRAME_BUFFER_SIZE;
 	}
 	return status;
 }
 static enum sci_status
 stp_request_pio_await_h2d_completion_tc_event(struct isci_request *ireq,
 					      u32 completion_code)
 {
 	enum sci_status status = SCI_SUCCESS;
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 		break;
 	default:
 		/* All other completion status cause the IO to be
 		 * complete.  If a NAK was received, then it is up to
 		 * the user to retry the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return status;
 }
 static enum sci_status
 pio_data_out_tx_done_tc_event(struct isci_request *ireq,
 			      u32 completion_code)
 {
 	enum sci_status status = SCI_SUCCESS;
 	bool all_frames_transferred = false;
 	struct isci_stp_request *stp_req = &ireq->stp.req;
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		/* Transmit data */
 		if (stp_req->pio_len != 0) {
 			status = sci_stp_request_pio_data_out_transmit_data(ireq);
 			if (status == SCI_SUCCESS) {
 				if (stp_req->pio_len == 0)
 					all_frames_transferred = true;
 			}
 		} else if (stp_req->pio_len == 0) {
 			/*
 			 * this will happen if the all data is written at the
 			 * first time after the pio setup fis is received
 			 */
 			all_frames_transferred  = true;
 		}
 		/* all data transferred. */
 		if (all_frames_transferred) {
 			/*
 			 * Change the state to SCI_REQ_STP_PIO_DATA_IN
 			 * and wait for PIO_SETUP fis / or D2H REg fis. */
 			sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 		}
 		break;
 	default:
 		/*
 		 * All other completion status cause the IO to be complete.
 		 * If a NAK was received, then it is up to the user to retry
 		 * the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return status;
 }
 static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_request *ireq,
 								       u32 frame_index)
 {
 	struct isci_host *ihost = ireq->owning_controller;
 	struct dev_to_host_fis *frame_header;
 	enum sci_status status;
 	u32 *frame_buffer;
 	status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 							       frame_index,
 							       (void **)&frame_header);
 	if ((status == SCI_SUCCESS) &&
 	    (frame_header->fis_type == FIS_REGD2H)) {
 		sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 							      frame_index,
 							      (void **)&frame_buffer);
 		sci_controller_copy_sata_response(&ireq->stp.rsp,
 						       frame_header,
 						       frame_buffer);
 	}
 	sci_controller_release_frame(ihost, frame_index);
 	return status;
 }
 static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
 					       u32 frame_index)
 {
 	struct isci_host *ihost = ireq->owning_controller;
 	enum sci_status status;
 	struct dev_to_host_fis *frame_header;
 	u32 *frame_buffer;
 	status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 							  frame_index,
 							  (void **)&frame_header);
 	if (status != SCI_SUCCESS)
 		return status;
 	if (frame_header->fis_type != FIS_REGD2H) {
 		dev_err(&ireq->isci_host->pdev->dev,
 			"%s ERROR: invalid fis type 0x%X\n",
 			__func__, frame_header->fis_type);
 		return SCI_FAILURE;
 	}
 	sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 						 frame_index,
 						 (void **)&frame_buffer);
 	sci_controller_copy_sata_response(&ireq->stp.rsp,
 					  (u32 *)frame_header,
 					  frame_buffer);
 	/* Frame has been decoded return it to the controller */
 	sci_controller_release_frame(ihost, frame_index);
 	return status;
 }
 static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
 						   u32 frame_index)
 {
 	struct sas_task *task = isci_request_access_task(ireq);
 	enum sci_status status;
 	status = process_unsolicited_fis(ireq, frame_index);
 	if (status == SCI_SUCCESS) {
 		if (ireq->stp.rsp.status & ATA_ERR)
 			status = SCI_IO_FAILURE_RESPONSE_VALID;
 	} else {
 		status = SCI_IO_FAILURE_RESPONSE_VALID;
 	}
 	if (status != SCI_SUCCESS) {
 		ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 		ireq->sci_status = status;
 	} else {
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 	}
 	/* the d2h ufi is the end of non-data commands */
 	if (task->data_dir == DMA_NONE)
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 	return status;
 }
 static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
 {
 	struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
 	void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
 	struct scu_task_context *task_context = ireq->tc;
 	/* fill in the SCU Task Context for a DATA fis containing CDB in Raw Frame
 	 * type. The TC for previous Packet fis was already there, we only need to
 	 * change the H2D fis content.
 	 */
 	memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
 	memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
 	memset(&(task_context->type.stp), 0, sizeof(struct stp_task_context));
 	task_context->type.stp.fis_type = FIS_DATA;
 	task_context->transfer_length_bytes = dev->cdb_len;
 }
 static void scu_atapi_construct_task_context(struct isci_request *ireq)
 {
 	struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct scu_task_context *task_context = ireq->tc;
 	int cdb_len = dev->cdb_len;
 	/* reference: SSTL 1.13.4.2
 	 * task_type, sata_direction
 	 */
 	if (task->data_dir == DMA_TO_DEVICE) {
 		task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
 		task_context->sata_direction = 0;
 	} else {
 		/* todo: for NO_DATA command, we need to send out raw frame. */
 		task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_IN;
 		task_context->sata_direction = 1;
 	}
 	memset(&task_context->type.stp, 0, sizeof(task_context->type.stp));
 	task_context->type.stp.fis_type = FIS_DATA;
 	memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
 	memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
 	task_context->ssp_command_iu_length = cdb_len / sizeof(u32);
 	/* task phase is set to TX_CMD */
 	task_context->task_phase = 0x1;
 	/* retry counter */
 	task_context->stp_retry_count = 0;
 	/* data transfer size. */
 	task_context->transfer_length_bytes = task->total_xfer_len;
 	/* setup sgl */
 	sci_request_build_sgl(ireq);
 }
 enum sci_status
 sci_io_request_frame_handler(struct isci_request *ireq,
 				  u32 frame_index)
 {
 	struct isci_host *ihost = ireq->owning_controller;
 	struct isci_stp_request *stp_req = &ireq->stp.req;
 	enum sci_base_request_states state;
 	enum sci_status status;
 	ssize_t word_cnt;
 	state = ireq->sm.current_state_id;
 	switch (state)  {
 	case SCI_REQ_STARTED: {
 		struct ssp_frame_hdr ssp_hdr;
 		void *frame_header;
 		sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 							      frame_index,
 							      &frame_header);
 		word_cnt = sizeof(struct ssp_frame_hdr) / sizeof(u32);
 		sci_swab32_cpy(&ssp_hdr, frame_header, word_cnt);
 		if (ssp_hdr.frame_type == SSP_RESPONSE) {
 			struct ssp_response_iu *resp_iu;
 			ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								      frame_index,
 								      (void **)&resp_iu);
 			sci_swab32_cpy(&ireq->ssp.rsp, resp_iu, word_cnt);
 			resp_iu = &ireq->ssp.rsp;
 			if (resp_iu->datapres == 0x01 ||
 			    resp_iu->datapres == 0x02) {
 				ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 				ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 			} else {
 				ireq->scu_status = SCU_TASK_DONE_GOOD;
 				ireq->sci_status = SCI_SUCCESS;
 			}
 		} else {
 			/* not a response frame, why did it get forwarded? */
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC IO Request 0x%p received unexpected "
 				"frame %d type 0x%02x\n", __func__, ireq,
 				frame_index, ssp_hdr.frame_type);
 		}
 		/*
 		 * In any case we are done with this frame buffer return it to
 		 * the controller
 		 */
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_SUCCESS;
 	}
 	case SCI_REQ_TASK_WAIT_TC_RESP:
 		sci_io_request_copy_response(ireq);
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_SUCCESS;
 	case SCI_REQ_SMP_WAIT_RESP: {
 		struct sas_task *task = isci_request_access_task(ireq);
 		struct scatterlist *sg = &task->smp_task.smp_resp;
 		void *frame_header, *kaddr;
 		u8 *rsp;
 		sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 							 frame_index,
 							 &frame_header);
 		kaddr = kmap_atomic(sg_page(sg));
 		rsp = kaddr + sg->offset;
 		sci_swab32_cpy(rsp, frame_header, 1);
 		if (rsp[0] == SMP_RESPONSE) {
 			void *smp_resp;
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								 frame_index,
 								 &smp_resp);
 			word_cnt = (sg->length/4)-1;
 			if (word_cnt > 0)
 				word_cnt = min_t(unsigned int, word_cnt,
 						 SCU_UNSOLICITED_FRAME_BUFFER_SIZE/4);
 			sci_swab32_cpy(rsp + 4, smp_resp, word_cnt);
 			ireq->scu_status = SCU_TASK_DONE_GOOD;
 			ireq->sci_status = SCI_SUCCESS;
 			sci_change_state(&ireq->sm, SCI_REQ_SMP_WAIT_TC_COMP);
 		} else {
 			/*
 			 * This was not a response frame why did it get
 			 * forwarded?
 			 */
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC SMP Request 0x%p received unexpected "
 				"frame %d type 0x%02x\n",
 				__func__,
 				ireq,
 				frame_index,
 				rsp[0]);
 			ireq->scu_status = SCU_TASK_DONE_SMP_FRM_TYPE_ERR;
 			ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 			sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		}
 		kunmap_atomic(kaddr);
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_SUCCESS;
 	}
 	case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
 		return sci_stp_request_udma_general_frame_handler(ireq,
 								       frame_index);
 	case SCI_REQ_STP_UDMA_WAIT_D2H:
 		/* Use the general frame handler to copy the resposne data */
 		status = sci_stp_request_udma_general_frame_handler(ireq, frame_index);
 		if (status != SCI_SUCCESS)
 			return status;
 		ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 		ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		return SCI_SUCCESS;
 	case SCI_REQ_STP_NON_DATA_WAIT_D2H: {
 		struct dev_to_host_fis *frame_header;
 		u32 *frame_buffer;
 		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 								       frame_index,
 								       (void **)&frame_header);
 		if (status != SCI_SUCCESS) {
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC IO Request 0x%p could not get frame "
 				"header for frame index %d, status %x\n",
 				__func__,
 				stp_req,
 				frame_index,
 				status);
 			return status;
 		}
 		switch (frame_header->fis_type) {
 		case FIS_REGD2H:
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								      frame_index,
 								      (void **)&frame_buffer);
 			sci_controller_copy_sata_response(&ireq->stp.rsp,
 							       frame_header,
 							       frame_buffer);
 			/* The command has completed with error */
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 			break;
 		default:
 			dev_warn(&ihost->pdev->dev,
 				 "%s: IO Request:0x%p Frame Id:%d protocol "
 				  "violation occurred\n", __func__, stp_req,
 				  frame_index);
 			ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
 			ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
 			break;
 		}
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		/* Frame has been decoded return it to the controller */
 		sci_controller_release_frame(ihost, frame_index);
 		return status;
 	}
 	case SCI_REQ_STP_PIO_WAIT_FRAME: {
 		struct sas_task *task = isci_request_access_task(ireq);
 		struct dev_to_host_fis *frame_header;
 		u32 *frame_buffer;
 		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 								       frame_index,
 								       (void **)&frame_header);
 		if (status != SCI_SUCCESS) {
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC IO Request 0x%p could not get frame "
 				"header for frame index %d, status %x\n",
 				__func__, stp_req, frame_index, status);
 			return status;
 		}
 		switch (frame_header->fis_type) {
 		case FIS_PIO_SETUP:
 			/* Get from the frame buffer the PIO Setup Data */
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								      frame_index,
 								      (void **)&frame_buffer);
 			/* Get the data from the PIO Setup The SCU Hardware
 			 * returns first word in the frame_header and the rest
 			 * of the data is in the frame buffer so we need to
 			 * back up one dword
 			 */
 			/* transfer_count: first 16bits in the 4th dword */
 			stp_req->pio_len = frame_buffer[3] & 0xffff;
 			/* status: 4th byte in the 3rd dword */
 			stp_req->status = (frame_buffer[2] >> 24) & 0xff;
 			sci_controller_copy_sata_response(&ireq->stp.rsp,
 							       frame_header,
 							       frame_buffer);
 			ireq->stp.rsp.status = stp_req->status;
 			/* The next state is dependent on whether the
 			 * request was PIO Data-in or Data out
 			 */
 			if (task->data_dir == DMA_FROM_DEVICE) {
 				sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_IN);
 			} else if (task->data_dir == DMA_TO_DEVICE) {
 				/* Transmit data */
 				status = sci_stp_request_pio_data_out_transmit_data(ireq);
 				if (status != SCI_SUCCESS)
 					break;
 				sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_DATA_OUT);
 			}
 			break;
 		case FIS_SETDEVBITS:
 			sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 			break;
 		case FIS_REGD2H:
 			if (frame_header->status & ATA_BUSY) {
 				/*
 				 * Now why is the drive sending a D2H Register
 				 * FIS when it is still busy?  Do nothing since
 				 * we are still in the right state.
 				 */
 				dev_dbg(&ihost->pdev->dev,
 					"%s: SCIC PIO Request 0x%p received "
 					"D2H Register FIS with BSY status "
 					"0x%x\n",
 					__func__,
 					stp_req,
 					frame_header->status);
 				break;
 			}
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								      frame_index,
 								      (void **)&frame_buffer);
 			sci_controller_copy_sata_response(&ireq->stp.req,
 							       frame_header,
 							       frame_buffer);
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 			sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 			break;
 		default:
 			/* FIXME: what do we do here? */
 			break;
 		}
 		/* Frame is decoded return it to the controller */
 		sci_controller_release_frame(ihost, frame_index);
 		return status;
 	}
 	case SCI_REQ_STP_PIO_DATA_IN: {
 		struct dev_to_host_fis *frame_header;
 		struct sata_fis_data *frame_buffer;
 		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
 								       frame_index,
 								       (void **)&frame_header);
 		if (status != SCI_SUCCESS) {
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC IO Request 0x%p could not get frame "
 				"header for frame index %d, status %x\n",
 				__func__,
 				stp_req,
 				frame_index,
 				status);
 			return status;
 		}
 		if (frame_header->fis_type != FIS_DATA) {
 			dev_err(&ihost->pdev->dev,
 				"%s: SCIC PIO Request 0x%p received frame %d "
 				"with fis type 0x%02x when expecting a data "
 				"fis.\n",
 				__func__,
 				stp_req,
 				frame_index,
 				frame_header->fis_type);
 			ireq->scu_status = SCU_TASK_DONE_GOOD;
 			ireq->sci_status = SCI_FAILURE_IO_REQUIRES_SCSI_ABORT;
 			sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 			/* Frame is decoded return it to the controller */
 			sci_controller_release_frame(ihost, frame_index);
 			return status;
 		}
 		if (stp_req->sgl.index < 0) {
 			ireq->saved_rx_frame_index = frame_index;
 			stp_req->pio_len = 0;
 		} else {
 			sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
 								      frame_index,
 								      (void **)&frame_buffer);
 			status = sci_stp_request_pio_data_in_copy_data(stp_req,
 									    (u8 *)frame_buffer);
 			/* Frame is decoded return it to the controller */
 			sci_controller_release_frame(ihost, frame_index);
 		}
 		/* Check for the end of the transfer, are there more
 		 * bytes remaining for this data transfer
 		 */
 		if (status != SCI_SUCCESS || stp_req->pio_len != 0)
 			return status;
 		if ((stp_req->status & ATA_BUSY) == 0) {
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 			sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		} else {
 			sci_change_state(&ireq->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
 		}
 		return status;
 	}
 	case SCI_REQ_ATAPI_WAIT_PIO_SETUP: {
 		struct sas_task *task = isci_request_access_task(ireq);
 		sci_controller_release_frame(ihost, frame_index);
 		ireq->target_device->working_request = ireq;
 		if (task->data_dir == DMA_NONE) {
 			sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
 			scu_atapi_reconstruct_raw_frame_task_context(ireq);
 		} else {
 			sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
 			scu_atapi_construct_task_context(ireq);
 		}
 		sci_controller_continue_io(ireq);
 		return SCI_SUCCESS;
 	}
 	case SCI_REQ_ATAPI_WAIT_D2H:
 		return atapi_d2h_reg_frame_handler(ireq, frame_index);
 	case SCI_REQ_ABORTING:
 		/*
 		 * TODO: Is it even possible to get an unsolicited frame in the
 		 * aborting state?
 		 */
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_SUCCESS;
 	default:
 		dev_warn(&ihost->pdev->dev,
 			 "%s: SCIC IO Request given unexpected frame %x while "
 			 "in state %d\n",
 			 __func__,
 			 frame_index,
 			 state);
 		sci_controller_release_frame(ihost, frame_index);
 		return SCI_FAILURE_INVALID_STATE;
 	}
 }
 static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq,
 						       u32 completion_code)
 {
 	enum sci_status status = SCI_SUCCESS;
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS):
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
 		/* We must check ther response buffer to see if the D2H
 		 * Register FIS was received before we got the TC
 		 * completion.
 		 */
 		if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 			sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		} else {
 			/* If we have an error completion status for the
 			 * TC then we can expect a D2H register FIS from
 			 * the device so we must change state to wait
 			 * for it
 			 */
 			sci_change_state(&ireq->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
 		}
 		break;
 	/* TODO Check to see if any of these completion status need to
 	 * wait for the device to host register fis.
 	 */
 	/* TODO We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR
 	 * - this comes only for B0
 	 */
 	default:
 		/* All other completion status cause the IO to be complete. */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return status;
 }
 static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
 						  enum sci_base_request_states next)
 {
 	enum sci_status status = SCI_SUCCESS;
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, next);
 		break;
 	default:
 		/* All other completion status cause the IO to be complete.
 		 * If a NAK was received, then it is up to the user to retry
 		 * the request.
 		 */
 		ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
 		ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	}
 	return status;
 }
 static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
 							u32 completion_code)
 {
 	struct isci_remote_device *idev = ireq->target_device;
 	struct dev_to_host_fis *d2h = &ireq->stp.rsp;
 	enum sci_status status = SCI_SUCCESS;
 	switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
 	case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT): {
 		u16 len = sci_req_tx_bytes(ireq);
 		/* likely non-error data underrrun, workaround missing
 		 * d2h frame from the controller
 		 */
 		if (d2h->fis_type != FIS_REGD2H) {
 			d2h->fis_type = FIS_REGD2H;
 			d2h->flags = (1 << 6);
 			d2h->status = 0x50;
 			d2h->error = 0;
 			d2h->lbal = 0;
 			d2h->byte_count_low = len & 0xff;
 			d2h->byte_count_high = len >> 8;
 			d2h->device = 0xa0;
 			d2h->lbal_exp = 0;
 			d2h->lbam_exp = 0;
 			d2h->lbah_exp = 0;
 			d2h->_r_a = 0;
 			d2h->sector_count = 0x3;
 			d2h->sector_count_exp = 0;
 			d2h->_r_b = 0;
 			d2h->_r_c = 0;
 			d2h->_r_d = 0;
 		}
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
 		status = ireq->sci_status;
 		/* the hw will have suspended the rnc, so complete the
 		 * request upon pending resume
 		 */
 		sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
 		break;
 	}
 	case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
 		/* In this case, there is no UF coming after.
 		 * compelte the IO now.
 		 */
 		ireq->scu_status = SCU_TASK_DONE_GOOD;
 		ireq->sci_status = SCI_SUCCESS;
 		sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
 		break;
 	default:
 		if (d2h->fis_type == FIS_REGD2H) {
 			/* UF received change the device state to ATAPI_ERROR */
 			status = ireq->sci_status;
 			sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
 		} else {
 			/* If receiving any non-sucess TC status, no UF
 			 * received yet, then an UF for the status fis
 			 * is coming after (XXX: suspect this is
 			 * actually a protocol error or a bug like the
 			 * DONE_UNEXP_FIS case)
 			 */
 			ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
 			ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
 			sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
 		}
 		break;
 	}
 	return status;
 }
 static int sci_request_smp_completion_status_is_tx_suspend(
 	unsigned int completion_status)
 {
 	switch (completion_status) {
 	case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
 	case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
 		return 1;
 	}
 	return 0;
 }
 static int sci_request_smp_completion_status_is_tx_rx_suspend(
 	unsigned int completion_status)
 {
 	return 0; /* There are no Tx/Rx SMP suspend conditions. */
 }
 static int sci_request_ssp_completion_status_is_tx_suspend(
 	unsigned int completion_status)
 {
 	switch (completion_status) {
 	case SCU_TASK_DONE_TX_RAW_CMD_ERR:
 	case SCU_TASK_DONE_LF_ERR:
 	case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
 	case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
 	case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
 	case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
 	case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
 		return 1;
 	}
 	return 0;
 }
 static int sci_request_ssp_completion_status_is_tx_rx_suspend(
 	unsigned int completion_status)
 {
 	return 0; /* There are no Tx/Rx SSP suspend conditions. */
 }
 static int sci_request_stpsata_completion_status_is_tx_suspend(
 	unsigned int completion_status)
 {
 	switch (completion_status) {
 	case SCU_TASK_DONE_TX_RAW_CMD_ERR:
 	case SCU_TASK_DONE_LL_R_ERR:
 	case SCU_TASK_DONE_LL_PERR:
 	case SCU_TASK_DONE_REG_ERR:
 	case SCU_TASK_DONE_SDB_ERR:
 	case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
 	case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 	case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
 	case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
 	case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
 	case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
 		return 1;
 	}
 	return 0;
 }
 static int sci_request_stpsata_completion_status_is_tx_rx_suspend(
 	unsigned int completion_status)
 {
 	switch (completion_status) {
 	case SCU_TASK_DONE_LF_ERR:
 	case SCU_TASK_DONE_LL_SY_TERM:
 	case SCU_TASK_DONE_LL_LF_TERM:
 	case SCU_TASK_DONE_BREAK_RCVD:
 	case SCU_TASK_DONE_INV_FIS_LEN:
 	case SCU_TASK_DONE_UNEXP_FIS:
 	case SCU_TASK_DONE_UNEXP_SDBFIS:
 	case SCU_TASK_DONE_MAX_PLD_ERR:
 		return 1;
 	}
 	return 0;
 }
 static void sci_request_handle_suspending_completions(
 	struct isci_request *ireq,
 	u32 completion_code)
 {
 	int is_tx = 0;
 	int is_tx_rx = 0;
 	switch (ireq->protocol) {
 	case SAS_PROTOCOL_SMP:
 		is_tx = sci_request_smp_completion_status_is_tx_suspend(
 			completion_code);
 		is_tx_rx = sci_request_smp_completion_status_is_tx_rx_suspend(
 			completion_code);
 		break;
 	case SAS_PROTOCOL_SSP:
 		is_tx = sci_request_ssp_completion_status_is_tx_suspend(
 			completion_code);
 		is_tx_rx = sci_request_ssp_completion_status_is_tx_rx_suspend(
 			completion_code);
 		break;
 	case SAS_PROTOCOL_STP:
 		is_tx = sci_request_stpsata_completion_status_is_tx_suspend(
 			completion_code);
 		is_tx_rx =
 			sci_request_stpsata_completion_status_is_tx_rx_suspend(
 				completion_code);
 		break;
 	default:
 		dev_warn(&ireq->isci_host->pdev->dev,
 			 "%s: request %p has no valid protocol\n",
 			 __func__, ireq);
 		break;
 	}
 	if (is_tx || is_tx_rx) {
 		BUG_ON(is_tx && is_tx_rx);
 		sci_remote_node_context_suspend(
 			&ireq->target_device->rnc,
 			SCU_HARDWARE_SUSPENSION,
 			(is_tx_rx) ? SCU_EVENT_TL_RNC_SUSPEND_TX_RX
 				   : SCU_EVENT_TL_RNC_SUSPEND_TX,
 			NULL, NULL);
 	}
 }
 enum sci_status
 sci_io_request_tc_completion(struct isci_request *ireq,
 			     u32 completion_code)
 {
 	enum sci_base_request_states state;
 	struct isci_host *ihost = ireq->owning_controller;
 	state = ireq->sm.current_state_id;
 	/* Decode those completions that signal upcoming suspension events. */
 	sci_request_handle_suspending_completions(
 		ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
 	switch (state) {
 	case SCI_REQ_STARTED:
 		return request_started_state_tc_event(ireq, completion_code);
 	case SCI_REQ_TASK_WAIT_TC_COMP:
 		return ssp_task_request_await_tc_event(ireq,
 						       completion_code);
 	case SCI_REQ_SMP_WAIT_RESP:
 		return smp_request_await_response_tc_event(ireq,
 							   completion_code);
 	case SCI_REQ_SMP_WAIT_TC_COMP:
 		return smp_request_await_tc_event(ireq, completion_code);
 	case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
 		return stp_request_udma_await_tc_event(ireq,
 						       completion_code);
 	case SCI_REQ_STP_NON_DATA_WAIT_H2D:
 		return stp_request_non_data_await_h2d_tc_event(ireq,
 							       completion_code);
 	case SCI_REQ_STP_PIO_WAIT_H2D:
 		return stp_request_pio_await_h2d_completion_tc_event(ireq,
 								     completion_code);
 	case SCI_REQ_STP_PIO_DATA_OUT:
 		return pio_data_out_tx_done_tc_event(ireq, completion_code);
 	case SCI_REQ_ABORTING:
 		return request_aborting_state_tc_event(ireq,
 						       completion_code);
 	case SCI_REQ_ATAPI_WAIT_H2D:
 		return atapi_raw_completion(ireq, completion_code,
 					    SCI_REQ_ATAPI_WAIT_PIO_SETUP);
 	case SCI_REQ_ATAPI_WAIT_TC_COMP:
 		return atapi_raw_completion(ireq, completion_code,
 					    SCI_REQ_ATAPI_WAIT_D2H);
 	case SCI_REQ_ATAPI_WAIT_D2H:
 		return atapi_data_tc_completion_handler(ireq, completion_code);
 	default:
 		dev_warn(&ihost->pdev->dev, "%s: %x in wrong state %s\n",
 			 __func__, completion_code, req_state_name(state));
 		return SCI_FAILURE_INVALID_STATE;
 	}
 }
 /**
  * isci_request_process_response_iu() - This function sets the status and
  *    response iu, in the task struct, from the request object for the upper
  *    layer driver.
  * @sas_task: This parameter is the task struct from the upper layer driver.
  * @resp_iu: This parameter points to the response iu of the completed request.
  * @dev: This parameter specifies the linux device struct.
  *
  * none.
  */
 static void isci_request_process_response_iu(
 	struct sas_task *task,
 	struct ssp_response_iu *resp_iu,
 	struct device *dev)
 {
 	dev_dbg(dev,
 		"%s: resp_iu = %p "
 		"resp_iu->status = 0x%x,\nresp_iu->datapres = %d "
 		"resp_iu->response_data_len = %x, "
 		"resp_iu->sense_data_len = %x\nrepsonse data: ",
 		__func__,
 		resp_iu,
 		resp_iu->status,
 		resp_iu->datapres,
 		resp_iu->response_data_len,
 		resp_iu->sense_data_len);
 	task->task_status.stat = resp_iu->status;
 	/* libsas updates the task status fields based on the response iu. */
 	sas_ssp_task_response(dev, task, resp_iu);
 }
 /**
  * isci_request_set_open_reject_status() - This function prepares the I/O
  *    completion for OPEN_REJECT conditions.
  * @request: This parameter is the completed isci_request object.
  * @response_ptr: This parameter specifies the service response for the I/O.
  * @status_ptr: This parameter specifies the exec status for the I/O.
  * @complete_to_host_ptr: This parameter specifies the action to be taken by
  *    the LLDD with respect to completing this request or forcing an abort
  *    condition on the I/O.
  * @open_rej_reason: This parameter specifies the encoded reason for the
  *    abandon-class reject.
  *
  * none.
  */
 static void isci_request_set_open_reject_status(
 	struct isci_request *request,
 	struct sas_task *task,
 	enum service_response *response_ptr,
 	enum exec_status *status_ptr,
 	enum isci_completion_selection *complete_to_host_ptr,
 	enum sas_open_rej_reason open_rej_reason)
 {
 	/* Task in the target is done. */
 	set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 	*response_ptr                     = SAS_TASK_UNDELIVERED;
 	*status_ptr                       = SAS_OPEN_REJECT;
 	*complete_to_host_ptr             = isci_perform_normal_io_completion;
 	task->task_status.open_rej_reason = open_rej_reason;
 }
 /**
  * isci_request_handle_controller_specific_errors() - This function decodes
  *    controller-specific I/O completion error conditions.
  * @request: This parameter is the completed isci_request object.
  * @response_ptr: This parameter specifies the service response for the I/O.
  * @status_ptr: This parameter specifies the exec status for the I/O.
  * @complete_to_host_ptr: This parameter specifies the action to be taken by
  *    the LLDD with respect to completing this request or forcing an abort
  *    condition on the I/O.
  *
  * none.
  */
 static void isci_request_handle_controller_specific_errors(
 	struct isci_remote_device *idev,
 	struct isci_request *request,
 	struct sas_task *task,
 	enum service_response *response_ptr,
 	enum exec_status *status_ptr,
 	enum isci_completion_selection *complete_to_host_ptr)
 {
 	unsigned int cstatus;
 	cstatus = request->scu_status;
 	dev_dbg(&request->isci_host->pdev->dev,
 		"%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR "
 		"- controller status = 0x%x\n",
 		__func__, request, cstatus);
 	/* Decode the controller-specific errors; most
 	 * important is to recognize those conditions in which
 	 * the target may still have a task outstanding that
 	 * must be aborted.
 	 *
 	 * Note that there are SCU completion codes being
 	 * named in the decode below for which SCIC has already
 	 * done work to handle them in a way other than as
 	 * a controller-specific completion code; these are left
 	 * in the decode below for completeness sake.
 	 */
 	switch (cstatus) {
 	case SCU_TASK_DONE_DMASETUP_DIRERR:
 	/* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */
 	case SCU_TASK_DONE_XFERCNT_ERR:
 		/* Also SCU_TASK_DONE_SMP_UFI_ERR: */
 		if (task->task_proto == SAS_PROTOCOL_SMP) {
 			/* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */
 			*response_ptr = SAS_TASK_COMPLETE;
 			/* See if the device has been/is being stopped. Note
 			 * that we ignore the quiesce state, since we are
 			 * concerned about the actual device state.
 			 */
 			if (!idev)
 				*status_ptr = SAS_DEVICE_UNKNOWN;
 			else
 				*status_ptr = SAS_ABORTED_TASK;
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			*complete_to_host_ptr =
 				isci_perform_normal_io_completion;
 		} else {
 			/* Task in the target is not done. */
 			*response_ptr = SAS_TASK_UNDELIVERED;
 			if (!idev)
 				*status_ptr = SAS_DEVICE_UNKNOWN;
 			else
 				*status_ptr = SAM_STAT_TASK_ABORTED;
 			clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			*complete_to_host_ptr =
 				isci_perform_error_io_completion;
 		}
 		break;
 	case SCU_TASK_DONE_CRC_ERR:
 	case SCU_TASK_DONE_NAK_CMD_ERR:
 	case SCU_TASK_DONE_EXCESS_DATA:
 	case SCU_TASK_DONE_UNEXP_FIS:
 	/* Also SCU_TASK_DONE_UNEXP_RESP: */
 	case SCU_TASK_DONE_VIIT_ENTRY_NV:       /* TODO - conditions? */
 	case SCU_TASK_DONE_IIT_ENTRY_NV:        /* TODO - conditions? */
 	case SCU_TASK_DONE_RNCNV_OUTBOUND:      /* TODO - conditions? */
 		/* These are conditions in which the target
 		 * has completed the task, so that no cleanup
 		 * is necessary.
 		 */
 		*response_ptr = SAS_TASK_COMPLETE;
 		/* See if the device has been/is being stopped. Note
 		 * that we ignore the quiesce state, since we are
 		 * concerned about the actual device state.
 		 */
 		if (!idev)
 			*status_ptr = SAS_DEVICE_UNKNOWN;
 		else
 			*status_ptr = SAS_ABORTED_TASK;
 		set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 		*complete_to_host_ptr = isci_perform_normal_io_completion;
 		break;
 	/* Note that the only open reject completion codes seen here will be
 	 * abandon-class codes; all others are automatically retried in the SCU.
 	 */
 	case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_WRONG_DEST);
 		break;
 	case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
 		/* Note - the return of AB0 will change when
 		 * libsas implements detection of zone violations.
 		 */
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_RESV_AB0);
 		break;
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_RESV_AB1);
 		break;
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_RESV_AB2);
 		break;
 	case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_RESV_AB3);
 		break;
 	case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_BAD_DEST);
 		break;
 	case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_STP_NORES);
 		break;
 	case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_EPROTO);
 		break;
 	case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
 		isci_request_set_open_reject_status(
 			request, task, response_ptr, status_ptr,
 			complete_to_host_ptr, SAS_OREJ_CONN_RATE);
 		break;
 	case SCU_TASK_DONE_LL_R_ERR:
 	/* Also SCU_TASK_DONE_ACK_NAK_TO: */
 	case SCU_TASK_DONE_LL_PERR:
 	case SCU_TASK_DONE_LL_SY_TERM:
 	/* Also SCU_TASK_DONE_NAK_ERR:*/
 	case SCU_TASK_DONE_LL_LF_TERM:
 	/* Also SCU_TASK_DONE_DATA_LEN_ERR: */
 	case SCU_TASK_DONE_LL_ABORT_ERR:
 	case SCU_TASK_DONE_SEQ_INV_TYPE:
 	/* Also SCU_TASK_DONE_UNEXP_XR: */
 	case SCU_TASK_DONE_XR_IU_LEN_ERR:
 	case SCU_TASK_DONE_INV_FIS_LEN:
 	/* Also SCU_TASK_DONE_XR_WD_LEN: */
 	case SCU_TASK_DONE_SDMA_ERR:
 	case SCU_TASK_DONE_OFFSET_ERR:
 	case SCU_TASK_DONE_MAX_PLD_ERR:
 	case SCU_TASK_DONE_LF_ERR:
 	case SCU_TASK_DONE_SMP_RESP_TO_ERR:  /* Escalate to dev reset? */
 	case SCU_TASK_DONE_SMP_LL_RX_ERR:
 	case SCU_TASK_DONE_UNEXP_DATA:
 	case SCU_TASK_DONE_UNEXP_SDBFIS:
 	case SCU_TASK_DONE_REG_ERR:
 	case SCU_TASK_DONE_SDB_ERR:
 	case SCU_TASK_DONE_TASK_ABORT:
 	default:
 		/* Task in the target is not done. */
 		*response_ptr = SAS_TASK_UNDELIVERED;
 		*status_ptr = SAM_STAT_TASK_ABORTED;
 		if (task->task_proto == SAS_PROTOCOL_SMP) {
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			*complete_to_host_ptr = isci_perform_normal_io_completion;
 		} else {
 			clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			*complete_to_host_ptr = isci_perform_error_io_completion;
 		}
 		break;
 	}
 }
 /**
  * isci_task_save_for_upper_layer_completion() - This function saves the
  *    request for later completion to the upper layer driver.
  * @host: This parameter is a pointer to the host on which the the request
  *    should be queued (either as an error or success).
  * @request: This parameter is the completed request.
  * @response: This parameter is the response code for the completed task.
  * @status: This parameter is the status code for the completed task.
  *
  * none.
  */
 static void isci_task_save_for_upper_layer_completion(
 	struct isci_host *host,
 	struct isci_request *request,
 	enum service_response response,
 	enum exec_status status,
 	enum isci_completion_selection task_notification_selection)
 {
 	struct sas_task *task = isci_request_access_task(request);
 	task_notification_selection
 		= isci_task_set_completion_status(task, response, status,
 						  task_notification_selection);
 	/* Tasks aborted specifically by a call to the lldd_abort_task
 	 * function should not be completed to the host in the regular path.
 	 */
 	switch (task_notification_selection) {
 	case isci_perform_normal_io_completion:
 		/* Normal notification (task_done) */
 		/* Add to the completed list. */
 		list_add(&request->completed_node,
 			 &host->requests_to_complete);
 		/* Take the request off the device's pending request list. */
 		list_del_init(&request->dev_node);
 		break;
 	case isci_perform_aborted_io_completion:
 		/* No notification to libsas because this request is
 		 * already in the abort path.
 		 */
 		/* Wake up whatever process was waiting for this
 		 * request to complete.
 		 */
 		WARN_ON(request->io_request_completion == NULL);
 		if (request->io_request_completion != NULL) {
 			/* Signal whoever is waiting that this
 			* request is complete.
 			*/
 			complete(request->io_request_completion);
 		}
 		break;
 	case isci_perform_error_io_completion:
 		/* Use sas_task_abort */
 		/* Add to the aborted list. */
 		list_add(&request->completed_node,
 			 &host->requests_to_errorback);
 		break;
 	default:
 		/* Add to the error to libsas list. */
 		list_add(&request->completed_node,
 			 &host->requests_to_errorback);
 		break;
 	}
 	dev_dbg(&host->pdev->dev,
 		"%s: %d - task = %p, response=%d (%d), status=%d (%d)\n",
 		__func__, task_notification_selection, task,
 		(task) ? task->task_status.resp : 0, response,
 		(task) ? task->task_status.stat : 0, status);
 }
 static void isci_process_stp_response(struct sas_task *task, struct dev_to_host_fis *fis)
 {
 	struct task_status_struct *ts = &task->task_status;
 	struct ata_task_resp *resp = (void *)&ts->buf[0];
 	resp->frame_len = sizeof(*fis);
 	memcpy(resp->ending_fis, fis, sizeof(*fis));
 	ts->buf_valid_size = sizeof(*resp);
 	/* If the device fault bit is set in the status register, then
 	 * set the sense data and return.
 	 */
 	if (fis->status & ATA_DF)
 		ts->stat = SAS_PROTO_RESPONSE;
 	else if (fis->status & ATA_ERR)
 		ts->stat = SAM_STAT_CHECK_CONDITION;
 	else
 		ts->stat = SAM_STAT_GOOD;
 	ts->resp = SAS_TASK_COMPLETE;
 }
 static void isci_request_io_request_complete(struct isci_host *ihost,
 					     struct isci_request *request,
 					     enum sci_io_status completion_status)
 {
 	struct sas_task *task = isci_request_access_task(request);
 	struct ssp_response_iu *resp_iu;
 	unsigned long task_flags;
 	struct isci_remote_device *idev = request->target_device;
 	enum service_response response = SAS_TASK_UNDELIVERED;
 	enum exec_status status = SAS_ABORTED_TASK;
 	enum isci_request_status request_status;
 	enum isci_completion_selection complete_to_host
 		= isci_perform_normal_io_completion;
 	dev_dbg(&ihost->pdev->dev,
 		"%s: request = %p, task = %p,\n"
 		"task->data_dir = %d completion_status = 0x%x\n",
 		__func__,
 		request,
 		task,
 		task->data_dir,
 		completion_status);
 	spin_lock(&request->state_lock);
 	request_status = request->status;
 	/* Decode the request status.  Note that if the request has been
 	 * aborted by a task management function, we don't care
 	 * what the status is.
 	 */
 	switch (request_status) {
 	case aborted:
 		/* "aborted" indicates that the request was aborted by a task
 		 * management function, since once a task management request is
 		 * perfomed by the device, the request only completes because
 		 * of the subsequent driver terminate.
 		 *
 		 * Aborted also means an external thread is explicitly managing
 		 * this request, so that we do not complete it up the stack.
 		 *
 		 * The target is still there (since the TMF was successful).
 		 */
 		set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 		response = SAS_TASK_COMPLETE;
 		/* See if the device has been/is being stopped. Note
 		 * that we ignore the quiesce state, since we are
 		 * concerned about the actual device state.
 		 */
 		if (!idev)
 			status = SAS_DEVICE_UNKNOWN;
 		else
 			status = SAS_ABORTED_TASK;
 		complete_to_host = isci_perform_aborted_io_completion;
 		/* This was an aborted request. */
 		spin_unlock(&request->state_lock);
 		break;
 	case aborting:
 		/* aborting means that the task management function tried and
 		 * failed to abort the request. We need to note the request
 		 * as SAS_TASK_UNDELIVERED, so that the scsi mid layer marks the
 		 * target as down.
 		 *
 		 * Aborting also means an external thread is explicitly managing
 		 * this request, so that we do not complete it up the stack.
 		 */
 		set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 		response = SAS_TASK_UNDELIVERED;
 		if (!idev)
 			/* The device has been /is being stopped. Note that
 			 * we ignore the quiesce state, since we are
 			 * concerned about the actual device state.
 			 */
 			status = SAS_DEVICE_UNKNOWN;
 		else
 			status = SAS_PHY_DOWN;
 		complete_to_host = isci_perform_aborted_io_completion;
 		/* This was an aborted request. */
 		spin_unlock(&request->state_lock);
 		break;
 	case terminating:
 		/* This was an terminated request.  This happens when
 		 * the I/O is being terminated because of an action on
 		 * the device (reset, tear down, etc.), and the I/O needs
 		 * to be completed up the stack.
 		 */
 		set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 		response = SAS_TASK_UNDELIVERED;
 		/* See if the device has been/is being stopped. Note
 		 * that we ignore the quiesce state, since we are
 		 * concerned about the actual device state.
 		 */
 		if (!idev)
 			status = SAS_DEVICE_UNKNOWN;
 		else
 			status = SAS_ABORTED_TASK;
 		complete_to_host = isci_perform_aborted_io_completion;
 		/* This was a terminated request. */
 		spin_unlock(&request->state_lock);
 		break;
 	case dead:
 		/* This was a terminated request that timed-out during the
 		 * termination process.  There is no task to complete to
 		 * libsas.
 		 */
 		complete_to_host = isci_perform_normal_io_completion;
 		spin_unlock(&request->state_lock);
 		break;
 	default:
 		/* The request is done from an SCU HW perspective. */
 		request->status = completed;
 		spin_unlock(&request->state_lock);
 		/* This is an active request being completed from the core. */
 		switch (completion_status) {
 		case SCI_IO_FAILURE_RESPONSE_VALID:
 			dev_dbg(&ihost->pdev->dev,
 				"%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
 				__func__,
 				request,
 				task);
 			if (sas_protocol_ata(task->task_proto)) {
 				isci_process_stp_response(task, &request->stp.rsp);
 			} else if (SAS_PROTOCOL_SSP == task->task_proto) {
 				/* crack the iu response buffer. */
 				resp_iu = &request->ssp.rsp;
 				isci_request_process_response_iu(task, resp_iu,
 								 &ihost->pdev->dev);
 			} else if (SAS_PROTOCOL_SMP == task->task_proto) {
 				dev_err(&ihost->pdev->dev,
 					"%s: SCI_IO_FAILURE_RESPONSE_VALID: "
 					"SAS_PROTOCOL_SMP protocol\n",
 					__func__);
 			} else
 				dev_err(&ihost->pdev->dev,
 					"%s: unknown protocol\n", __func__);
 			/* use the task status set in the task struct by the
 			 * isci_request_process_response_iu call.
 			 */
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			response = task->task_status.resp;
 			status = task->task_status.stat;
 			break;
 		case SCI_IO_SUCCESS:
 		case SCI_IO_SUCCESS_IO_DONE_EARLY:
 			response = SAS_TASK_COMPLETE;
 			status   = SAM_STAT_GOOD;
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
 				/* This was an SSP / STP / SATA transfer.
 				 * There is a possibility that less data than
 				 * the maximum was transferred.
 				 */
 				u32 transferred_length = sci_req_tx_bytes(request);
 				task->task_status.residual
 					= task->total_xfer_len - transferred_length;
 				/* If there were residual bytes, call this an
 				 * underrun.
 				 */
 				if (task->task_status.residual != 0)
 					status = SAS_DATA_UNDERRUN;
 				dev_dbg(&ihost->pdev->dev,
 					"%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
 					__func__,
 					status);
 			} else
 				dev_dbg(&ihost->pdev->dev,
 					"%s: SCI_IO_SUCCESS\n",
 					__func__);
 			break;
 		case SCI_IO_FAILURE_TERMINATED:
 			dev_dbg(&ihost->pdev->dev,
 				"%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
 				__func__,
 				request,
 				task);
 			/* The request was terminated explicitly.  No handling
 			 * is needed in the SCSI error handler path.
 			 */
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			response = SAS_TASK_UNDELIVERED;
 			/* See if the device has been/is being stopped. Note
 			 * that we ignore the quiesce state, since we are
 			 * concerned about the actual device state.
 			 */
 			if (!idev)
 				status = SAS_DEVICE_UNKNOWN;
 			else
 				status = SAS_ABORTED_TASK;
 			complete_to_host = isci_perform_normal_io_completion;
 			break;
 		case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
 			isci_request_handle_controller_specific_errors(
 				idev, request, task, &response, &status,
 				&complete_to_host);
 			break;
 		case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
 			/* This is a special case, in that the I/O completion
 			 * is telling us that the device needs a reset.
 			 * In order for the device reset condition to be
 			 * noticed, the I/O has to be handled in the error
 			 * handler.  Set the reset flag and cause the
 			 * SCSI error thread to be scheduled.
 			 */
 			spin_lock_irqsave(&task->task_state_lock, task_flags);
 			task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
 			spin_unlock_irqrestore(&task->task_state_lock, task_flags);
 			/* Fail the I/O. */
 			response = SAS_TASK_UNDELIVERED;
 			status = SAM_STAT_TASK_ABORTED;
 			complete_to_host = isci_perform_error_io_completion;
 			clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			break;
 		case SCI_FAILURE_RETRY_REQUIRED:
 			/* Fail the I/O so it can be retried. */
 			response = SAS_TASK_UNDELIVERED;
 			if (!idev)
 				status = SAS_DEVICE_UNKNOWN;
 			else
 				status = SAS_ABORTED_TASK;
 			complete_to_host = isci_perform_normal_io_completion;
 			set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 			break;
 		default:
 			/* Catch any otherwise unhandled error codes here. */
 			dev_dbg(&ihost->pdev->dev,
 				 "%s: invalid completion code: 0x%x - "
 				 "isci_request = %p\n",
 				 __func__, completion_status, request);
 			response = SAS_TASK_UNDELIVERED;
 			/* See if the device has been/is being stopped. Note
 			 * that we ignore the quiesce state, since we are
 			 * concerned about the actual device state.
 			 */
 			if (!idev)
 				status = SAS_DEVICE_UNKNOWN;
 			else
 				status = SAS_ABORTED_TASK;
 			if (SAS_PROTOCOL_SMP == task->task_proto) {
 				set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 				complete_to_host = isci_perform_normal_io_completion;
 			} else {
 				clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
 				complete_to_host = isci_perform_error_io_completion;
 			}
 			break;
 		}
 		break;
 	}
 	switch (task->task_proto) {
 	case SAS_PROTOCOL_SSP:
 		if (task->data_dir == DMA_NONE)
 			break;
 		if (task->num_scatter == 0)
 			/* 0 indicates a single dma address */
 			dma_unmap_single(&ihost->pdev->dev,
 					 request->zero_scatter_daddr,
 					 task->total_xfer_len, task->data_dir);
 		else  /* unmap the sgl dma addresses */
 			dma_unmap_sg(&ihost->pdev->dev, task->scatter,
 				     request->num_sg_entries, task->data_dir);
 		break;
 	case SAS_PROTOCOL_SMP: {
 		struct scatterlist *sg = &task->smp_task.smp_req;
 		struct smp_req *smp_req;
 		void *kaddr;
 		dma_unmap_sg(&ihost->pdev->dev, sg, 1, DMA_TO_DEVICE);
 		/* need to swab it back in case the command buffer is re-used */
 		kaddr = kmap_atomic(sg_page(sg));
 		smp_req = kaddr + sg->offset;
 		sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
 		kunmap_atomic(kaddr);
 		break;
 	}
 	default:
 		break;
 	}
 	/* Put the completed request on the correct list */
 	isci_task_save_for_upper_layer_completion(ihost, request, response,
 						  status, complete_to_host
 						  );
 	/* complete the io request to the core. */
 	sci_controller_complete_io(ihost, request->target_device, request);
 	/* set terminated handle so it cannot be completed or
 	 * terminated again, and to cause any calls into abort
 	 * task to recognize the already completed case.
 	 */
 	set_bit(IREQ_TERMINATED, &request->flags);
 }
 static void sci_request_started_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
 	struct domain_device *dev = ireq->target_device->domain_dev;
 	enum sci_base_request_states state;
 	struct sas_task *task;
 	/* XXX as hch said always creating an internal sas_task for tmf
 	 * requests would simplify the driver
 	 */
 	task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
 	/* all unaccelerated request types (non ssp or ncq) handled with
 	 * substates
 	 */
 	if (!task && dev->dev_type == SAS_END_DEV) {
 		state = SCI_REQ_TASK_WAIT_TC_COMP;
 	} else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
 		state = SCI_REQ_SMP_WAIT_RESP;
 	} else if (task && sas_protocol_ata(task->task_proto) &&
 		   !task->ata_task.use_ncq) {
 		if (dev->sata_dev.command_set == ATAPI_COMMAND_SET &&
 			task->ata_task.fis.command == ATA_CMD_PACKET) {
 			state = SCI_REQ_ATAPI_WAIT_H2D;
 		} else if (task->data_dir == DMA_NONE) {
 			state = SCI_REQ_STP_NON_DATA_WAIT_H2D;
 		} else if (task->ata_task.dma_xfer) {
 			state = SCI_REQ_STP_UDMA_WAIT_TC_COMP;
 		} else /* PIO */ {
 			state = SCI_REQ_STP_PIO_WAIT_H2D;
 		}
 	} else {
 		/* SSP or NCQ are fully accelerated, no substates */
 		return;
 	}
 	sci_change_state(sm, state);
 }
 static void sci_request_completed_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
 	struct isci_host *ihost = ireq->owning_controller;
 	/* Tell the SCI_USER that the IO request is complete */
 	if (!test_bit(IREQ_TMF, &ireq->flags))
 		isci_request_io_request_complete(ihost, ireq,
 						 ireq->sci_status);
 	else
 		isci_task_request_complete(ihost, ireq, ireq->sci_status);
 }
 static void sci_request_aborting_state_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
 	/* Setting the abort bit in the Task Context is required by the silicon. */
 	ireq->tc->abort = 1;
 }
 static void sci_stp_request_started_non_data_await_h2d_completion_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
 	ireq->target_device->working_request = ireq;
 }
 static void sci_stp_request_started_pio_await_h2d_completion_enter(struct sci_base_state_machine *sm)
 {
 	struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
 	ireq->target_device->working_request = ireq;
 }
 static const struct sci_base_state sci_request_state_table[] = {
 	[SCI_REQ_INIT] = { },
 	[SCI_REQ_CONSTRUCTED] = { },
 	[SCI_REQ_STARTED] = {
 		.enter_state = sci_request_started_state_enter,
 	},
 	[SCI_REQ_STP_NON_DATA_WAIT_H2D] = {
 		.enter_state = sci_stp_request_started_non_data_await_h2d_completion_enter,
 	},
 	[SCI_REQ_STP_NON_DATA_WAIT_D2H] = { },
 	[SCI_REQ_STP_PIO_WAIT_H2D] = {
 		.enter_state = sci_stp_request_started_pio_await_h2d_completion_enter,
 	},
 	[SCI_REQ_STP_PIO_WAIT_FRAME] = { },
 	[SCI_REQ_STP_PIO_DATA_IN] = { },
 	[SCI_REQ_STP_PIO_DATA_OUT] = { },
 	[SCI_REQ_STP_UDMA_WAIT_TC_COMP] = { },
 	[SCI_REQ_STP_UDMA_WAIT_D2H] = { },
 	[SCI_REQ_TASK_WAIT_TC_COMP] = { },
 	[SCI_REQ_TASK_WAIT_TC_RESP] = { },
 	[SCI_REQ_SMP_WAIT_RESP] = { },
 	[SCI_REQ_SMP_WAIT_TC_COMP] = { },
 	[SCI_REQ_ATAPI_WAIT_H2D] = { },
 	[SCI_REQ_ATAPI_WAIT_PIO_SETUP] = { },
 	[SCI_REQ_ATAPI_WAIT_D2H] = { },
 	[SCI_REQ_ATAPI_WAIT_TC_COMP] = { },
 	[SCI_REQ_COMPLETED] = {
 		.enter_state = sci_request_completed_state_enter,
 	},
 	[SCI_REQ_ABORTING] = {
 		.enter_state = sci_request_aborting_state_enter,
 	},
 	[SCI_REQ_FINAL] = { },
 };
 static void
 sci_general_request_construct(struct isci_host *ihost,
 				   struct isci_remote_device *idev,
 				   struct isci_request *ireq)
 {
 	sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
 	ireq->target_device = idev;
 	ireq->protocol = SAS_PROTOCOL_NONE;
 	ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
 	ireq->sci_status   = SCI_SUCCESS;
 	ireq->scu_status   = 0;
 	ireq->post_context = 0xFFFFFFFF;
 }
 static enum sci_status
 sci_io_request_construct(struct isci_host *ihost,
 			  struct isci_remote_device *idev,
 			  struct isci_request *ireq)
 {
 	struct domain_device *dev = idev->domain_dev;
 	enum sci_status status = SCI_SUCCESS;
 	/* Build the common part of the request */
 	sci_general_request_construct(ihost, idev, ireq);
 	if (idev->rnc.remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
 		return SCI_FAILURE_INVALID_REMOTE_DEVICE;
 	if (dev->dev_type == SAS_END_DEV)
 		/* pass */;
 	else if (dev_is_sata(dev))
 		memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
 	else if (dev_is_expander(dev))
 		/* pass */;
 	else
 		return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
 	memset(ireq->tc, 0, offsetof(struct scu_task_context, sgl_pair_ab));
 	return status;
 }
 enum sci_status sci_task_request_construct(struct isci_host *ihost,
 					    struct isci_remote_device *idev,
 					    u16 io_tag, struct isci_request *ireq)
 {
 	struct domain_device *dev = idev->domain_dev;
 	enum sci_status status = SCI_SUCCESS;
 	/* Build the common part of the request */
 	sci_general_request_construct(ihost, idev, ireq);
 	if (dev->dev_type == SAS_END_DEV || dev_is_sata(dev)) {
 		set_bit(IREQ_TMF, &ireq->flags);
 		memset(ireq->tc, 0, sizeof(struct scu_task_context));
 	} else
 		status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
 	return status;
 }
 static enum sci_status isci_request_ssp_request_construct(
 	struct isci_request *request)
 {
 	enum sci_status status;
 	dev_dbg(&request->isci_host->pdev->dev,
 		"%s: request = %p\n",
 		__func__,
 		request);
 	status = sci_io_request_construct_basic_ssp(request);
 	return status;
 }
 static enum sci_status isci_request_stp_request_construct(struct isci_request *ireq)
 {
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct host_to_dev_fis *fis = &ireq->stp.cmd;
 	struct ata_queued_cmd *qc = task->uldd_task;
 	enum sci_status status;
 	dev_dbg(&ireq->isci_host->pdev->dev,
 		"%s: ireq = %p\n",
 		__func__,
 		ireq);
 	memcpy(fis, &task->ata_task.fis, sizeof(struct host_to_dev_fis));
 	if (!task->ata_task.device_control_reg_update)
 		fis->flags |= 0x80;
 	fis->flags &= 0xF0;
 	status = sci_io_request_construct_basic_sata(ireq);
 	if (qc && (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
 		   qc->tf.command == ATA_CMD_FPDMA_READ)) {
 		fis->sector_count = qc->tag << 3;
 		ireq->tc->type.stp.ncq_tag = qc->tag;
 	}
 	return status;
 }
 static enum sci_status
 sci_io_request_construct_smp(struct device *dev,
 			      struct isci_request *ireq,
 			      struct sas_task *task)
 {
 	struct scatterlist *sg = &task->smp_task.smp_req;
 	struct isci_remote_device *idev;
 	struct scu_task_context *task_context;
 	struct isci_port *iport;
 	struct smp_req *smp_req;
 	void *kaddr;
 	u8 req_len;
 	u32 cmd;
 	kaddr = kmap_atomic(sg_page(sg));
 	smp_req = kaddr + sg->offset;
 	/*
 	 * Look at the SMP requests' header fields; for certain SAS 1.x SMP
 	 * functions under SAS 2.0, a zero request length really indicates
 	 * a non-zero default length.
 	 */
 	if (smp_req->req_len == 0) {
 		switch (smp_req->func) {
 		case SMP_DISCOVER:
 		case SMP_REPORT_PHY_ERR_LOG:
 		case SMP_REPORT_PHY_SATA:
 		case SMP_REPORT_ROUTE_INFO:
 			smp_req->req_len = 2;
 			break;
 		case SMP_CONF_ROUTE_INFO:
 		case SMP_PHY_CONTROL:
 		case SMP_PHY_TEST_FUNCTION:
 			smp_req->req_len = 9;
 			break;
 			/* Default - zero is a valid default for 2.0. */
 		}
 	}
 	req_len = smp_req->req_len;
 	sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
 	cmd = *(u32 *) smp_req;
 	kunmap_atomic(kaddr);
 	if (!dma_map_sg(dev, sg, 1, DMA_TO_DEVICE))
 		return SCI_FAILURE;
 	ireq->protocol = SAS_PROTOCOL_SMP;
 	/* byte swap the smp request. */
 	task_context = ireq->tc;
 	idev = ireq->target_device;
 	iport = idev->owning_port;
 	/*
 	 * Fill in the TC with the its required data
 	 * 00h
 	 */
 	task_context->priority = 0;
 	task_context->initiator_request = 1;
 	task_context->connection_rate = idev->connection_rate;
 	task_context->protocol_engine_index = ISCI_PEG;
 	task_context->logical_port_index = iport->physical_port_index;
 	task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SMP;
 	task_context->abort = 0;
 	task_context->valid = SCU_TASK_CONTEXT_VALID;
 	task_context->context_type = SCU_TASK_CONTEXT_TYPE;
 	/* 04h */
 	task_context->remote_node_index = idev->rnc.remote_node_index;
 	task_context->command_code = 0;
 	task_context->task_type = SCU_TASK_TYPE_SMP_REQUEST;
 	/* 08h */
 	task_context->link_layer_control = 0;
 	task_context->do_not_dma_ssp_good_response = 1;
 	task_context->strict_ordering = 0;
 	task_context->control_frame = 1;
 	task_context->timeout_enable = 0;
 	task_context->block_guard_enable = 0;
 	/* 0ch */
 	task_context->address_modifier = 0;
 	/* 10h */
 	task_context->ssp_command_iu_length = req_len;
 	/* 14h */
 	task_context->transfer_length_bytes = 0;
 	/*
 	 * 18h ~ 30h, protocol specific
 	 * since commandIU has been build by framework at this point, we just
 	 * copy the frist DWord from command IU to this location. */
 	memcpy(&task_context->type.smp, &cmd, sizeof(u32));
 	/*
 	 * 40h
 	 * "For SMP you could program it to zero. We would prefer that way
 	 * so that done code will be consistent." - Venki
 	 */
 	task_context->task_phase = 0;
 	ireq->post_context = (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
 			      (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
 			       (iport->physical_port_index <<
 				SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
 			      ISCI_TAG_TCI(ireq->io_tag));
 	/*
 	 * Copy the physical address for the command buffer to the SCU Task
 	 * Context command buffer should not contain command header.
 	 */
 	task_context->command_iu_upper = upper_32_bits(sg_dma_address(sg));
 	task_context->command_iu_lower = lower_32_bits(sg_dma_address(sg) + sizeof(u32));
 	/* SMP response comes as UF, so no need to set response IU address. */
 	task_context->response_iu_upper = 0;
 	task_context->response_iu_lower = 0;
 	sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
 	return SCI_SUCCESS;
 }
 /*
  * isci_smp_request_build() - This function builds the smp request.
  * @ireq: This parameter points to the isci_request allocated in the
  *    request construct function.
  *
  * SCI_SUCCESS on successfull completion, or specific failure code.
  */
 static enum sci_status isci_smp_request_build(struct isci_request *ireq)
 {
 	struct sas_task *task = isci_request_access_task(ireq);
 	struct device *dev = &ireq->isci_host->pdev->dev;
 	enum sci_status status = SCI_FAILURE;
 	status = sci_io_request_construct_smp(dev, ireq, task);
 	if (status != SCI_SUCCESS)
 		dev_dbg(&ireq->isci_host->pdev->dev,
 			 "%s: failed with status = %d\n",
 			 __func__,
 			 status);
 	return status;
 }
 /**
  * isci_io_request_build() - This function builds the io request object.
  * @ihost: This parameter specifies the ISCI host object
  * @request: This parameter points to the isci_request object allocated in the
  *    request construct function.
  * @sci_device: This parameter is the handle for the sci core's remote device
  *    object that is the destination for this request.
  *
  * SCI_SUCCESS on successfull completion, or specific failure code.
  */
 static enum sci_status isci_io_request_build(struct isci_host *ihost,
 					     struct isci_request *request,
 					     struct isci_remote_device *idev)
 {
 	enum sci_status status = SCI_SUCCESS;
 	struct sas_task *task = isci_request_access_task(request);
 	dev_dbg(&ihost->pdev->dev,
 		"%s: idev = 0x%p; request = %p, "
 		"num_scatter = %d\n",
 		__func__,
 		idev,
 		request,
 		task->num_scatter);
 	/* map the sgl addresses, if present.
 	 * libata does the mapping for sata devices
 	 * before we get the request.
 	 */
 	if (task->num_scatter &&
 	    !sas_protocol_ata(task->task_proto) &&
 	    !(SAS_PROTOCOL_SMP & task->task_proto)) {
 		request->num_sg_entries = dma_map_sg(
 			&ihost->pdev->dev,
 			task->scatter,
 			task->num_scatter,
 			task->data_dir
 			);
 		if (request->num_sg_entries == 0)
 			return SCI_FAILURE_INSUFFICIENT_RESOURCES;
 	}
 	status = sci_io_request_construct(ihost, idev, request);
 	if (status != SCI_SUCCESS) {
 		dev_dbg(&ihost->pdev->dev,
 			 "%s: failed request construct\n",
 			 __func__);
 		return SCI_FAILURE;
 	}
 	switch (task->task_proto) {
 	case SAS_PROTOCOL_SMP:
 		status = isci_smp_request_build(request);
 		break;
 	case SAS_PROTOCOL_SSP:
 		status = isci_request_ssp_request_construct(request);
 		break;
 	case SAS_PROTOCOL_SATA:
 	case SAS_PROTOCOL_STP:
 	case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
 		status = isci_request_stp_request_construct(request);
 		break;
 	default:
 		dev_dbg(&ihost->pdev->dev,
 			 "%s: unknown protocol\n", __func__);
 		return SCI_FAILURE;
 	}
 	return SCI_SUCCESS;
 }
 static struct isci_request *isci_request_from_tag(struct isci_host *ihost, u16 tag)
 {
 	struct isci_request *ireq;
 	ireq = ihost->reqs[ISCI_TAG_TCI(tag)];
 	ireq->io_tag = tag;
 	ireq->io_request_completion = NULL;
 	ireq->flags = 0;
 	ireq->num_sg_entries = 0;
 	INIT_LIST_HEAD(&ireq->completed_node);
 	INIT_LIST_HEAD(&ireq->dev_node);
 	isci_request_change_state(ireq, allocated);
 	return ireq;
 }
 static struct isci_request *isci_io_request_from_tag(struct isci_host *ihost,
 						     struct sas_task *task,
 						     u16 tag)
 {
 	struct isci_request *ireq;
 	ireq = isci_request_from_tag(ihost, tag);
 	ireq->ttype_ptr.io_task_ptr = task;
 	clear_bit(IREQ_TMF, &ireq->flags);
 	task->lldd_task = ireq;
 	return ireq;
 }
 struct isci_request *isci_tmf_request_from_tag(struct isci_host *ihost,
 					       struct isci_tmf *isci_tmf,
 					       u16 tag)
 {
 	struct isci_request *ireq;
 	ireq = isci_request_from_tag(ihost, tag);
 	ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
 	set_bit(IREQ_TMF, &ireq->flags);
 	return ireq;
 }
 int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
 			 struct sas_task *task, u16 tag)
 {
 	enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
 	struct isci_request *ireq;
 	unsigned long flags;
 	int ret = 0;
 	/* do common allocation and init of request object. */
 	ireq = isci_io_request_from_tag(ihost, task, tag);
 	status = isci_io_request_build(ihost, ireq, idev);
 	if (status != SCI_SUCCESS) {
 		dev_dbg(&ihost->pdev->dev,
 			 "%s: request_construct failed - status = 0x%x\n",
 			 __func__,
 			 status);
 		return status;
 	}
 	spin_lock_irqsave(&ihost->scic_lock, flags);
 	if (test_bit(IDEV_IO_NCQERROR, &idev->flags)) {
 		if (isci_task_is_ncq_recovery(task)) {
 			/* The device is in an NCQ recovery state.  Issue the
 			 * request on the task side.  Note that it will
 			 * complete on the I/O request side because the
 			 * request was built that way (ie.
 			 * ireq->is_task_management_request is false).
 			 */
 			status = sci_controller_start_task(ihost,
 							    idev,
 							    ireq);
 		} else {
 			status = SCI_FAILURE;
 		}
 	} else {
 		/* send the request, let the core assign the IO TAG.	*/
 		status = sci_controller_start_io(ihost, idev,
 						  ireq);
 	}
 	if (status != SCI_SUCCESS &&
 	    status != SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
 		dev_dbg(&ihost->pdev->dev,
 			 "%s: failed request start (0x%x)\n",
 			 __func__, status);
 		spin_unlock_irqrestore(&ihost->scic_lock, flags);
 		return status;
 	}
 	/* Either I/O started OK, or the core has signaled that
 	 * the device needs a target reset.
 	 *
 	 * In either case, hold onto the I/O for later.
 	 *
 	 * Update it's status and add it to the list in the
 	 * remote device object.
 	 */
 	list_add(&ireq->dev_node, &idev->reqs_in_process);
 	if (status == SCI_SUCCESS) {
 		isci_request_change_state(ireq, started);
 	} else {
 		/* The request did not really start in the
 		 * hardware, so clear the request handle
 		 * here so no terminations will be done.
 		 */
 		set_bit(IREQ_TERMINATED, &ireq->flags);
 		isci_request_change_state(ireq, completed);
 	}
 	spin_unlock_irqrestore(&ihost->scic_lock, flags);
 	if (status ==
 	    SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
 		/* Signal libsas that we need the SCSI error
 		 * handler thread to work on this I/O and that
 		 * we want a 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);
 		/* Cause this task to be scheduled in the SCSI error
 		 * handler thread.
 		 */
 		sas_task_abort(task);
 		/* Change the status, since we are holding
 		 * the I/O until it is managed by the SCSI
 		 * error handler.
 		 */
 		status = SCI_SUCCESS;
 	}

drivers/scsi/isci/request.h

Diff comments View file @ 726980d

 /*
  * This file is provided under a dual BSD/GPLv2 license.  When using or
  * redistributing this file, you may do so under either license.
  *
  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  * The full GNU General Public License is included in this distribution
  * in the file called LICENSE.GPL.
  *
  * BSD LICENSE
  *
  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in
  *     the documentation and/or other materials provided with the
  *     distribution.
  *   * Neither the name of Intel Corporation nor the names of its
  *     contributors may be used to endorse or promote products derived
  *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _ISCI_REQUEST_H_
 #define _ISCI_REQUEST_H_
 #include "isci.h"
 #include "host.h"
 #include "scu_task_context.h"
 /**
  * struct isci_request_status - This enum defines the possible states of an I/O
  *    request.
  *
  *
  */
 enum isci_request_status {
 	unallocated = 0x00,
 	allocated   = 0x01,
 	started     = 0x02,
 	completed   = 0x03,
 	aborting    = 0x04,
 	aborted     = 0x05,
 	terminating = 0x06,
 	dead        = 0x07
 };
 /**
  * isci_stp_request - extra request infrastructure to handle pio/atapi protocol
  * @pio_len - number of bytes requested at PIO setup
  * @status - pio setup ending status value to tell us if we need
  *	     to wait for another fis or if the transfer is complete.  Upon
  *           receipt of a d2h fis this will be the status field of that fis.
  * @sgl - track pio transfer progress as we iterate through the sgl
  */
 struct isci_stp_request {
 	u32 pio_len;
 	u8 status;
 	struct isci_stp_pio_sgl {
 		int index;
 		u8 set;
 		u32 offset;
 	} sgl;
 };
 struct isci_request {
 	enum isci_request_status status;
 	#define IREQ_COMPLETE_IN_TARGET 0
 	#define IREQ_TERMINATED 1
 	#define IREQ_TMF 2
 	#define IREQ_ACTIVE 3
+	#define IREQ_PENDING_ABORT 4 /* Set == device was not suspended yet */
+	#define IREQ_TC_ABORT_POSTED 5
 	unsigned long flags;
 	/* XXX kill ttype and ttype_ptr, allocate full sas_task */
 	union ttype_ptr_union {
 		struct sas_task *io_task_ptr;   /* When ttype==io_task  */
 		struct isci_tmf *tmf_task_ptr;  /* When ttype==tmf_task */
 	} ttype_ptr;
 	struct isci_host *isci_host;
 	/* For use in the requests_to_{complete|abort} lists: */
 	struct list_head completed_node;
 	/* For use in the reqs_in_process list: */
 	struct list_head dev_node;
 	spinlock_t state_lock;
 	dma_addr_t request_daddr;
 	dma_addr_t zero_scatter_daddr;
 	unsigned int num_sg_entries;
 	/* Note: "io_request_completion" is completed in two different ways
 	 * depending on whether this is a TMF or regular request.
 	 * - TMF requests are completed in the thread that started them;
 	 * - regular requests are completed in the request completion callback
 	 *   function.
 	 * This difference in operation allows the aborter of a TMF request
 	 * to be sure that once the TMF request completes, the I/O that the
 	 * TMF was aborting is guaranteed to have completed.
 	 *
 	 * XXX kill io_request_completion
 	 */
 	struct completion *io_request_completion;
 	struct sci_base_state_machine sm;
 	struct isci_host *owning_controller;
 	struct isci_remote_device *target_device;
 	u16 io_tag;
 	enum sas_protocol protocol;
 	u32 scu_status; /* hardware result */
 	u32 sci_status; /* upper layer disposition */
 	u32 post_context;
 	struct scu_task_context *tc;
 	/* could be larger with sg chaining */
 	#define SCU_SGL_SIZE ((SCI_MAX_SCATTER_GATHER_ELEMENTS + 1) / 2)
 	struct scu_sgl_element_pair sg_table[SCU_SGL_SIZE] __attribute__ ((aligned(32)));
 	/* This field is a pointer to the stored rx frame data.  It is used in
 	 * STP internal requests and SMP response frames.  If this field is
 	 * non-NULL the saved frame must be released on IO request completion.
 	 */
 	u32 saved_rx_frame_index;
 	union {
 		struct {
 			union {
 				struct ssp_cmd_iu cmd;
 				struct ssp_task_iu tmf;
 			};
 			union {
 				struct ssp_response_iu rsp;
 				u8 rsp_buf[SSP_RESP_IU_MAX_SIZE];
 			};
 		} ssp;
 		struct {
 			struct isci_stp_request req;
 			struct host_to_dev_fis cmd;
 			struct dev_to_host_fis rsp;
 		} stp;
 	};
 };
 static inline struct isci_request *to_ireq(struct isci_stp_request *stp_req)
 {
 	struct isci_request *ireq;
 	ireq = container_of(stp_req, typeof(*ireq), stp.req);
 	return ireq;
 }
 /**
  * enum sci_base_request_states - request state machine states
  *
  * @SCI_REQ_INIT: Simply the initial state for the base request state machine.
  *
  * @SCI_REQ_CONSTRUCTED: This state indicates that the request has been
  * constructed.  This state is entered from the INITIAL state.
  *
  * @SCI_REQ_STARTED: This state indicates that the request has been started.
  * This state is entered from the CONSTRUCTED state.
  *
  * @SCI_REQ_STP_UDMA_WAIT_TC_COMP:
  * @SCI_REQ_STP_UDMA_WAIT_D2H:
  * @SCI_REQ_STP_NON_DATA_WAIT_H2D:
  * @SCI_REQ_STP_NON_DATA_WAIT_D2H:
  *
  * @SCI_REQ_STP_PIO_WAIT_H2D: While in this state the IO request object is
  * waiting for the TC completion notification for the H2D Register FIS
  *
  * @SCI_REQ_STP_PIO_WAIT_FRAME: While in this state the IO request object is
  * waiting for either a PIO Setup FIS or a D2H register FIS.  The type of frame
  * received is based on the result of the prior frame and line conditions.
  *
  * @SCI_REQ_STP_PIO_DATA_IN: While in this state the IO request object is
  * waiting for a DATA frame from the device.
  *
  * @SCI_REQ_STP_PIO_DATA_OUT: While in this state the IO request object is
  * waiting to transmit the next data frame to the device.
  *
  * @SCI_REQ_ATAPI_WAIT_H2D: While in this state the IO request object is
  * waiting for the TC completion notification for the H2D Register FIS
  *
  * @SCI_REQ_ATAPI_WAIT_PIO_SETUP: While in this state the IO request object is
  * waiting for either a PIO Setup.
  *
  * @SCI_REQ_ATAPI_WAIT_D2H: The non-data IO transit to this state in this state
  * after receiving TC completion. While in this state IO request object is
  * waiting for D2H status frame as UF.
  *
  * @SCI_REQ_ATAPI_WAIT_TC_COMP: When transmitting raw frames hardware reports
  * task context completion after every frame submission, so in the
  * non-accelerated case we need to expect the completion for the "cdb" frame.
  *
  * @SCI_REQ_TASK_WAIT_TC_COMP: The AWAIT_TC_COMPLETION sub-state indicates that
  * the started raw task management request is waiting for the transmission of
  * the initial frame (i.e. command, task, etc.).
  *
  * @SCI_REQ_TASK_WAIT_TC_RESP: This sub-state indicates that the started task
  * management request is waiting for the reception of an unsolicited frame
  * (i.e.  response IU).
  *
  * @SCI_REQ_SMP_WAIT_RESP: This sub-state indicates that the started task
  * management request is waiting for the reception of an unsolicited frame
  * (i.e.  response IU).
  *
  * @SCI_REQ_SMP_WAIT_TC_COMP: The AWAIT_TC_COMPLETION sub-state indicates that
  * the started SMP request is waiting for the transmission of the initial frame
  * (i.e.  command, task, etc.).
  *
  * @SCI_REQ_COMPLETED: This state indicates that the request has completed.
  * This state is entered from the STARTED state. This state is entered from the
  * ABORTING state.
  *
  * @SCI_REQ_ABORTING: This state indicates that the request is in the process
  * of being terminated/aborted.  This state is entered from the CONSTRUCTED
  * state.  This state is entered from the STARTED state.
  *
  * @SCI_REQ_FINAL: Simply the final state for the base request state machine.
  */
 #define REQUEST_STATES {\
 	C(REQ_INIT),\
 	C(REQ_CONSTRUCTED),\
 	C(REQ_STARTED),\
 	C(REQ_STP_UDMA_WAIT_TC_COMP),\
 	C(REQ_STP_UDMA_WAIT_D2H),\
 	C(REQ_STP_NON_DATA_WAIT_H2D),\
 	C(REQ_STP_NON_DATA_WAIT_D2H),\
 	C(REQ_STP_PIO_WAIT_H2D),\
 	C(REQ_STP_PIO_WAIT_FRAME),\
 	C(REQ_STP_PIO_DATA_IN),\
 	C(REQ_STP_PIO_DATA_OUT),\
 	C(REQ_ATAPI_WAIT_H2D),\
 	C(REQ_ATAPI_WAIT_PIO_SETUP),\
 	C(REQ_ATAPI_WAIT_D2H),\
 	C(REQ_ATAPI_WAIT_TC_COMP),\
 	C(REQ_TASK_WAIT_TC_COMP),\
 	C(REQ_TASK_WAIT_TC_RESP),\
 	C(REQ_SMP_WAIT_RESP),\
 	C(REQ_SMP_WAIT_TC_COMP),\
 	C(REQ_COMPLETED),\
 	C(REQ_ABORTING),\
 	C(REQ_FINAL),\
 	}
 #undef C
 #define C(a) SCI_##a
 enum sci_base_request_states REQUEST_STATES;
 #undef C
 const char *req_state_name(enum sci_base_request_states state);
 enum sci_status sci_request_start(struct isci_request *ireq);
 enum sci_status sci_io_request_terminate(struct isci_request *ireq);
 enum sci_status
 sci_io_request_event_handler(struct isci_request *ireq,
 				  u32 event_code);
 enum sci_status
 sci_io_request_frame_handler(struct isci_request *ireq,
 				  u32 frame_index);
 enum sci_status
 sci_task_request_terminate(struct isci_request *ireq);
 extern enum sci_status
 sci_request_complete(struct isci_request *ireq);
 extern enum sci_status
 sci_io_request_tc_completion(struct isci_request *ireq, u32 code);
 /* XXX open code in caller */
 static inline dma_addr_t
 sci_io_request_get_dma_addr(struct isci_request *ireq, void *virt_addr)
 {
 	char *requested_addr = (char *)virt_addr;
 	char *base_addr = (char *)ireq;
 	BUG_ON(requested_addr < base_addr);
 	BUG_ON((requested_addr - base_addr) >= sizeof(*ireq));
 	return ireq->request_daddr + (requested_addr - base_addr);
 }
 /**
  * isci_request_change_state() - This function sets the status of the request
  *    object.
  * @request: This parameter points to the isci_request object
  * @status: This Parameter is the new status of the object
  *
  */
 static inline enum isci_request_status
 isci_request_change_state(struct isci_request *isci_request,
 			  enum isci_request_status status)
 {
 	enum isci_request_status old_state;
 	unsigned long flags;
 	dev_dbg(&isci_request->isci_host->pdev->dev,
 		"%s: isci_request = %p, state = 0x%x\n",
 		__func__,
 		isci_request,
 		status);
 	BUG_ON(isci_request == NULL);
 	spin_lock_irqsave(&isci_request->state_lock, flags);
 	old_state = isci_request->status;
 	isci_request->status = status;
 	spin_unlock_irqrestore(&isci_request->state_lock, flags);
 	return old_state;
 }
 /**
  * isci_request_change_started_to_newstate() - This function sets the status of
  *    the request object.
  * @request: This parameter points to the isci_request object
  * @status: This Parameter is the new status of the object
  *
  * state previous to any change.
  */
 static inline enum isci_request_status
 isci_request_change_started_to_newstate(struct isci_request *isci_request,
 					struct completion *completion_ptr,
 					enum isci_request_status newstate)
 {
 	enum isci_request_status old_state;
 	unsigned long flags;
 	spin_lock_irqsave(&isci_request->state_lock, flags);
 	old_state = isci_request->status;
 	if (old_state == started || old_state == aborting) {
 		BUG_ON(isci_request->io_request_completion != NULL);
 		isci_request->io_request_completion = completion_ptr;
 		isci_request->status = newstate;
 	}
 	spin_unlock_irqrestore(&isci_request->state_lock, flags);
 	dev_dbg(&isci_request->isci_host->pdev->dev,
 		"%s: isci_request = %p, old_state = 0x%x\n",
 		__func__,
 		isci_request,
 		old_state);
 	return old_state;
 }
 /**
  * isci_request_change_started_to_aborted() - This function sets the status of
  *    the request object.
  * @request: This parameter points to the isci_request object
  * @completion_ptr: This parameter is saved as the kernel completion structure
  *    signalled when the old request completes.
  *
  * state previous to any change.
  */
 static inline enum isci_request_status
 isci_request_change_started_to_aborted(struct isci_request *isci_request,
 				       struct completion *completion_ptr)
 {
 	return isci_request_change_started_to_newstate(isci_request,
 						       completion_ptr,
 						       aborted);
 }
 #define isci_request_access_task(req) ((req)->ttype_ptr.io_task_ptr)
 #define isci_request_access_tmf(req) ((req)->ttype_ptr.tmf_task_ptr)
 struct isci_request *isci_tmf_request_from_tag(struct isci_host *ihost,
 					       struct isci_tmf *isci_tmf,
 					       u16 tag);
 int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
 			 struct sas_task *task, u16 tag);
 void isci_terminate_pending_requests(struct isci_host *ihost,
 				     struct isci_remote_device *idev);
 enum sci_status
 sci_task_request_construct(struct isci_host *ihost,
 			    struct isci_remote_device *idev,
 			    u16 io_tag,
 			    struct isci_request *ireq);
 enum sci_status sci_task_request_construct_ssp(struct isci_request *ireq);
 void sci_smp_request_copy_response(struct isci_request *ireq);
 static inline int isci_task_is_ncq_recovery(struct sas_task *task)
 {
 	return (sas_protocol_ata(task->task_proto) &&
 		task->ata_task.fis.command == ATA_CMD_READ_LOG_EXT &&
 		task->ata_task.fis.lbal == ATA_LOG_SATA_NCQ);
 }
 #endif /* !defined(_ISCI_REQUEST_H_) */

1	/*	1	/*
2	* This file is provided under a dual BSD/GPLv2 license. When using or	2	* This file is provided under a dual BSD/GPLv2 license. When using or
3	* redistributing this file, you may do so under either license.	3	* redistributing this file, you may do so under either license.
4	*	4	*
5	* GPL LICENSE SUMMARY	5	* GPL LICENSE SUMMARY
6	*	6	*
7	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.	7	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8	*	8	*
9	* This program is free software; you can redistribute it and/or modify	9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of version 2 of the GNU General Public License as	10	* it under the terms of version 2 of the GNU General Public License as
11	* published by the Free Software Foundation.	11	* published by the Free Software Foundation.
12	*	12	*
13	* This program is distributed in the hope that it will be useful, but	13	* This program is distributed in the hope that it will be useful, but
14	* WITHOUT ANY WARRANTY; without even the implied warranty of	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* General Public License for more details.	16	* General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.	20	* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21	* The full GNU General Public License is included in this distribution	21	* The full GNU General Public License is included in this distribution
22	* in the file called LICENSE.GPL.	22	* in the file called LICENSE.GPL.
23	*	23	*
24	* BSD LICENSE	24	* BSD LICENSE
25	*	25	*
26	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.	26	* Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27	* All rights reserved.	27	* All rights reserved.
28	*	28	*
29	* Redistribution and use in source and binary forms, with or without	29	* Redistribution and use in source and binary forms, with or without
30	* modification, are permitted provided that the following conditions	30	* modification, are permitted provided that the following conditions
31	* are met:	31	* are met:
32	*	32	*
33	* * Redistributions of source code must retain the above copyright	33	* * Redistributions of source code must retain the above copyright
34	* notice, this list of conditions and the following disclaimer.	34	* notice, this list of conditions and the following disclaimer.
35	* * Redistributions in binary form must reproduce the above copyright	35	* * Redistributions in binary form must reproduce the above copyright
36	* notice, this list of conditions and the following disclaimer in	36	* notice, this list of conditions and the following disclaimer in
37	* the documentation and/or other materials provided with the	37	* the documentation and/or other materials provided with the
38	* distribution.	38	* distribution.
39	* * Neither the name of Intel Corporation nor the names of its	39	* * Neither the name of Intel Corporation nor the names of its
40	* contributors may be used to endorse or promote products derived	40	* contributors may be used to endorse or promote products derived