Skip to content

L
linux
Commit 827a84d4 authored by Dan Williams's avatar Dan Williams
Browse files
Options

isci: move stp request info to scic_sds_request 

In preparation for unifying allocation of all request information make stp
data available in all requests.  Incidentally collapse indentation.
Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent e531381e
Hide whitespace changes
Inline Side-by-side
Showing with 313 additions and 435 deletions
drivers/scsi/isci/core/scic_sds_request.c
View file @ 827a84d4
......@@ -710,8 +710,7 @@ enum sci_status scic_io_request_construct_basic_sata(
struct isci_request *isci_request = sci_req->ireq;
struct sas_task *task = isci_request_access_task(isci_request);
stp_req = container_of(sci_req, typeof(*stp_req), parent);
stp_req = &sci_req->stp.req;
sci_req->protocol = SCIC_STP_PROTOCOL;
copy = (task->data_dir == DMA_NONE) ? false : true;
......
drivers/scsi/isci/core/scic_sds_request.h
View file @ 827a84d4
......@@ -56,16 +56,10 @@
#ifndef _SCIC_SDS_IO_REQUEST_H_
#define _SCIC_SDS_IO_REQUEST_H_
/**
* This file contains the structures, constants and prototypes for the
* SCIC_SDS_IO_REQUEST object.
*
*
*/
#include "scic_io_request.h"
#include "sci_base_state_machine.h"
#include "scu_task_context.h"
#include "scic_sds_stp_request.h"
struct scic_sds_controller;
struct scic_sds_remote_device;
......@@ -233,8 +227,19 @@ struct scic_sds_request {
*/
u8 device_sequence;
struct {
struct scic_sds_stp_request req;
} stp;
};
static inline struct scic_sds_request *to_sci_req(struct scic_sds_stp_request *stp_req)
{
struct scic_sds_request *sci_req;
sci_req = container_of(stp_req, typeof(*sci_req), stp.req);
return sci_req;
}
/**
* enum sci_base_request_states - This enumeration depicts all the states for
* the common request state machine.
......
drivers/scsi/isci/core/scic_sds_stp_request.c
View file @ 827a84d4
......@@ -134,8 +134,7 @@ u32 scic_sds_stp_request_get_object_size(void)
void scic_sds_stp_request_assign_buffers(struct scic_sds_request *sci_req)
{
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
sci_req->command_buffer = scic_sds_stp_request_get_h2d_reg_buffer(stp_req);
sci_req->response_buffer = scic_sds_stp_request_get_response_buffer(stp_req);
......@@ -344,17 +343,18 @@ enum sci_status scic_sds_stp_ncq_request_construct(struct scic_sds_request *sci_
* utilizing the raw frame method. none
*/
static void scu_stp_raw_request_construct_task_context(
struct scic_sds_stp_request *sci_req,
struct scic_sds_stp_request *stp_req,
struct scu_task_context *task_context)
{
scu_sata_reqeust_construct_task_context(&sci_req->parent, task_context);
struct scic_sds_request *sci_req = to_sci_req(stp_req);
scu_sata_reqeust_construct_task_context(sci_req, 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);
task_context->transfer_length_bytes = sizeof(struct host_to_dev_fis) - sizeof(u32);
}
void scic_stp_io_request_set_ncq_tag(
......@@ -376,10 +376,11 @@ void *scic_stp_io_request_get_h2d_reg_address(
}
void *scic_stp_io_request_get_d2h_reg_address(
struct scic_sds_request *req)
void *scic_stp_io_request_get_d2h_reg_address(struct scic_sds_request *sci_req)
{
return &((struct scic_sds_stp_request *)req)->d2h_reg_fis;
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
return &stp_req->d2h_reg_fis;
}
/**
......@@ -395,7 +396,7 @@ void *scic_stp_io_request_get_d2h_reg_address(
static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic_sds_stp_request *stp_req)
{
struct scu_sgl_element *current_sgl;
struct scic_sds_request *sci_req = &stp_req->parent;
struct scic_sds_request *sci_req = to_sci_req(stp_req);
struct scic_sds_request_pio_sgl *pio_sgl = &stp_req->type.pio.request_current;
if (pio_sgl->sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
......@@ -489,60 +490,54 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
enum sci_status status;
struct dev_to_host_fis *frame_header;
u32 *frame_buffer;
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
status = scic_sds_unsolicited_frame_control_get_header(
&stp_req->parent.owning_controller->uf_control,
frame_index,
(void **)&frame_header);
if (status == SCI_SUCCESS) {
switch (frame_header->fis_type) {
case FIS_REGD2H:
scic_sds_unsolicited_frame_control_get_buffer(
&stp_req->parent.owning_controller->uf_control,
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(
&stp_req->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer);
/* The command has completed with error */
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
break;
default:
dev_warn(scic_to_dev(sci_req->owning_controller),
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n",
__func__, stp_req, frame_index);
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION);
break;
}
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct scic_sds_controller *scic = sci_req->owning_controller;
sci_base_state_machine_change_state(
&stp_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
frame_index,
(void **)&frame_header);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
stp_req->parent.owning_controller, frame_index);
} else
if (status != SCI_SUCCESS) {
dev_err(scic_to_dev(sci_req->owning_controller),
"%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:
scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(&stp_req->d2h_reg_fis,
frame_header,
frame_buffer);
/* The command has completed with error */
scic_sds_request_set_status(sci_req, SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
break;
default:
dev_warn(scic_to_dev(scic),
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n", __func__, stp_req,
frame_index);
scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION);
break;
}
sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(scic, frame_index);
return status;
}
......@@ -599,8 +594,7 @@ static const struct sci_base_state scic_sds_stp_request_started_non_data_substat
enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request *sci_req)
{
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
scic_sds_stp_non_ncq_request_construct(sci_req);
......@@ -617,36 +611,28 @@ enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request
#define SCU_MAX_FRAME_BUFFER_SIZE 0x400 /* 1K is the maximum SCU frame data payload */
/**
*
* @sci_req:
* @length:
*
* This function will transmit DATA_FIS from (current sgl + offset) for input
/* transmit DATA_FIS from (current sgl + offset) for input
* parameter length. current sgl and offset is alreay stored in the IO request
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
struct scic_sds_request *sci_req,
u32 length)
{
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_controller *scic = sci_req->owning_controller;
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct scu_task_context *task_context;
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 */
struct scu_task_context *task_context = scic_sds_controller_get_task_context_buffer(
sci_req->owning_controller,
sci_req->io_tag
);
/* Recycle the TC and reconstruct it for sending out DATA FIS containing
* for the data from current_sgl+offset for the input length
*/
task_context = scic_sds_controller_get_task_context_buffer(scic,
sci_req->io_tag);
if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
current_sgl = &stp_req->type.pio.request_current.sgl_pair->A;
else
current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
current_sgl = &stp_req->type.pio.request_current.sgl_pair->B;
/* update the TC */
task_context->command_iu_upper = current_sgl->address_upper;
......@@ -658,23 +644,14 @@ static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
return scic_controller_continue_io(sci_req);
}
/**
*
* @sci_req:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(
struct scic_sds_request *sci_req)
static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(struct scic_sds_request *sci_req)
{
struct scu_sgl_element *current_sgl;
u32 sgl_offset;
u32 remaining_bytes_in_current_sgl = 0;
enum sci_status status = SCI_SUCCESS;
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
sgl_offset = stp_req->type.pio.request_current.sgl_offset;
......@@ -740,7 +717,7 @@ scic_sds_stp_request_pio_data_in_copy_data_buffer(struct scic_sds_stp_request *s
void *kaddr;
int total_len = len;
sci_req = &stp_req->parent;
sci_req = to_sci_req(stp_req);
ireq = scic_sds_request_get_user_request(sci_req);
task = isci_request_access_task(ireq);
src_addr = data_buf;
......@@ -846,234 +823,184 @@ static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completi
return status;
}
/**
*
* @sci_req:
* @frame_index:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
struct scic_sds_request *sci_req,
u32 frame_index)
static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
struct dev_to_host_fis *frame_header;
u32 *frame_buffer;
struct scic_sds_stp_request *stp_req = container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_controller *scic = sci_req->owning_controller;
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct isci_request *ireq = sci_req->ireq;
struct sas_task *task = isci_request_access_task(ireq);
struct dev_to_host_fis *frame_header;
enum sci_status status;
u32 *frame_buffer;
status = scic_sds_unsolicited_frame_control_get_header(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header);
status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
frame_index,
(void **)&frame_header);
if (status == SCI_SUCCESS) {
switch (frame_header->fis_type) {
case FIS_PIO_SETUP:
/* Get from the frame buffer the PIO Setup Data */
scic_sds_unsolicited_frame_control_get_buffer(
&(stp_req->parent.owning_controller->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
*/
if (status != SCI_SUCCESS) {
dev_err(scic_to_dev(scic),
"%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 */
scic_sds_unsolicited_frame_control_get_buffer(&scic->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->type.pio.pio_transfer_bytes =
frame_buffer[3] & 0xffff;
/* transfer_count: first 16bits in the 4th dword */
stp_req->type.pio.pio_transfer_bytes = frame_buffer[3] & 0xffff;
/* ending_status: 4th byte in the 3rd dword */
stp_req->type.pio.ending_status =
(frame_buffer[2] >> 24) & 0xff;
/* ending_status: 4th byte in the 3rd dword */
stp_req->type.pio.ending_status = (frame_buffer[2] >> 24) & 0xff;
scic_sds_controller_copy_sata_response(
&stp_req->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer);
scic_sds_controller_copy_sata_response(&stp_req->d2h_reg_fis,
frame_header,
frame_buffer);
stp_req->d2h_reg_fis.status =
stp_req->type.pio.ending_status;
stp_req->d2h_reg_fis.status = stp_req->type.pio.ending_status;
/* The next state is dependent on whether the
* request was PIO Data-in or Data out
/* The next state is dependent on whether the
* request was PIO Data-in or Data out
*/
if (task->data_dir == DMA_FROM_DEVICE) {
sci_base_state_machine_change_state(&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE);
} else if (task->data_dir == DMA_TO_DEVICE) {
/* Transmit data */
status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
if (status != SCI_SUCCESS)
break;
sci_base_state_machine_change_state(&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE);
}
break;
case FIS_SETDEVBITS:
sci_base_state_machine_change_state(&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
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.
*/
if (task->data_dir == DMA_FROM_DEVICE) {
sci_base_state_machine_change_state(
&stp_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE);
} else if (task->data_dir == DMA_TO_DEVICE) {
/* Transmit data */
status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
if (status == SCI_SUCCESS) {
sci_base_state_machine_change_state(
&stp_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE);
}
}
dev_dbg(scic_to_dev(scic),
"%s: SCIC PIO Request 0x%p received "
"D2H Register FIS with BSY status "
"0x%x\n", __func__, stp_req,
frame_header->status);
break;
}
case FIS_SETDEVBITS:
sci_base_state_machine_change_state(
&stp_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
break;
scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
frame_index,
(void **)&frame_buffer);
case FIS_REGD2H:
if ((frame_header->status & ATA_BUSY) == 0) {
scic_sds_unsolicited_frame_control_get_buffer(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(
&stp_req->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer);
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
sci_base_state_machine_change_state(
&stp_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
} else {
/* 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(scic_to_dev(sci_req->owning_controller),
"%s: SCIC PIO Request 0x%p received "
"D2H Register FIS with BSY status "
"0x%x\n",
__func__,
stp_req,
frame_header->status);
}
break;
scic_sds_controller_copy_sata_response(&stp_req->d2h_reg_fis,
frame_header,
frame_buffer);
default:
/* FIXME: what do we do here? */
break;
}
scic_sds_request_set_status(sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
stp_req->parent.owning_controller,
frame_index);
} else
dev_err(scic_to_dev(sci_req->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
__func__, stp_req, frame_index, status);
sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
break;
default:
/* FIXME: what do we do here? */
break;
}
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(scic, frame_index);
return status;
}
/**
*
* @sci_req:
* @frame_index:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler(
struct scic_sds_request *sci_req,
u32 frame_index)
static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler(struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
struct dev_to_host_fis *frame_header;
struct sata_fis_data *frame_buffer;
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct scic_sds_controller *scic = sci_req->owning_controller;
status = scic_sds_unsolicited_frame_control_get_header(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header);
status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
frame_index,
(void **)&frame_header);
if (status == SCI_SUCCESS) {
if (frame_header->fis_type == FIS_DATA) {
if (stp_req->type.pio.request_current.sgl_pair ==
NULL) {
stp_req->parent.saved_rx_frame_index =
frame_index;
stp_req->type.pio.pio_transfer_bytes = 0;
} else {
status = scic_sds_unsolicited_frame_control_get_buffer(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer);
status = scic_sds_stp_request_pio_data_in_copy_data(
stp_req,
(u8 *)frame_buffer);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
stp_req->parent.owning_controller,
frame_index);
}
if (status != SCI_SUCCESS) {
dev_err(scic_to_dev(scic),
"%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;
}
/*
* Check for the end of the transfer, are there more
* bytes remaining for this data transfer
*/
if ((status == SCI_SUCCESS) &&
(stp_req->type.pio.pio_transfer_bytes == 0)) {
if ((stp_req->type.pio.ending_status &
ATA_BUSY) == 0) {
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
sci_base_state_machine_change_state(
&stp_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
} else {
sci_base_state_machine_change_state(
&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
}
}
if (frame_header->fis_type == FIS_DATA) {
if (stp_req->type.pio.request_current.sgl_pair == NULL) {
sci_req->saved_rx_frame_index = frame_index;
stp_req->type.pio.pio_transfer_bytes = 0;
} else {
dev_err(scic_to_dev(sci_req->owning_controller),
"%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);
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_GOOD,
SCI_FAILURE_IO_REQUIRES_SCSI_ABORT);
scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
frame_index,
(void **)&frame_buffer);
sci_base_state_machine_change_state(
&stp_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
status = scic_sds_stp_request_pio_data_in_copy_data(stp_req,
(u8 *)frame_buffer);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(
stp_req->parent.owning_controller,
frame_index);
scic_sds_controller_release_frame(scic, frame_index);
}
} else
dev_err(scic_to_dev(sci_req->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
__func__, stp_req, frame_index, status);
/* Check for the end of the transfer, are there more
* bytes remaining for this data transfer
*/
if (status != SCI_SUCCESS ||
stp_req->type.pio.pio_transfer_bytes != 0)
return status;
if ((stp_req->type.pio.ending_status & ATA_BUSY) == 0) {
scic_sds_request_set_status(sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
} else {
sci_base_state_machine_change_state(&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
}
} else {
dev_err(scic_to_dev(scic),
"%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);
scic_sds_request_set_status(sci_req,
SCU_TASK_DONE_GOOD,
SCI_FAILURE_IO_REQUIRES_SCSI_ABORT);
sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
/* Frame is decoded return it to the controller */
scic_sds_controller_release_frame(scic, frame_index);
}
return status;
}
......@@ -1093,8 +1020,7 @@ static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_com
{
enum sci_status status = SCI_SUCCESS;
bool all_frames_transferred = false;
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
......@@ -1280,8 +1206,7 @@ enum sci_status
scic_sds_stp_pio_request_construct(struct scic_sds_request *sci_req,
bool copy_rx_frame)
{
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct scic_sds_stp_pio_request *pio = &stp_req->type.pio;
scic_sds_stp_non_ncq_request_construct(sci_req);
......@@ -1325,91 +1250,66 @@ static void scic_sds_stp_request_udma_complete_request(
SCI_BASE_REQUEST_STATE_COMPLETED);
}
/**
*
* @sci_req:
* @frame_index:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
struct scic_sds_request *sci_req,
u32 frame_index)
static enum sci_status scic_sds_stp_request_udma_general_frame_handler(struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
struct scic_sds_controller *scic = sci_req->owning_controller;
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct dev_to_host_fis *frame_header;
enum sci_status status;
u32 *frame_buffer;
status = scic_sds_unsolicited_frame_control_get_header(
&sci_req->owning_controller->uf_control,
frame_index,
(void **)&frame_header);
status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
frame_index,
(void **)&frame_header);
if ((status == SCI_SUCCESS) &&
(frame_header->fis_type == FIS_REGD2H)) {
scic_sds_unsolicited_frame_control_get_buffer(
&sci_req->owning_controller->uf_control,
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(
&((struct scic_sds_stp_request *)sci_req)->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer);
scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(&stp_req->d2h_reg_fis,
frame_header,
frame_buffer);
}
scic_sds_controller_release_frame(
sci_req->owning_controller, frame_index);
scic_sds_controller_release_frame(scic, frame_index);
return status;
}
/**
* This method process TC completions while in the state where we are waiting
* for TC completions.
* @sci_req:
* @completion_code:
*
* enum sci_status
*/
static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler(
struct scic_sds_request *request,
struct scic_sds_request *sci_req,
u32 completion_code)
{
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
enum sci_status status = SCI_SUCCESS;
struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
scic_sds_stp_request_udma_complete_request(
&sci_req->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
);
scic_sds_stp_request_udma_complete_request(sci_req,
SCU_TASK_DONE_GOOD,
SCI_SUCCESS);
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 (sci_req->d2h_reg_fis.fis_type == FIS_REGD2H) {
scic_sds_remote_device_suspend(
sci_req->parent.target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
);
if (stp_req->d2h_reg_fis.fis_type == FIS_REGD2H) {
scic_sds_remote_device_suspend(sci_req->target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
scic_sds_stp_request_udma_complete_request(
&sci_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
scic_sds_stp_request_udma_complete_request(sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
} 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_base_state_machine_change_state(
&sci_req->parent.started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
);
sci_base_state_machine_change_state(&sci_req->started_substate_machine,
SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE);
}
break;
......@@ -1422,18 +1322,14 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_R_ERR):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
scic_sds_remote_device_suspend(
sci_req->parent.target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
);
scic_sds_remote_device_suspend(sci_req->target_device,
SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
/* Fall through to the default case */
default:
/* All other completion status cause the IO to be complete. */
scic_sds_stp_request_udma_complete_request(
&sci_req->parent,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
);
scic_sds_stp_request_udma_complete_request(sci_req,
SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
break;
}
......@@ -1449,13 +1345,12 @@ static enum sci_status scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler
/* Use the general frame handler to copy the resposne data */
status = scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
if (status == SCI_SUCCESS) {
scic_sds_stp_request_udma_complete_request(
sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID
);
}
if (status != SCI_SUCCESS)
return status;
scic_sds_stp_request_udma_complete_request(sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
return status;
}
......@@ -1636,67 +1531,58 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_c
* if the received frame was processed successfully.
*/
static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
struct scic_sds_request *request,
struct scic_sds_request *sci_req,
u32 frame_index)
{
enum sci_status status;
struct dev_to_host_fis *frame_header;
u32 *frame_buffer;
struct scic_sds_stp_request *stp_req =
(struct scic_sds_stp_request *)request;
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
struct scic_sds_controller *scic = sci_req->owning_controller;
status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
frame_index,
(void **)&frame_header);
if (status != SCI_SUCCESS) {
dev_err(scic_to_dev(scic),
"%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;
}
status = scic_sds_unsolicited_frame_control_get_header(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_header);
switch (frame_header->fis_type) {
case FIS_REGD2H:
scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
frame_index,
(void **)&frame_buffer);
if (status == SCI_SUCCESS) {
switch (frame_header->fis_type) {
case FIS_REGD2H:
scic_sds_unsolicited_frame_control_get_buffer(
&(stp_req->parent.owning_controller->uf_control),
frame_index,
(void **)&frame_buffer);
scic_sds_controller_copy_sata_response(
&stp_req->d2h_reg_fis,
(u32 *)frame_header,
frame_buffer);
/* The command has completed with error */
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
break;
scic_sds_controller_copy_sata_response(&stp_req->d2h_reg_fis,
frame_header,
frame_buffer);
default:
dev_warn(scic_to_dev(request->owning_controller),
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n",
__func__,
stp_req,
frame_index);
scic_sds_request_set_status(
&stp_req->parent,
SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION);
break;
}
/* The command has completed with error */
scic_sds_request_set_status(sci_req,
SCU_TASK_DONE_CHECK_RESPONSE,
SCI_FAILURE_IO_RESPONSE_VALID);
break;
sci_base_state_machine_change_state(
&stp_req->parent.state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
default:
dev_warn(scic_to_dev(scic),
"%s: IO Request:0x%p Frame Id:%d protocol "
"violation occurred\n", __func__, stp_req,
frame_index);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(
stp_req->parent.owning_controller, frame_index);
} else
dev_err(scic_to_dev(request->owning_controller),
"%s: SCIC IO Request 0x%p could not get frame header "
"for frame index %d, status %x\n",
__func__, stp_req, frame_index, status);
scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
SCI_FAILURE_PROTOCOL_VIOLATION);
break;
}
sci_base_state_machine_change_state(&sci_req->state_machine,
SCI_BASE_REQUEST_STATE_COMPLETED);
/* Frame has been decoded return it to the controller */
scic_sds_controller_release_frame(scic, frame_index);
return status;
}
......@@ -1787,8 +1673,7 @@ static const struct sci_base_state scic_sds_stp_request_started_soft_reset_subst
enum sci_status scic_sds_stp_soft_reset_request_construct(struct scic_sds_request *sci_req)
{
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
scic_sds_stp_non_ncq_request_construct(sci_req);
......
drivers/scsi/isci/core/scic_sds_stp_request.h
View file @ 827a84d4
......@@ -58,17 +58,8 @@
#include <linux/dma-mapping.h>
#include <scsi/sas.h>
#include "scic_sds_request.h"
/**
* This structure represents the additional information that is required to
* handle SATA PIO requests.
*
*
*/
struct scic_sds_stp_request {
struct scic_sds_request parent;
struct dev_to_host_fis d2h_reg_fis;
union {
......@@ -125,7 +116,6 @@ struct scic_sds_stp_request {
u32 device_preferred_cdb_length;
} packet;
} type;
};
/**
......
drivers/scsi/isci/task.c
View file @ 827a84d4
......@@ -64,7 +64,7 @@
#include "request.h"
#include "sata.h"
#include "task.h"
#include "scic_sds_stp_request.h"
#include "scic_sds_request.h"
/**
* isci_task_refuse() - complete the request to the upper layer driver in
......@@ -1435,8 +1435,7 @@ isci_task_request_complete(struct isci_host *ihost,
struct isci_tmf *tmf = isci_request_access_tmf(ireq);
struct completion *tmf_complete;
struct scic_sds_request *sci_req = ireq->sci_request_handle;
struct scic_sds_stp_request *stp_req =
container_of(sci_req, typeof(*stp_req), parent);
struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
dev_dbg(&ihost->pdev->dev,
"%s: request = %p, status=%d\n",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7