aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@infradead.org>2011-03-28 09:21:14 -0400
committerDan Williams <dan.j.williams@intel.com>2011-07-03 07:00:37 -0400
commit38aa74eb704c5886a5ded4085acd5f2895ab3511 (patch)
treeb016de0ed6e72957a630b7c822d5d93ff5aad982 /drivers/scsi
parentca841f0e862bccd61f537b76c94579c1bd391448 (diff)
isci: remove base_request abstraction
Merge struct sci_base_request into scic_sds_request, and also factor the two types of state machine handlers into one function. While we're at it also remove lots of duplicate incorrect kerneldoc comments for the state machine handlers. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Diffstat (limited to 'drivers/scsi')
-rw-r--r--drivers/scsi/isci/core/sci_base_remote_device.h6
-rw-r--r--drivers/scsi/isci/core/sci_base_request.h195
-rw-r--r--drivers/scsi/isci/core/scic_sds_controller.c68
-rw-r--r--drivers/scsi/isci/core/scic_sds_controller.h5
-rw-r--r--drivers/scsi/isci/core/scic_sds_port.c30
-rw-r--r--drivers/scsi/isci/core/scic_sds_remote_device.c99
-rw-r--r--drivers/scsi/isci/core/scic_sds_remote_device.h7
-rw-r--r--drivers/scsi/isci/core/scic_sds_request.c402
-rw-r--r--drivers/scsi/isci/core/scic_sds_request.h122
-rw-r--r--drivers/scsi/isci/core/scic_sds_smp_remote_device.c23
-rw-r--r--drivers/scsi/isci/core/scic_sds_smp_request.c63
-rw-r--r--drivers/scsi/isci/core/scic_sds_ssp_request.c69
-rw-r--r--drivers/scsi/isci/core/scic_sds_stp_packet_request.c12
-rw-r--r--drivers/scsi/isci/core/scic_sds_stp_remote_device.c173
-rw-r--r--drivers/scsi/isci/core/scic_sds_stp_request.c218
15 files changed, 551 insertions, 941 deletions
diff --git a/drivers/scsi/isci/core/sci_base_remote_device.h b/drivers/scsi/isci/core/sci_base_remote_device.h
index 45414ce6a2c6..5db5f31336fc 100644
--- a/drivers/scsi/isci/core/sci_base_remote_device.h
+++ b/drivers/scsi/isci/core/sci_base_remote_device.h
@@ -65,7 +65,7 @@
65 65
66#include "sci_base_state_machine.h" 66#include "sci_base_state_machine.h"
67 67
68struct sci_base_request; 68struct scic_sds_request;
69 69
70/** 70/**
71 * enum sci_base_remote_device_states - This enumeration depicts all the states 71 * enum sci_base_remote_device_states - This enumeration depicts all the states
@@ -159,12 +159,12 @@ typedef enum sci_status (*sci_base_remote_device_handler_t)(
159 159
160typedef enum sci_status (*sci_base_remote_device_request_handler_t)( 160typedef enum sci_status (*sci_base_remote_device_request_handler_t)(
161 struct sci_base_remote_device *, 161 struct sci_base_remote_device *,
162 struct sci_base_request * 162 struct scic_sds_request *
163 ); 163 );
164 164
165typedef enum sci_status (*sci_base_remote_device_high_priority_request_complete_handler_t)( 165typedef enum sci_status (*sci_base_remote_device_high_priority_request_complete_handler_t)(
166 struct sci_base_remote_device *, 166 struct sci_base_remote_device *,
167 struct sci_base_request *, 167 struct scic_sds_request *,
168 void *, 168 void *,
169 enum sci_io_status 169 enum sci_io_status
170 ); 170 );
diff --git a/drivers/scsi/isci/core/sci_base_request.h b/drivers/scsi/isci/core/sci_base_request.h
deleted file mode 100644
index 223aa4c5f757..000000000000
--- a/drivers/scsi/isci/core/sci_base_request.h
+++ /dev/null
@@ -1,195 +0,0 @@
1/*
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.
4 *
5 * GPL LICENSE SUMMARY
6 *
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8 *
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
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
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
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
22 * in the file called LICENSE.GPL.
23 *
24 * BSD LICENSE
25 *
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
28 *
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
31 * are met:
32 *
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
38 * distribution.
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55
56#ifndef _SCI_BASE_REQUST_H_
57#define _SCI_BASE_REQUST_H_
58
59/**
60 * This file contains all of the constants, types, and method declarations for
61 * the SCI base IO and task request objects.
62 *
63 *
64 */
65
66#include "sci_base_state_machine.h"
67
68/**
69 * enum sci_base_request_states - This enumeration depicts all the states for
70 * the common request state machine.
71 *
72 *
73 */
74enum sci_base_request_states {
75 /**
76 * Simply the initial state for the base request state machine.
77 */
78 SCI_BASE_REQUEST_STATE_INITIAL,
79
80 /**
81 * This state indicates that the request has been constructed. This state
82 * is entered from the INITIAL state.
83 */
84 SCI_BASE_REQUEST_STATE_CONSTRUCTED,
85
86 /**
87 * This state indicates that the request has been started. This state is
88 * entered from the CONSTRUCTED state.
89 */
90 SCI_BASE_REQUEST_STATE_STARTED,
91
92 /**
93 * This state indicates that the request has completed.
94 * This state is entered from the STARTED state. This state is entered from
95 * the ABORTING state.
96 */
97 SCI_BASE_REQUEST_STATE_COMPLETED,
98
99 /**
100 * This state indicates that the request is in the process of being
101 * terminated/aborted.
102 * This state is entered from the CONSTRUCTED state.
103 * This state is entered from the STARTED state.
104 */
105 SCI_BASE_REQUEST_STATE_ABORTING,
106
107 /**
108 * Simply the final state for the base request state machine.
109 */
110 SCI_BASE_REQUEST_STATE_FINAL,
111};
112
113/**
114 * struct sci_base_request - The base request object abstracts the fields
115 * common to all SCI IO and task request objects.
116 *
117 *
118 */
119struct sci_base_request {
120 /**
121 * The field specifies that the parent object for the base request is the
122 * base object itself.
123 */
124 struct sci_base_object parent;
125
126 /**
127 * This field contains the information for the base request state machine.
128 */
129 struct sci_base_state_machine state_machine;
130};
131
132typedef enum sci_status (*sci_base_request_handler_t)(
133 struct sci_base_request *this_request
134 );
135
136/**
137 * struct sci_base_request_state_handler - This structure contains all of the
138 * state handler methods common to base IO and task request state machines.
139 * Handler methods provide the ability to change the behavior for user
140 * requests or transitions depending on the state the machine is in.
141 *
142 *
143 */
144struct sci_base_request_state_handler {
145 /**
146 * The start_handler specifies the method invoked when a user attempts to
147 * start a request.
148 */
149 sci_base_request_handler_t start_handler;
150
151 /**
152 * The abort_handler specifies the method invoked when a user attempts to
153 * abort a request.
154 */
155 sci_base_request_handler_t abort_handler;
156
157 /**
158 * The complete_handler specifies the method invoked when a user attempts to
159 * complete a request.
160 */
161 sci_base_request_handler_t complete_handler;
162
163 /**
164 * The destruct_handler specifies the method invoked when a user attempts to
165 * destruct a request.
166 */
167 sci_base_request_handler_t destruct_handler;
168
169};
170
171/**
172 * sci_base_request_construct() - Construct the base request.
173 * @this_request: This parameter specifies the base request to be constructed.
174 * @state_table: This parameter specifies the table of state definitions to be
175 * utilized for the request state machine.
176 *
177 */
178static inline void sci_base_request_construct(
179 struct sci_base_request *base_req,
180 const struct sci_base_state *my_state_table)
181{
182 base_req->parent.private = NULL;
183 sci_base_state_machine_construct(
184 &base_req->state_machine,
185 &base_req->parent,
186 my_state_table,
187 SCI_BASE_REQUEST_STATE_INITIAL
188 );
189
190 sci_base_state_machine_start(
191 &base_req->state_machine
192 );
193}
194
195#endif /* _SCI_BASE_REQUST_H_ */
diff --git a/drivers/scsi/isci/core/scic_sds_controller.c b/drivers/scsi/isci/core/scic_sds_controller.c
index e7790bb7dfdd..7ead6f381550 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.c
+++ b/drivers/scsi/isci/core/scic_sds_controller.c
@@ -2161,7 +2161,7 @@ enum sci_status scic_controller_reset(
2161enum sci_io_status scic_controller_start_io( 2161enum sci_io_status scic_controller_start_io(
2162 struct scic_sds_controller *scic, 2162 struct scic_sds_controller *scic,
2163 struct scic_sds_remote_device *remote_device, 2163 struct scic_sds_remote_device *remote_device,
2164 struct scic_sds_request *io_request, 2164 struct scic_sds_request *request,
2165 u16 io_tag) 2165 u16 io_tag)
2166{ 2166{
2167 u32 state; 2167 u32 state;
@@ -2172,7 +2172,7 @@ enum sci_io_status scic_controller_start_io(
2172 2172
2173 return start_io(scic, 2173 return start_io(scic,
2174 (struct sci_base_remote_device *) remote_device, 2174 (struct sci_base_remote_device *) remote_device,
2175 (struct sci_base_request *)io_request, io_tag); 2175 request, io_tag);
2176} 2176}
2177 2177
2178/** 2178/**
@@ -2204,7 +2204,7 @@ enum sci_status scic_controller_terminate_request(
2204 2204
2205 return terminate_request(scic, 2205 return terminate_request(scic,
2206 (struct sci_base_remote_device *)remote_device, 2206 (struct sci_base_remote_device *)remote_device,
2207 (struct sci_base_request *)request); 2207 request);
2208} 2208}
2209 2209
2210/** 2210/**
@@ -2232,7 +2232,7 @@ enum sci_status scic_controller_terminate_request(
2232enum sci_status scic_controller_complete_io( 2232enum sci_status scic_controller_complete_io(
2233 struct scic_sds_controller *scic, 2233 struct scic_sds_controller *scic,
2234 struct scic_sds_remote_device *remote_device, 2234 struct scic_sds_remote_device *remote_device,
2235 struct scic_sds_request *io_request) 2235 struct scic_sds_request *request)
2236{ 2236{
2237 u32 state; 2237 u32 state;
2238 scic_sds_controller_request_handler_t complete_io; 2238 scic_sds_controller_request_handler_t complete_io;
@@ -2242,7 +2242,7 @@ enum sci_status scic_controller_complete_io(
2242 2242
2243 return complete_io(scic, 2243 return complete_io(scic,
2244 (struct sci_base_remote_device *)remote_device, 2244 (struct sci_base_remote_device *)remote_device,
2245 (struct sci_base_request *)io_request); 2245 request);
2246} 2246}
2247 2247
2248/** 2248/**
@@ -2289,7 +2289,7 @@ enum sci_task_status scic_controller_start_task(
2289 if (start_task) 2289 if (start_task)
2290 status = start_task(scic, 2290 status = start_task(scic,
2291 (struct sci_base_remote_device *)remote_device, 2291 (struct sci_base_remote_device *)remote_device,
2292 (struct sci_base_request *)task_request, 2292 task_request,
2293 task_tag); 2293 task_tag);
2294 else 2294 else
2295 dev_warn(scic_to_dev(scic), 2295 dev_warn(scic_to_dev(scic),
@@ -2329,7 +2329,7 @@ enum sci_status scic_controller_complete_task(
2329 if (complete_task) 2329 if (complete_task)
2330 status = complete_task(scic, 2330 status = complete_task(scic,
2331 (struct sci_base_remote_device *)remote_device, 2331 (struct sci_base_remote_device *)remote_device,
2332 (struct sci_base_request *)task_request); 2332 task_request);
2333 else 2333 else
2334 dev_warn(scic_to_dev(scic), 2334 dev_warn(scic_to_dev(scic),
2335 "%s: SCIC Controller completing task from invalid " 2335 "%s: SCIC Controller completing task from invalid "
@@ -2825,7 +2825,7 @@ default_controller_handler(struct scic_sds_controller *scic, const char *func)
2825static enum sci_status scic_sds_controller_default_start_operation_handler( 2825static enum sci_status scic_sds_controller_default_start_operation_handler(
2826 struct scic_sds_controller *scic, 2826 struct scic_sds_controller *scic,
2827 struct sci_base_remote_device *remote_device, 2827 struct sci_base_remote_device *remote_device,
2828 struct sci_base_request *io_request, 2828 struct scic_sds_request *request,
2829 u16 io_tag) 2829 u16 io_tag)
2830{ 2830{
2831 return default_controller_handler(scic, __func__); 2831 return default_controller_handler(scic, __func__);
@@ -2834,7 +2834,7 @@ static enum sci_status scic_sds_controller_default_start_operation_handler(
2834static enum sci_status scic_sds_controller_default_request_handler( 2834static enum sci_status scic_sds_controller_default_request_handler(
2835 struct scic_sds_controller *scic, 2835 struct scic_sds_controller *scic,
2836 struct sci_base_remote_device *remote_device, 2836 struct sci_base_remote_device *remote_device,
2837 struct sci_base_request *io_request) 2837 struct scic_sds_request *request)
2838{ 2838{
2839 return default_controller_handler(scic, __func__); 2839 return default_controller_handler(scic, __func__);
2840} 2840}
@@ -3186,26 +3186,24 @@ static enum sci_status scic_sds_controller_ready_state_stop_handler(
3186static enum sci_status scic_sds_controller_ready_state_start_io_handler( 3186static enum sci_status scic_sds_controller_ready_state_start_io_handler(
3187 struct scic_sds_controller *controller, 3187 struct scic_sds_controller *controller,
3188 struct sci_base_remote_device *remote_device, 3188 struct sci_base_remote_device *remote_device,
3189 struct sci_base_request *io_request, 3189 struct scic_sds_request *request,
3190 u16 io_tag) 3190 u16 io_tag)
3191{ 3191{
3192 enum sci_status status; 3192 enum sci_status status;
3193 3193
3194 struct scic_sds_request *the_request;
3195 struct scic_sds_remote_device *the_device; 3194 struct scic_sds_remote_device *the_device;
3196 3195
3197 the_request = (struct scic_sds_request *)io_request;
3198 the_device = (struct scic_sds_remote_device *)remote_device; 3196 the_device = (struct scic_sds_remote_device *)remote_device;
3199 3197
3200 status = scic_sds_remote_device_start_io(controller, the_device, the_request); 3198 status = scic_sds_remote_device_start_io(controller, the_device, request);
3201 3199
3202 if (status != SCI_SUCCESS) 3200 if (status != SCI_SUCCESS)
3203 return status; 3201 return status;
3204 3202
3205 controller->io_request_table[ 3203 controller->io_request_table[
3206 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3204 scic_sds_io_tag_get_index(request->io_tag)] = request;
3207 scic_sds_controller_post_request(controller, 3205 scic_sds_controller_post_request(controller,
3208 scic_sds_request_get_post_context(the_request)); 3206 scic_sds_request_get_post_context(request));
3209 return SCI_SUCCESS; 3207 return SCI_SUCCESS;
3210} 3208}
3211 3209
@@ -3220,22 +3218,20 @@ static enum sci_status scic_sds_controller_ready_state_start_io_handler(
3220static enum sci_status scic_sds_controller_ready_state_complete_io_handler( 3218static enum sci_status scic_sds_controller_ready_state_complete_io_handler(
3221 struct scic_sds_controller *controller, 3219 struct scic_sds_controller *controller,
3222 struct sci_base_remote_device *remote_device, 3220 struct sci_base_remote_device *remote_device,
3223 struct sci_base_request *io_request) 3221 struct scic_sds_request *request)
3224{ 3222{
3225 u16 index; 3223 u16 index;
3226 enum sci_status status; 3224 enum sci_status status;
3227 struct scic_sds_request *the_request;
3228 struct scic_sds_remote_device *the_device; 3225 struct scic_sds_remote_device *the_device;
3229 3226
3230 the_request = (struct scic_sds_request *)io_request;
3231 the_device = (struct scic_sds_remote_device *)remote_device; 3227 the_device = (struct scic_sds_remote_device *)remote_device;
3232 3228
3233 status = scic_sds_remote_device_complete_io(controller, the_device, 3229 status = scic_sds_remote_device_complete_io(controller, the_device,
3234 the_request); 3230 request);
3235 if (status != SCI_SUCCESS) 3231 if (status != SCI_SUCCESS)
3236 return status; 3232 return status;
3237 3233
3238 index = scic_sds_io_tag_get_index(the_request->io_tag); 3234 index = scic_sds_io_tag_get_index(request->io_tag);
3239 controller->io_request_table[index] = NULL; 3235 controller->io_request_table[index] = NULL;
3240 return SCI_SUCCESS; 3236 return SCI_SUCCESS;
3241} 3237}
@@ -3247,16 +3243,12 @@ static enum sci_status scic_sds_controller_ready_state_complete_io_handler(
3247static enum sci_status scic_sds_controller_ready_state_continue_io_handler( 3243static enum sci_status scic_sds_controller_ready_state_continue_io_handler(
3248 struct scic_sds_controller *controller, 3244 struct scic_sds_controller *controller,
3249 struct sci_base_remote_device *remote_device, 3245 struct sci_base_remote_device *remote_device,
3250 struct sci_base_request *io_request) 3246 struct scic_sds_request *request)
3251{ 3247{
3252 struct scic_sds_request *the_request;
3253
3254 the_request = (struct scic_sds_request *)io_request;
3255
3256 controller->io_request_table[ 3248 controller->io_request_table[
3257 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3249 scic_sds_io_tag_get_index(request->io_tag)] = request;
3258 scic_sds_controller_post_request(controller, 3250 scic_sds_controller_post_request(controller,
3259 scic_sds_request_get_post_context(the_request)); 3251 scic_sds_request_get_post_context(request));
3260 return SCI_SUCCESS; 3252 return SCI_SUCCESS;
3261} 3253}
3262 3254
@@ -3273,27 +3265,25 @@ static enum sci_status scic_sds_controller_ready_state_continue_io_handler(
3273static enum sci_status scic_sds_controller_ready_state_start_task_handler( 3265static enum sci_status scic_sds_controller_ready_state_start_task_handler(
3274 struct scic_sds_controller *controller, 3266 struct scic_sds_controller *controller,
3275 struct sci_base_remote_device *remote_device, 3267 struct sci_base_remote_device *remote_device,
3276 struct sci_base_request *io_request, 3268 struct scic_sds_request *request,
3277 u16 task_tag) 3269 u16 task_tag)
3278{ 3270{
3279 struct scic_sds_request *the_request = (struct scic_sds_request *)
3280 io_request;
3281 struct scic_sds_remote_device *the_device = (struct scic_sds_remote_device *) 3271 struct scic_sds_remote_device *the_device = (struct scic_sds_remote_device *)
3282 remote_device; 3272 remote_device;
3283 enum sci_status status; 3273 enum sci_status status;
3284 3274
3285 status = scic_sds_remote_device_start_task(controller, the_device, 3275 status = scic_sds_remote_device_start_task(controller, the_device,
3286 the_request); 3276 request);
3287 3277
3288 if (status == SCI_SUCCESS) { 3278 if (status == SCI_SUCCESS) {
3289 controller->io_request_table[ 3279 controller->io_request_table[
3290 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3280 scic_sds_io_tag_get_index(request->io_tag)] = request;
3291 3281
3292 scic_sds_controller_post_request(controller, 3282 scic_sds_controller_post_request(controller,
3293 scic_sds_request_get_post_context(the_request)); 3283 scic_sds_request_get_post_context(request));
3294 } else if (status == SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS) { 3284 } else if (status == SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS) {
3295 controller->io_request_table[ 3285 controller->io_request_table[
3296 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3286 scic_sds_io_tag_get_index(request->io_tag)] = request;
3297 3287
3298 /* 3288 /*
3299 * We will let framework know this task request started successfully, 3289 * We will let framework know this task request started successfully,
@@ -3315,13 +3305,11 @@ static enum sci_status scic_sds_controller_ready_state_start_task_handler(
3315static enum sci_status scic_sds_controller_ready_state_terminate_request_handler( 3305static enum sci_status scic_sds_controller_ready_state_terminate_request_handler(
3316 struct scic_sds_controller *controller, 3306 struct scic_sds_controller *controller,
3317 struct sci_base_remote_device *remote_device, 3307 struct sci_base_remote_device *remote_device,
3318 struct sci_base_request *io_request) 3308 struct scic_sds_request *request)
3319{ 3309{
3320 struct scic_sds_request *the_request = (struct scic_sds_request *)
3321 io_request;
3322 enum sci_status status; 3310 enum sci_status status;
3323 3311
3324 status = scic_sds_io_request_terminate(the_request); 3312 status = scic_sds_io_request_terminate(request);
3325 if (status != SCI_SUCCESS) 3313 if (status != SCI_SUCCESS)
3326 return status; 3314 return status;
3327 3315
@@ -3330,7 +3318,7 @@ static enum sci_status scic_sds_controller_ready_state_terminate_request_handler
3330 * request sub-type. 3318 * request sub-type.
3331 */ 3319 */
3332 scic_sds_controller_post_request(controller, 3320 scic_sds_controller_post_request(controller,
3333 scic_sds_request_get_post_context(the_request) | 3321 scic_sds_request_get_post_context(request) |
3334 SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT); 3322 SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT);
3335 return SCI_SUCCESS; 3323 return SCI_SUCCESS;
3336} 3324}
@@ -3391,7 +3379,7 @@ static void scic_sds_controller_ready_state_link_down_handler(
3391static enum sci_status scic_sds_controller_stopping_state_complete_io_handler( 3379static enum sci_status scic_sds_controller_stopping_state_complete_io_handler(
3392 struct scic_sds_controller *controller, 3380 struct scic_sds_controller *controller,
3393 struct sci_base_remote_device *remote_device, 3381 struct sci_base_remote_device *remote_device,
3394 struct sci_base_request *io_request) 3382 struct scic_sds_request *request)
3395{ 3383{
3396 /* XXX: Implement this function */ 3384 /* XXX: Implement this function */
3397 return SCI_FAILURE; 3385 return SCI_FAILURE;
diff --git a/drivers/scsi/isci/core/scic_sds_controller.h b/drivers/scsi/isci/core/scic_sds_controller.h
index f2d7e9c05b17..5cff8066a0ef 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.h
+++ b/drivers/scsi/isci/core/scic_sds_controller.h
@@ -86,7 +86,6 @@
86 86
87struct sci_base_remote_device; 87struct sci_base_remote_device;
88struct scic_sds_remote_device; 88struct scic_sds_remote_device;
89struct sci_base_request;
90struct scic_sds_request; 89struct scic_sds_request;
91struct scic_sds_controller; 90struct scic_sds_controller;
92 91
@@ -487,11 +486,11 @@ typedef enum sci_status (*scic_sds_controller_timed_handler_t)
487typedef enum sci_status (*scic_sds_controller_request_handler_t) 486typedef enum sci_status (*scic_sds_controller_request_handler_t)
488 (struct scic_sds_controller *, 487 (struct scic_sds_controller *,
489 struct sci_base_remote_device *, 488 struct sci_base_remote_device *,
490 struct sci_base_request *); 489 struct scic_sds_request *);
491typedef enum sci_status (*scic_sds_controller_start_request_handler_t) 490typedef enum sci_status (*scic_sds_controller_start_request_handler_t)
492 (struct scic_sds_controller *, 491 (struct scic_sds_controller *,
493 struct sci_base_remote_device *, 492 struct sci_base_remote_device *,
494 struct sci_base_request *, u16); 493 struct scic_sds_request *, u16);
495typedef void (*scic_sds_controller_phy_handler_t) 494typedef void (*scic_sds_controller_phy_handler_t)
496 (struct scic_sds_controller *, 495 (struct scic_sds_controller *,
497 struct scic_sds_port *, 496 struct scic_sds_port *,
diff --git a/drivers/scsi/isci/core/scic_sds_port.c b/drivers/scsi/isci/core/scic_sds_port.c
index 8e3983ebc4dc..ef9cb9eb66f4 100644
--- a/drivers/scsi/isci/core/scic_sds_port.c
+++ b/drivers/scsi/isci/core/scic_sds_port.c
@@ -1090,15 +1090,7 @@ static enum sci_status scic_sds_port_ready_substate_stop_handler(
1090 return SCI_SUCCESS; 1090 return SCI_SUCCESS;
1091} 1091}
1092 1092
1093/** 1093/*
1094 *
1095 * @port: This is the struct sci_base_port object which is cast into a struct scic_sds_port
1096 * object.
1097 * @device: This is the struct sci_base_remote_device object which is not used in this
1098 * function.
1099 * @io_request: This is the struct sci_base_request object which is not used in this
1100 * function.
1101 *
1102 * This method is the general ready substate complete io handler for the 1094 * This method is the general ready substate complete io handler for the
1103 * struct scic_sds_port object. This function decrments the outstanding request count 1095 * struct scic_sds_port object. This function decrments the outstanding request count
1104 * for this port object. enum sci_status SCI_SUCCESS 1096 * for this port object. enum sci_status SCI_SUCCESS
@@ -1194,15 +1186,7 @@ static void scic_sds_port_ready_waiting_substate_link_up_handler(
1194 ); 1186 );
1195} 1187}
1196 1188
1197/** 1189/*
1198 *
1199 * @port: This is the struct sci_base_port object which is cast into a struct scic_sds_port
1200 * object.
1201 * @device: This is the struct sci_base_remote_device object which is not used in this
1202 * request.
1203 * @io_request: This is the struct sci_base_request object which is not used in this
1204 * function.
1205 *
1206 * This method is the ready waiting substate start io handler for the 1190 * This method is the ready waiting substate start io handler for the
1207 * struct scic_sds_port object. The port object can not accept new requests so the 1191 * struct scic_sds_port object. The port object can not accept new requests so the
1208 * request is failed. enum sci_status SCI_FAILURE_INVALID_STATE 1192 * request is failed. enum sci_status SCI_FAILURE_INVALID_STATE
@@ -1316,15 +1300,7 @@ static void scic_sds_port_ready_operational_substate_link_down_handler(
1316 SCIC_SDS_PORT_READY_SUBSTATE_WAITING); 1300 SCIC_SDS_PORT_READY_SUBSTATE_WAITING);
1317} 1301}
1318 1302
1319/** 1303/*
1320 *
1321 * @port: This is the struct sci_base_port object which is cast into a struct scic_sds_port
1322 * object.
1323 * @device: This is the struct sci_base_remote_device object which is not used in this
1324 * function.
1325 * @io_request: This is the struct sci_base_request object which is not used in this
1326 * function.
1327 *
1328 * This method is the ready operational substate start io handler for the 1304 * This method is the ready operational substate start io handler for the
1329 * struct scic_sds_port object. This function incremetns the outstanding request 1305 * struct scic_sds_port object. This function incremetns the outstanding request
1330 * count for this port object. enum sci_status SCI_SUCCESS 1306 * count for this port object. enum sci_status SCI_SUCCESS
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.c b/drivers/scsi/isci/core/scic_sds_remote_device.c
index b4b6be7cdfb9..cb49a33285d9 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.c
@@ -363,7 +363,7 @@ enum sci_status scic_sds_remote_device_start_io(
363 struct scic_sds_request *io_request) 363 struct scic_sds_request *io_request)
364{ 364{
365 return this_device->state_handlers->parent.start_io_handler( 365 return this_device->state_handlers->parent.start_io_handler(
366 &this_device->parent, &io_request->parent); 366 &this_device->parent, io_request);
367} 367}
368 368
369/** 369/**
@@ -381,7 +381,7 @@ enum sci_status scic_sds_remote_device_complete_io(
381 struct scic_sds_request *io_request) 381 struct scic_sds_request *io_request)
382{ 382{
383 return this_device->state_handlers->parent.complete_io_handler( 383 return this_device->state_handlers->parent.complete_io_handler(
384 &this_device->parent, &io_request->parent); 384 &this_device->parent, io_request);
385} 385}
386 386
387/** 387/**
@@ -399,7 +399,7 @@ enum sci_status scic_sds_remote_device_start_task(
399 struct scic_sds_request *io_request) 399 struct scic_sds_request *io_request)
400{ 400{
401 return this_device->state_handlers->parent.start_task_handler( 401 return this_device->state_handlers->parent.start_task_handler(
402 &this_device->parent, &io_request->parent); 402 &this_device->parent, io_request);
403} 403}
404 404
405/** 405/**
@@ -567,7 +567,7 @@ void scic_sds_remote_device_continue_request(void *dev)
567 scic_sds_controller_request_handler_t continue_io; 567 scic_sds_controller_request_handler_t continue_io;
568 568
569 continue_io = scic_sds_controller_state_handler_table[state].continue_io; 569 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
570 continue_io(scic, &sci_req->target_device->parent, &sci_req->parent); 570 continue_io(scic, &sci_req->target_device->parent, sci_req);
571 } 571 }
572} 572}
573 573
@@ -792,21 +792,21 @@ enum sci_status scic_sds_remote_device_default_frame_handler(
792 792
793enum sci_status scic_sds_remote_device_default_start_request_handler( 793enum sci_status scic_sds_remote_device_default_start_request_handler(
794 struct sci_base_remote_device *base_dev, 794 struct sci_base_remote_device *base_dev,
795 struct sci_base_request *request) 795 struct scic_sds_request *request)
796{ 796{
797 return default_device_handler(base_dev, __func__); 797 return default_device_handler(base_dev, __func__);
798} 798}
799 799
800enum sci_status scic_sds_remote_device_default_complete_request_handler( 800enum sci_status scic_sds_remote_device_default_complete_request_handler(
801 struct sci_base_remote_device *base_dev, 801 struct sci_base_remote_device *base_dev,
802 struct sci_base_request *request) 802 struct scic_sds_request *request)
803{ 803{
804 return default_device_handler(base_dev, __func__); 804 return default_device_handler(base_dev, __func__);
805} 805}
806 806
807enum sci_status scic_sds_remote_device_default_continue_request_handler( 807enum sci_status scic_sds_remote_device_default_continue_request_handler(
808 struct sci_base_remote_device *base_dev, 808 struct sci_base_remote_device *base_dev,
809 struct sci_base_request *request) 809 struct scic_sds_request *request)
810{ 810{
811 return default_device_handler(base_dev, __func__); 811 return default_device_handler(base_dev, __func__);
812} 812}
@@ -1019,13 +1019,7 @@ enum sci_status scic_sds_remote_device_ready_state_reset_handler(
1019 return SCI_SUCCESS; 1019 return SCI_SUCCESS;
1020} 1020}
1021 1021
1022/** 1022/*
1023 *
1024 * @device: The struct sci_base_remote_device which is cast to a
1025 * struct scic_sds_remote_device for which the request is to be started.
1026 * @request: The struct sci_base_request which is cast to a SCIC_SDS_IO_REQUEST that
1027 * is to be started.
1028 *
1029 * This method will attempt to start a task request for this device object. The 1023 * This method will attempt to start a task request for this device object. The
1030 * remote device object will issue the start request for the task and if 1024 * remote device object will issue the start request for the task and if
1031 * successful it will start the request for the port object then increment its 1025 * successful it will start the request for the port object then increment its
@@ -1035,38 +1029,28 @@ enum sci_status scic_sds_remote_device_ready_state_reset_handler(
1035 */ 1029 */
1036static enum sci_status scic_sds_remote_device_ready_state_start_task_handler( 1030static enum sci_status scic_sds_remote_device_ready_state_start_task_handler(
1037 struct sci_base_remote_device *device, 1031 struct sci_base_remote_device *device,
1038 struct sci_base_request *request) 1032 struct scic_sds_request *request)
1039{ 1033{
1040 enum sci_status result; 1034 enum sci_status result;
1041 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 1035 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1042 struct scic_sds_request *task_request = (struct scic_sds_request *)request;
1043 1036
1044 /* See if the port is in a state where we can start the IO request */ 1037 /* See if the port is in a state where we can start the IO request */
1045 result = scic_sds_port_start_io( 1038 result = scic_sds_port_start_io(
1046 scic_sds_remote_device_get_port(this_device), this_device, task_request); 1039 scic_sds_remote_device_get_port(this_device), this_device, request);
1047 1040
1048 if (result == SCI_SUCCESS) { 1041 if (result == SCI_SUCCESS) {
1049 result = scic_sds_remote_node_context_start_task( 1042 result = scic_sds_remote_node_context_start_task(
1050 this_device->rnc, task_request 1043 this_device->rnc, request);
1051 ); 1044 if (result == SCI_SUCCESS)
1052 1045 result = scic_sds_request_start(request);
1053 if (result == SCI_SUCCESS) {
1054 result = scic_sds_request_start(task_request);
1055 }
1056 1046
1057 scic_sds_remote_device_start_request(this_device, task_request, result); 1047 scic_sds_remote_device_start_request(this_device, request, result);
1058 } 1048 }
1059 1049
1060 return result; 1050 return result;
1061} 1051}
1062 1052
1063/** 1053/*
1064 *
1065 * @device: The struct sci_base_remote_device which is cast to a
1066 * struct scic_sds_remote_device for which the request is to be started.
1067 * @request: The struct sci_base_request which is cast to a SCIC_SDS_IO_REQUEST that
1068 * is to be started.
1069 *
1070 * This method will attempt to start an io request for this device object. The 1054 * This method will attempt to start an io request for this device object. The
1071 * remote device object will issue the start request for the io and if 1055 * remote device object will issue the start request for the io and if
1072 * successful it will start the request for the port object then increment its 1056 * successful it will start the request for the port object then increment its
@@ -1076,38 +1060,28 @@ static enum sci_status scic_sds_remote_device_ready_state_start_task_handler(
1076 */ 1060 */
1077static enum sci_status scic_sds_remote_device_ready_state_start_io_handler( 1061static enum sci_status scic_sds_remote_device_ready_state_start_io_handler(
1078 struct sci_base_remote_device *device, 1062 struct sci_base_remote_device *device,
1079 struct sci_base_request *request) 1063 struct scic_sds_request *request)
1080{ 1064{
1081 enum sci_status result; 1065 enum sci_status result;
1082 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 1066 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1083 struct scic_sds_request *io_request = (struct scic_sds_request *)request;
1084 1067
1085 /* See if the port is in a state where we can start the IO request */ 1068 /* See if the port is in a state where we can start the IO request */
1086 result = scic_sds_port_start_io( 1069 result = scic_sds_port_start_io(
1087 scic_sds_remote_device_get_port(this_device), this_device, io_request); 1070 scic_sds_remote_device_get_port(this_device), this_device, request);
1088 1071
1089 if (result == SCI_SUCCESS) { 1072 if (result == SCI_SUCCESS) {
1090 result = scic_sds_remote_node_context_start_io( 1073 result = scic_sds_remote_node_context_start_io(
1091 this_device->rnc, io_request 1074 this_device->rnc, request);
1092 ); 1075 if (result == SCI_SUCCESS)
1076 result = scic_sds_request_start(request);
1093 1077
1094 if (result == SCI_SUCCESS) { 1078 scic_sds_remote_device_start_request(this_device, request, result);
1095 result = scic_sds_request_start(io_request);
1096 }
1097
1098 scic_sds_remote_device_start_request(this_device, io_request, result);
1099 } 1079 }
1100 1080
1101 return result; 1081 return result;
1102} 1082}
1103 1083
1104/** 1084/*
1105 *
1106 * @device: The struct sci_base_remote_device which is cast to a
1107 * struct scic_sds_remote_device for which the request is to be completed.
1108 * @request: The struct sci_base_request which is cast to a SCIC_SDS_IO_REQUEST that
1109 * is to be completed.
1110 *
1111 * This method will complete the request for the remote device object. The 1085 * This method will complete the request for the remote device object. The
1112 * method will call the completion handler for the request object and if 1086 * method will call the completion handler for the request object and if
1113 * successful it will complete the request on the port object then decrement 1087 * successful it will complete the request on the port object then decrement
@@ -1115,18 +1089,17 @@ static enum sci_status scic_sds_remote_device_ready_state_start_io_handler(
1115 */ 1089 */
1116static enum sci_status scic_sds_remote_device_ready_state_complete_request_handler( 1090static enum sci_status scic_sds_remote_device_ready_state_complete_request_handler(
1117 struct sci_base_remote_device *device, 1091 struct sci_base_remote_device *device,
1118 struct sci_base_request *request) 1092 struct scic_sds_request *request)
1119{ 1093{
1120 enum sci_status result; 1094 enum sci_status result;
1121 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 1095 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1122 struct scic_sds_request *the_request = (struct scic_sds_request *)request;
1123 1096
1124 result = scic_sds_request_complete(the_request); 1097 result = scic_sds_request_complete(request);
1125 1098
1126 if (result == SCI_SUCCESS) { 1099 if (result == SCI_SUCCESS) {
1127 /* See if the port is in a state where we can start the IO request */ 1100 /* See if the port is in a state where we can start the IO request */
1128 result = scic_sds_port_complete_io( 1101 result = scic_sds_port_complete_io(
1129 scic_sds_remote_device_get_port(this_device), this_device, the_request); 1102 scic_sds_remote_device_get_port(this_device), this_device, request);
1130 1103
1131 if (result == SCI_SUCCESS) { 1104 if (result == SCI_SUCCESS) {
1132 scic_sds_remote_device_decrement_request_count(this_device); 1105 scic_sds_remote_device_decrement_request_count(this_device);
@@ -1178,19 +1151,16 @@ static enum sci_status scic_sds_remote_device_stopping_state_stop_handler(
1178 */ 1151 */
1179static enum sci_status scic_sds_remote_device_stopping_state_complete_request_handler( 1152static enum sci_status scic_sds_remote_device_stopping_state_complete_request_handler(
1180 struct sci_base_remote_device *device, 1153 struct sci_base_remote_device *device,
1181 struct sci_base_request *request) 1154 struct scic_sds_request *request)
1182{ 1155{
1183 enum sci_status status = SCI_SUCCESS; 1156 enum sci_status status = SCI_SUCCESS;
1184 struct scic_sds_request *this_request = (struct scic_sds_request *)request;
1185 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 1157 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1186 1158
1187 status = scic_sds_request_complete(this_request); 1159 status = scic_sds_request_complete(request);
1188 if (status == SCI_SUCCESS) { 1160 if (status == SCI_SUCCESS) {
1189 status = scic_sds_port_complete_io( 1161 status = scic_sds_port_complete_io(
1190 scic_sds_remote_device_get_port(this_device), 1162 scic_sds_remote_device_get_port(this_device),
1191 this_device, 1163 this_device, request);
1192 this_request
1193 );
1194 1164
1195 if (status == SCI_SUCCESS) { 1165 if (status == SCI_SUCCESS) {
1196 scic_sds_remote_device_decrement_request_count(this_device); 1166 scic_sds_remote_device_decrement_request_count(this_device);
@@ -1255,11 +1225,7 @@ static enum sci_status scic_sds_remote_device_resetting_state_stop_handler(
1255 return SCI_SUCCESS; 1225 return SCI_SUCCESS;
1256} 1226}
1257 1227
1258/** 1228/*
1259 *
1260 * @device: The device object for which the request is completing.
1261 * @request: The task request that is being completed.
1262 *
1263 * This method completes requests for this struct scic_sds_remote_device while it is 1229 * This method completes requests for this struct scic_sds_remote_device while it is
1264 * in the SCI_BASE_REMOTE_DEVICE_STATE_RESETTING state. This method calls the 1230 * in the SCI_BASE_REMOTE_DEVICE_STATE_RESETTING state. This method calls the
1265 * complete method for the request object and if that is successful the port 1231 * complete method for the request object and if that is successful the port
@@ -1268,17 +1234,16 @@ static enum sci_status scic_sds_remote_device_resetting_state_stop_handler(
1268 */ 1234 */
1269static enum sci_status scic_sds_remote_device_resetting_state_complete_request_handler( 1235static enum sci_status scic_sds_remote_device_resetting_state_complete_request_handler(
1270 struct sci_base_remote_device *device, 1236 struct sci_base_remote_device *device,
1271 struct sci_base_request *request) 1237 struct scic_sds_request *request)
1272{ 1238{
1273 enum sci_status status = SCI_SUCCESS; 1239 enum sci_status status = SCI_SUCCESS;
1274 struct scic_sds_request *this_request = (struct scic_sds_request *)request;
1275 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 1240 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1276 1241
1277 status = scic_sds_request_complete(this_request); 1242 status = scic_sds_request_complete(request);
1278 1243
1279 if (status == SCI_SUCCESS) { 1244 if (status == SCI_SUCCESS) {
1280 status = scic_sds_port_complete_io( 1245 status = scic_sds_port_complete_io(
1281 scic_sds_remote_device_get_port(this_device), this_device, this_request); 1246 scic_sds_remote_device_get_port(this_device), this_device, request);
1282 1247
1283 if (status == SCI_SUCCESS) { 1248 if (status == SCI_SUCCESS) {
1284 scic_sds_remote_device_decrement_request_count(this_device); 1249 scic_sds_remote_device_decrement_request_count(this_device);
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.h b/drivers/scsi/isci/core/scic_sds_remote_device.h
index 725c0588f2ab..90b231833872 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.h
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.h
@@ -65,7 +65,6 @@
65 65
66#include "intel_sas.h" 66#include "intel_sas.h"
67#include "sci_base_remote_device.h" 67#include "sci_base_remote_device.h"
68#include "sci_base_request.h"
69#include "scu_remote_node_context.h" 68#include "scu_remote_node_context.h"
70#include "scic_sds_remote_node_context.h" 69#include "scic_sds_remote_node_context.h"
71 70
@@ -507,15 +506,15 @@ enum sci_status scic_sds_remote_device_default_reset_complete_handler(
507 506
508enum sci_status scic_sds_remote_device_default_start_request_handler( 507enum sci_status scic_sds_remote_device_default_start_request_handler(
509 struct sci_base_remote_device *device, 508 struct sci_base_remote_device *device,
510 struct sci_base_request *request); 509 struct scic_sds_request *request);
511 510
512enum sci_status scic_sds_remote_device_default_complete_request_handler( 511enum sci_status scic_sds_remote_device_default_complete_request_handler(
513 struct sci_base_remote_device *device, 512 struct sci_base_remote_device *device,
514 struct sci_base_request *request); 513 struct scic_sds_request *request);
515 514
516enum sci_status scic_sds_remote_device_default_continue_request_handler( 515enum sci_status scic_sds_remote_device_default_continue_request_handler(
517 struct sci_base_remote_device *device, 516 struct sci_base_remote_device *device,
518 struct sci_base_request *request); 517 struct scic_sds_request *request);
519 518
520enum sci_status scic_sds_remote_device_default_suspend_handler( 519enum sci_status scic_sds_remote_device_default_suspend_handler(
521 struct scic_sds_remote_device *this_device, 520 struct scic_sds_remote_device *this_device,
diff --git a/drivers/scsi/isci/core/scic_sds_request.c b/drivers/scsi/isci/core/scic_sds_request.c
index d0cbb97b63a7..7c21de0cc3a6 100644
--- a/drivers/scsi/isci/core/scic_sds_request.c
+++ b/drivers/scsi/isci/core/scic_sds_request.c
@@ -57,7 +57,6 @@
57#include "intel_sas.h" 57#include "intel_sas.h"
58#include "intel_sata.h" 58#include "intel_sata.h"
59#include "intel_sat.h" 59#include "intel_sat.h"
60#include "sci_base_request.h"
61#include "scic_controller.h" 60#include "scic_controller.h"
62#include "scic_io_request.h" 61#include "scic_io_request.h"
63#include "scic_remote_device.h" 62#include "scic_remote_device.h"
@@ -728,10 +727,8 @@ enum sci_status scic_io_request_construct_basic_ssp(
728 727
729 scic_sds_io_request_build_ssp_command_iu(sci_req); 728 scic_sds_io_request_build_ssp_command_iu(sci_req);
730 729
731 sci_base_state_machine_change_state( 730 sci_base_state_machine_change_state(&sci_req->state_machine,
732 &sci_req->parent.state_machine, 731 SCI_BASE_REQUEST_STATE_CONSTRUCTED);
733 SCI_BASE_REQUEST_STATE_CONSTRUCTED
734 );
735 732
736 return SCI_SUCCESS; 733 return SCI_SUCCESS;
737} 734}
@@ -746,10 +743,8 @@ enum sci_status scic_task_request_construct_ssp(
746 /* Fill in the SSP Task IU */ 743 /* Fill in the SSP Task IU */
747 scic_sds_task_request_build_ssp_task_iu(sci_req); 744 scic_sds_task_request_build_ssp_task_iu(sci_req);
748 745
749 sci_base_state_machine_change_state( 746 sci_base_state_machine_change_state(&sci_req->state_machine,
750 &sci_req->parent.state_machine, 747 SCI_BASE_REQUEST_STATE_CONSTRUCTED);
751 SCI_BASE_REQUEST_STATE_CONSTRUCTED
752 );
753 748
754 return SCI_SUCCESS; 749 return SCI_SUCCESS;
755} 750}
@@ -780,10 +775,8 @@ enum sci_status scic_io_request_construct_basic_sata(
780 status = scic_io_request_construct_sata(sci_req, proto, len, dir, copy); 775 status = scic_io_request_construct_sata(sci_req, proto, len, dir, copy);
781 776
782 if (status == SCI_SUCCESS) 777 if (status == SCI_SUCCESS)
783 sci_base_state_machine_change_state( 778 sci_base_state_machine_change_state(&sci_req->state_machine,
784 &sci_req->parent.state_machine, 779 SCI_BASE_REQUEST_STATE_CONSTRUCTED);
785 SCI_BASE_REQUEST_STATE_CONSTRUCTED
786 );
787 780
788 return status; 781 return status;
789} 782}
@@ -818,10 +811,8 @@ enum sci_status scic_task_request_construct_sata(
818 } 811 }
819 812
820 if (status == SCI_SUCCESS) 813 if (status == SCI_SUCCESS)
821 sci_base_state_machine_change_state( 814 sci_base_state_machine_change_state(&sci_req->state_machine,
822 &sci_req->parent.state_machine, 815 SCI_BASE_REQUEST_STATE_CONSTRUCTED);
823 SCI_BASE_REQUEST_STATE_CONSTRUCTED
824 );
825 816
826 return status; 817 return status;
827} 818}
@@ -891,18 +882,12 @@ u32 scic_io_request_get_number_of_bytes_transferred(
891 * This method invokes the base state start request handler for the 882 * This method invokes the base state start request handler for the
892 * SCIC_SDS_IO_REQUEST_T object. enum sci_status 883 * SCIC_SDS_IO_REQUEST_T object. enum sci_status
893 */ 884 */
894enum sci_status scic_sds_request_start( 885enum sci_status
895 struct scic_sds_request *this_request) 886scic_sds_request_start(struct scic_sds_request *request)
896{ 887{
897 if ( 888 if (request->device_sequence ==
898 this_request->device_sequence 889 scic_sds_remote_device_get_sequence(request->target_device))
899 == scic_sds_remote_device_get_sequence(this_request->target_device) 890 return request->state_handlers->start_handler(request);
900 ) {
901 return this_request->state_handlers->parent.start_handler(
902 &this_request->parent
903 );
904 }
905
906 return SCI_FAILURE; 891 return SCI_FAILURE;
907} 892}
908 893
@@ -914,11 +899,10 @@ enum sci_status scic_sds_request_start(
914 * This method invokes the base state terminate request handber for the 899 * This method invokes the base state terminate request handber for the
915 * SCIC_SDS_IO_REQUEST_T object. enum sci_status 900 * SCIC_SDS_IO_REQUEST_T object. enum sci_status
916 */ 901 */
917enum sci_status scic_sds_io_request_terminate( 902enum sci_status
918 struct scic_sds_request *this_request) 903scic_sds_io_request_terminate(struct scic_sds_request *request)
919{ 904{
920 return this_request->state_handlers->parent.abort_handler( 905 return request->state_handlers->abort_handler(request);
921 &this_request->parent);
922} 906}
923 907
924/** 908/**
@@ -929,11 +913,10 @@ enum sci_status scic_sds_io_request_terminate(
929 * This method invokes the base state request completion handler for the 913 * This method invokes the base state request completion handler for the
930 * SCIC_SDS_IO_REQUEST_T object. enum sci_status 914 * SCIC_SDS_IO_REQUEST_T object. enum sci_status
931 */ 915 */
932enum sci_status scic_sds_io_request_complete( 916enum sci_status
933 struct scic_sds_request *this_request) 917scic_sds_io_request_complete(struct scic_sds_request *request)
934{ 918{
935 return this_request->state_handlers->parent.complete_handler( 919 return request->state_handlers->complete_handler(request);
936 &this_request->parent);
937} 920}
938 921
939/** 922/**
@@ -1023,175 +1006,132 @@ void scic_sds_io_request_copy_response(struct scic_sds_request *sds_request)
1023 * * DEFAULT STATE HANDLERS 1006 * * DEFAULT STATE HANDLERS
1024 * ***************************************************************************** */ 1007 * ***************************************************************************** */
1025 1008
1026/** 1009/*
1027 * scic_sds_request_default_start_handler() -
1028 * @request: This is the struct sci_base_request object that is cast to the
1029 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1030 *
1031 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1010 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1032 * object receives a scic_sds_request_start() request. The default action is 1011 * object receives a scic_sds_request_start() request. The default action is
1033 * to log a warning and return a failure status. enum sci_status 1012 * to log a warning and return a failure status. enum sci_status
1034 * SCI_FAILURE_INVALID_STATE 1013 * SCI_FAILURE_INVALID_STATE
1035 */ 1014 */
1036enum sci_status scic_sds_request_default_start_handler( 1015enum sci_status scic_sds_request_default_start_handler(
1037 struct sci_base_request *request) 1016 struct scic_sds_request *request)
1038{ 1017{
1039 struct scic_sds_request *scic_request = 1018 dev_warn(scic_to_dev(request->owning_controller),
1040 (struct scic_sds_request *)request;
1041
1042 dev_warn(scic_to_dev(scic_request->owning_controller),
1043 "%s: SCIC IO Request requested to start while in wrong " 1019 "%s: SCIC IO Request requested to start while in wrong "
1044 "state %d\n", 1020 "state %d\n",
1045 __func__, 1021 __func__,
1046 sci_base_state_machine_get_state( 1022 sci_base_state_machine_get_state(&request->state_machine));
1047 &((struct scic_sds_request *)request)->parent.state_machine));
1048 1023
1049 return SCI_FAILURE_INVALID_STATE; 1024 return SCI_FAILURE_INVALID_STATE;
1050} 1025}
1051 1026
1052static enum sci_status scic_sds_request_default_abort_handler( 1027static enum sci_status scic_sds_request_default_abort_handler(
1053 struct sci_base_request *request) 1028 struct scic_sds_request *request)
1054{ 1029{
1055 struct scic_sds_request *scic_request = 1030 dev_warn(scic_to_dev(request->owning_controller),
1056 (struct scic_sds_request *)request;
1057
1058 dev_warn(scic_to_dev(scic_request->owning_controller),
1059 "%s: SCIC IO Request requested to abort while in wrong " 1031 "%s: SCIC IO Request requested to abort while in wrong "
1060 "state %d\n", 1032 "state %d\n",
1061 __func__, 1033 __func__,
1062 sci_base_state_machine_get_state( 1034 sci_base_state_machine_get_state(&request->state_machine));
1063 &((struct scic_sds_request *)request)->parent.state_machine));
1064 1035
1065 return SCI_FAILURE_INVALID_STATE; 1036 return SCI_FAILURE_INVALID_STATE;
1066} 1037}
1067 1038
1068/** 1039/*
1069 * scic_sds_request_default_complete_handler() -
1070 * @request: This is the struct sci_base_request object that is cast to the
1071 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1072 *
1073 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1040 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1074 * object receives a scic_sds_request_complete() request. The default action 1041 * object receives a scic_sds_request_complete() request. The default action
1075 * is to log a warning and return a failure status. enum sci_status 1042 * is to log a warning and return a failure status. enum sci_status
1076 * SCI_FAILURE_INVALID_STATE 1043 * SCI_FAILURE_INVALID_STATE
1077 */ 1044 */
1078enum sci_status scic_sds_request_default_complete_handler( 1045enum sci_status scic_sds_request_default_complete_handler(
1079 struct sci_base_request *request) 1046 struct scic_sds_request *request)
1080{ 1047{
1081 struct scic_sds_request *scic_request = 1048 dev_warn(scic_to_dev(request->owning_controller),
1082 (struct scic_sds_request *)request;
1083
1084 dev_warn(scic_to_dev(scic_request->owning_controller),
1085 "%s: SCIC IO Request requested to complete while in wrong " 1049 "%s: SCIC IO Request requested to complete while in wrong "
1086 "state %d\n", 1050 "state %d\n",
1087 __func__, 1051 __func__,
1088 sci_base_state_machine_get_state( 1052 sci_base_state_machine_get_state(&request->state_machine));
1089 &((struct scic_sds_request *)request)->parent.state_machine));
1090 1053
1091 return SCI_FAILURE_INVALID_STATE; 1054 return SCI_FAILURE_INVALID_STATE;
1092} 1055}
1093 1056
1094/** 1057/*
1095 * scic_sds_request_default_destruct_handler() -
1096 * @request: This is the struct sci_base_request object that is cast to the
1097 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1098 *
1099 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1058 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1100 * object receives a scic_sds_request_complete() request. The default action 1059 * object receives a scic_sds_request_complete() request. The default action
1101 * is to log a warning and return a failure status. enum sci_status 1060 * is to log a warning and return a failure status. enum sci_status
1102 * SCI_FAILURE_INVALID_STATE 1061 * SCI_FAILURE_INVALID_STATE
1103 */ 1062 */
1104enum sci_status scic_sds_request_default_destruct_handler( 1063enum sci_status scic_sds_request_default_destruct_handler(
1105 struct sci_base_request *request) 1064 struct scic_sds_request *request)
1106{ 1065{
1107 struct scic_sds_request *scic_request = 1066 dev_warn(scic_to_dev(request->owning_controller),
1108 (struct scic_sds_request *)request;
1109
1110 dev_warn(scic_to_dev(scic_request->owning_controller),
1111 "%s: SCIC IO Request requested to destroy while in wrong " 1067 "%s: SCIC IO Request requested to destroy while in wrong "
1112 "state %d\n", 1068 "state %d\n",
1113 __func__, 1069 __func__,
1114 sci_base_state_machine_get_state( 1070 sci_base_state_machine_get_state(&request->state_machine));
1115 &((struct scic_sds_request *)request)->parent.state_machine));
1116 1071
1117 return SCI_FAILURE_INVALID_STATE; 1072 return SCI_FAILURE_INVALID_STATE;
1118} 1073}
1119 1074
1120/** 1075/**
1121 * scic_sds_request_default_tc_completion_handler() -
1122 * @request: This is the struct sci_base_request object that is cast to the
1123 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1124 *
1125 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1076 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1126 * object receives a scic_sds_task_request_complete() request. The default 1077 * object receives a scic_sds_task_request_complete() request. The default
1127 * action is to log a warning and return a failure status. enum sci_status 1078 * action is to log a warning and return a failure status. enum sci_status
1128 * SCI_FAILURE_INVALID_STATE 1079 * SCI_FAILURE_INVALID_STATE
1129 */ 1080 */
1130enum sci_status scic_sds_request_default_tc_completion_handler( 1081enum sci_status scic_sds_request_default_tc_completion_handler(
1131 struct scic_sds_request *this_request, 1082 struct scic_sds_request *request,
1132 u32 completion_code) 1083 u32 completion_code)
1133{ 1084{
1134 dev_warn(scic_to_dev(this_request->owning_controller), 1085 dev_warn(scic_to_dev(request->owning_controller),
1135 "%s: SCIC IO Request given task completion notification %x " 1086 "%s: SCIC IO Request given task completion notification %x "
1136 "while in wrong state %d\n", 1087 "while in wrong state %d\n",
1137 __func__, 1088 __func__,
1138 completion_code, 1089 completion_code,
1139 sci_base_state_machine_get_state( 1090 sci_base_state_machine_get_state(&request->state_machine));
1140 &this_request->parent.state_machine));
1141 1091
1142 return SCI_FAILURE_INVALID_STATE; 1092 return SCI_FAILURE_INVALID_STATE;
1143 1093
1144} 1094}
1145 1095
1146/** 1096/*
1147 * scic_sds_request_default_event_handler() -
1148 * @request: This is the struct sci_base_request object that is cast to the
1149 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1150 *
1151 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1097 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1152 * object receives a scic_sds_request_event_handler() request. The default 1098 * object receives a scic_sds_request_event_handler() request. The default
1153 * action is to log a warning and return a failure status. enum sci_status 1099 * action is to log a warning and return a failure status. enum sci_status
1154 * SCI_FAILURE_INVALID_STATE 1100 * SCI_FAILURE_INVALID_STATE
1155 */ 1101 */
1156enum sci_status scic_sds_request_default_event_handler( 1102enum sci_status scic_sds_request_default_event_handler(
1157 struct scic_sds_request *this_request, 1103 struct scic_sds_request *request,
1158 u32 event_code) 1104 u32 event_code)
1159{ 1105{
1160 dev_warn(scic_to_dev(this_request->owning_controller), 1106 dev_warn(scic_to_dev(request->owning_controller),
1161 "%s: SCIC IO Request given event code notification %x while " 1107 "%s: SCIC IO Request given event code notification %x while "
1162 "in wrong state %d\n", 1108 "in wrong state %d\n",
1163 __func__, 1109 __func__,
1164 event_code, 1110 event_code,
1165 sci_base_state_machine_get_state( 1111 sci_base_state_machine_get_state(&request->state_machine));
1166 &this_request->parent.state_machine));
1167 1112
1168 return SCI_FAILURE_INVALID_STATE; 1113 return SCI_FAILURE_INVALID_STATE;
1169} 1114}
1170 1115
1171/** 1116/*
1172 * scic_sds_request_default_frame_handler() -
1173 * @request: This is the struct sci_base_request object that is cast to the
1174 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1175 *
1176 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T 1117 * This method is the default action to take when an SCIC_SDS_IO_REQUEST_T
1177 * object receives a scic_sds_request_event_handler() request. The default 1118 * object receives a scic_sds_request_event_handler() request. The default
1178 * action is to log a warning and return a failure status. enum sci_status 1119 * action is to log a warning and return a failure status. enum sci_status
1179 * SCI_FAILURE_INVALID_STATE 1120 * SCI_FAILURE_INVALID_STATE
1180 */ 1121 */
1181enum sci_status scic_sds_request_default_frame_handler( 1122enum sci_status scic_sds_request_default_frame_handler(
1182 struct scic_sds_request *this_request, 1123 struct scic_sds_request *request,
1183 u32 frame_index) 1124 u32 frame_index)
1184{ 1125{
1185 dev_warn(scic_to_dev(this_request->owning_controller), 1126 dev_warn(scic_to_dev(request->owning_controller),
1186 "%s: SCIC IO Request given unexpected frame %x while in " 1127 "%s: SCIC IO Request given unexpected frame %x while in "
1187 "state %d\n", 1128 "state %d\n",
1188 __func__, 1129 __func__,
1189 frame_index, 1130 frame_index,
1190 sci_base_state_machine_get_state( 1131 sci_base_state_machine_get_state(&request->state_machine));
1191 &this_request->parent.state_machine));
1192 1132
1193 scic_sds_controller_release_frame( 1133 scic_sds_controller_release_frame(
1194 this_request->owning_controller, frame_index); 1134 request->owning_controller, frame_index);
1195 1135
1196 return SCI_FAILURE_INVALID_STATE; 1136 return SCI_FAILURE_INVALID_STATE;
1197} 1137}
@@ -1201,11 +1141,7 @@ enum sci_status scic_sds_request_default_frame_handler(
1201 * * CONSTRUCTED STATE HANDLERS 1141 * * CONSTRUCTED STATE HANDLERS
1202 * ***************************************************************************** */ 1142 * ***************************************************************************** */
1203 1143
1204/** 1144/*
1205 * scic_sds_request_constructed_state_start_handler() -
1206 * @request: This is the struct sci_base_request object that is cast to the
1207 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1208 *
1209 * This method implements the action taken when a constructed 1145 * This method implements the action taken when a constructed
1210 * SCIC_SDS_IO_REQUEST_T object receives a scic_sds_request_start() request. 1146 * SCIC_SDS_IO_REQUEST_T object receives a scic_sds_request_start() request.
1211 * This method will, if necessary, allocate a TCi for the io request object and 1147 * This method will, if necessary, allocate a TCi for the io request object and
@@ -1215,34 +1151,33 @@ enum sci_status scic_sds_request_default_frame_handler(
1215 * SCI_SUCCESS SCI_FAILURE_INSUFFICIENT_RESOURCES 1151 * SCI_SUCCESS SCI_FAILURE_INSUFFICIENT_RESOURCES
1216 */ 1152 */
1217static enum sci_status scic_sds_request_constructed_state_start_handler( 1153static enum sci_status scic_sds_request_constructed_state_start_handler(
1218 struct sci_base_request *request) 1154 struct scic_sds_request *request)
1219{ 1155{
1220 struct scu_task_context *task_context; 1156 struct scu_task_context *task_context;
1221 struct scic_sds_request *this_request = (struct scic_sds_request *)request;
1222 1157
1223 if (this_request->io_tag == SCI_CONTROLLER_INVALID_IO_TAG) { 1158 if (request->io_tag == SCI_CONTROLLER_INVALID_IO_TAG) {
1224 this_request->io_tag = 1159 request->io_tag =
1225 scic_controller_allocate_io_tag(this_request->owning_controller); 1160 scic_controller_allocate_io_tag(request->owning_controller);
1226 } 1161 }
1227 1162
1228 /* Record the IO Tag in the request */ 1163 /* Record the IO Tag in the request */
1229 if (this_request->io_tag != SCI_CONTROLLER_INVALID_IO_TAG) { 1164 if (request->io_tag != SCI_CONTROLLER_INVALID_IO_TAG) {
1230 task_context = this_request->task_context_buffer; 1165 task_context = request->task_context_buffer;
1231 1166
1232 task_context->task_index = scic_sds_io_tag_get_index(this_request->io_tag); 1167 task_context->task_index = scic_sds_io_tag_get_index(request->io_tag);
1233 1168
1234 switch (task_context->protocol_type) { 1169 switch (task_context->protocol_type) {
1235 case SCU_TASK_CONTEXT_PROTOCOL_SMP: 1170 case SCU_TASK_CONTEXT_PROTOCOL_SMP:
1236 case SCU_TASK_CONTEXT_PROTOCOL_SSP: 1171 case SCU_TASK_CONTEXT_PROTOCOL_SSP:
1237 /* SSP/SMP Frame */ 1172 /* SSP/SMP Frame */
1238 task_context->type.ssp.tag = this_request->io_tag; 1173 task_context->type.ssp.tag = request->io_tag;
1239 task_context->type.ssp.target_port_transfer_tag = 0xFFFF; 1174 task_context->type.ssp.target_port_transfer_tag = 0xFFFF;
1240 break; 1175 break;
1241 1176
1242 case SCU_TASK_CONTEXT_PROTOCOL_STP: 1177 case SCU_TASK_CONTEXT_PROTOCOL_STP:
1243 /* 1178 /*
1244 * STP/SATA Frame 1179 * STP/SATA Frame
1245 * task_context->type.stp.ncq_tag = this_request->ncq_tag; */ 1180 * task_context->type.stp.ncq_tag = request->ncq_tag; */
1246 break; 1181 break;
1247 1182
1248 case SCU_TASK_CONTEXT_PROTOCOL_NONE: 1183 case SCU_TASK_CONTEXT_PROTOCOL_NONE:
@@ -1257,20 +1192,17 @@ static enum sci_status scic_sds_request_constructed_state_start_handler(
1257 /* 1192 /*
1258 * Check to see if we need to copy the task context buffer 1193 * Check to see if we need to copy the task context buffer
1259 * or have been building into the task context buffer */ 1194 * or have been building into the task context buffer */
1260 if (this_request->was_tag_assigned_by_user == false) { 1195 if (request->was_tag_assigned_by_user == false) {
1261 scic_sds_controller_copy_task_context( 1196 scic_sds_controller_copy_task_context(
1262 this_request->owning_controller, this_request 1197 request->owning_controller, request);
1263 );
1264 } 1198 }
1265 1199
1266 /* Add to the post_context the io tag value */ 1200 /* Add to the post_context the io tag value */
1267 this_request->post_context |= scic_sds_io_tag_get_index(this_request->io_tag); 1201 request->post_context |= scic_sds_io_tag_get_index(request->io_tag);
1268 1202
1269 /* Everything is good go ahead and change state */ 1203 /* Everything is good go ahead and change state */
1270 sci_base_state_machine_change_state( 1204 sci_base_state_machine_change_state(&request->state_machine,
1271 &this_request->parent.state_machine, 1205 SCI_BASE_REQUEST_STATE_STARTED);
1272 SCI_BASE_REQUEST_STATE_STARTED
1273 );
1274 1206
1275 return SCI_SUCCESS; 1207 return SCI_SUCCESS;
1276 } 1208 }
@@ -1278,35 +1210,24 @@ static enum sci_status scic_sds_request_constructed_state_start_handler(
1278 return SCI_FAILURE_INSUFFICIENT_RESOURCES; 1210 return SCI_FAILURE_INSUFFICIENT_RESOURCES;
1279} 1211}
1280 1212
1281/** 1213/*
1282 * scic_sds_request_constructed_state_abort_handler() -
1283 * @request: This is the struct sci_base_request object that is cast to the
1284 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1285 *
1286 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1214 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1287 * object receives a scic_sds_request_terminate() request. Since the request 1215 * object receives a scic_sds_request_terminate() request. Since the request
1288 * has not yet been posted to the hardware the request transitions to the 1216 * has not yet been posted to the hardware the request transitions to the
1289 * completed state. enum sci_status SCI_SUCCESS 1217 * completed state. enum sci_status SCI_SUCCESS
1290 */ 1218 */
1291static enum sci_status scic_sds_request_constructed_state_abort_handler( 1219static enum sci_status scic_sds_request_constructed_state_abort_handler(
1292 struct sci_base_request *request) 1220 struct scic_sds_request *request)
1293{ 1221{
1294 struct scic_sds_request *this_request = (struct scic_sds_request *)request;
1295
1296 /* 1222 /*
1297 * This request has been terminated by the user make sure that the correct 1223 * This request has been terminated by the user make sure that the correct
1298 * status code is returned */ 1224 * status code is returned */
1299 scic_sds_request_set_status( 1225 scic_sds_request_set_status(request,
1300 this_request,
1301 SCU_TASK_DONE_TASK_ABORT, 1226 SCU_TASK_DONE_TASK_ABORT,
1302 SCI_FAILURE_IO_TERMINATED 1227 SCI_FAILURE_IO_TERMINATED);
1303 );
1304
1305 sci_base_state_machine_change_state(
1306 &this_request->parent.state_machine,
1307 SCI_BASE_REQUEST_STATE_COMPLETED
1308 );
1309 1228
1229 sci_base_state_machine_change_state(&request->state_machine,
1230 SCI_BASE_REQUEST_STATE_COMPLETED);
1310 return SCI_SUCCESS; 1231 return SCI_SUCCESS;
1311} 1232}
1312 1233
@@ -1315,30 +1236,20 @@ static enum sci_status scic_sds_request_constructed_state_abort_handler(
1315 * * STARTED STATE HANDLERS 1236 * * STARTED STATE HANDLERS
1316 * ***************************************************************************** */ 1237 * ***************************************************************************** */
1317 1238
1318/** 1239/*
1319 * scic_sds_request_started_state_abort_handler() -
1320 * @request: This is the struct sci_base_request object that is cast to the
1321 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1322 *
1323 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1240 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1324 * object receives a scic_sds_request_terminate() request. Since the request 1241 * object receives a scic_sds_request_terminate() request. Since the request
1325 * has been posted to the hardware the io request state is changed to the 1242 * has been posted to the hardware the io request state is changed to the
1326 * aborting state. enum sci_status SCI_SUCCESS 1243 * aborting state. enum sci_status SCI_SUCCESS
1327 */ 1244 */
1328enum sci_status scic_sds_request_started_state_abort_handler( 1245enum sci_status scic_sds_request_started_state_abort_handler(
1329 struct sci_base_request *request) 1246 struct scic_sds_request *request)
1330{ 1247{
1331 struct scic_sds_request *this_request = (struct scic_sds_request *)request; 1248 if (request->has_started_substate_machine)
1332 1249 sci_base_state_machine_stop(&request->started_substate_machine);
1333 if (this_request->has_started_substate_machine) {
1334 sci_base_state_machine_stop(&this_request->started_substate_machine);
1335 }
1336
1337 sci_base_state_machine_change_state(
1338 &this_request->parent.state_machine,
1339 SCI_BASE_REQUEST_STATE_ABORTING
1340 );
1341 1250
1251 sci_base_state_machine_change_state(&request->state_machine,
1252 SCI_BASE_REQUEST_STATE_ABORTING);
1342 return SCI_SUCCESS; 1253 return SCI_SUCCESS;
1343} 1254}
1344 1255
@@ -1512,20 +1423,12 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
1512 */ 1423 */
1513 1424
1514 /* In all cases we will treat this as the completion of the IO request. */ 1425 /* In all cases we will treat this as the completion of the IO request. */
1515 sci_base_state_machine_change_state( 1426 sci_base_state_machine_change_state(&this_request->state_machine,
1516 &this_request->parent.state_machine, 1427 SCI_BASE_REQUEST_STATE_COMPLETED);
1517 SCI_BASE_REQUEST_STATE_COMPLETED
1518 );
1519
1520 return SCI_SUCCESS; 1428 return SCI_SUCCESS;
1521} 1429}
1522 1430
1523/** 1431/*
1524 * scic_sds_request_started_state_frame_handler() -
1525 * @request: This is the struct sci_base_request object that is cast to the
1526 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1527 * @frame_index: This is the index of the unsolicited frame to be processed.
1528 *
1529 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1432 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1530 * object receives a scic_sds_request_frame_handler() request. This method 1433 * object receives a scic_sds_request_frame_handler() request. This method
1531 * first determines the frame type received. If this is a response frame then 1434 * first determines the frame type received. If this is a response frame then
@@ -1601,11 +1504,7 @@ static enum sci_status scic_sds_request_started_state_frame_handler(
1601 * ***************************************************************************** */ 1504 * ***************************************************************************** */
1602 1505
1603 1506
1604/** 1507/*
1605 * scic_sds_request_completed_state_complete_handler() -
1606 * @request: This is the struct sci_base_request object that is cast to the
1607 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1608 *
1609 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1508 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1610 * object receives a scic_sds_request_complete() request. This method frees up 1509 * object receives a scic_sds_request_complete() request. This method frees up
1611 * any io request resources that have been allocated and transitions the 1510 * any io request resources that have been allocated and transitions the
@@ -1613,26 +1512,20 @@ static enum sci_status scic_sds_request_started_state_frame_handler(
1613 * transitioning to the final state? enum sci_status SCI_SUCCESS 1512 * transitioning to the final state? enum sci_status SCI_SUCCESS
1614 */ 1513 */
1615static enum sci_status scic_sds_request_completed_state_complete_handler( 1514static enum sci_status scic_sds_request_completed_state_complete_handler(
1616 struct sci_base_request *request) 1515 struct scic_sds_request *request)
1617{ 1516{
1618 struct scic_sds_request *this_request = (struct scic_sds_request *)request; 1517 if (request->was_tag_assigned_by_user != true) {
1619
1620 if (this_request->was_tag_assigned_by_user != true) {
1621 scic_controller_free_io_tag( 1518 scic_controller_free_io_tag(
1622 this_request->owning_controller, this_request->io_tag 1519 request->owning_controller, request->io_tag);
1623 );
1624 } 1520 }
1625 1521
1626 if (this_request->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX) { 1522 if (request->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX) {
1627 scic_sds_controller_release_frame( 1523 scic_sds_controller_release_frame(
1628 this_request->owning_controller, this_request->saved_rx_frame_index); 1524 request->owning_controller, request->saved_rx_frame_index);
1629 } 1525 }
1630 1526
1631 sci_base_state_machine_change_state( 1527 sci_base_state_machine_change_state(&request->state_machine,
1632 &this_request->parent.state_machine, 1528 SCI_BASE_REQUEST_STATE_FINAL);
1633 SCI_BASE_REQUEST_STATE_FINAL
1634 );
1635
1636 return SCI_SUCCESS; 1529 return SCI_SUCCESS;
1637} 1530}
1638 1531
@@ -1641,11 +1534,7 @@ static enum sci_status scic_sds_request_completed_state_complete_handler(
1641 * * ABORTING STATE HANDLERS 1534 * * ABORTING STATE HANDLERS
1642 * ***************************************************************************** */ 1535 * ***************************************************************************** */
1643 1536
1644/** 1537/*
1645 * scic_sds_request_aborting_state_abort_handler() -
1646 * @request: This is the struct sci_base_request object that is cast to the
1647 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1648 *
1649 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1538 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1650 * object receives a scic_sds_request_terminate() request. This method is the 1539 * object receives a scic_sds_request_terminate() request. This method is the
1651 * io request aborting state abort handlers. On receipt of a multiple 1540 * io request aborting state abort handlers. On receipt of a multiple
@@ -1653,23 +1542,14 @@ static enum sci_status scic_sds_request_completed_state_complete_handler(
1653 * This should not happen in normal operation. enum sci_status SCI_SUCCESS 1542 * This should not happen in normal operation. enum sci_status SCI_SUCCESS
1654 */ 1543 */
1655static enum sci_status scic_sds_request_aborting_state_abort_handler( 1544static enum sci_status scic_sds_request_aborting_state_abort_handler(
1656 struct sci_base_request *request) 1545 struct scic_sds_request *request)
1657{ 1546{
1658 struct scic_sds_request *this_request = (struct scic_sds_request *)request; 1547 sci_base_state_machine_change_state(&request->state_machine,
1659 1548 SCI_BASE_REQUEST_STATE_COMPLETED);
1660 sci_base_state_machine_change_state(
1661 &this_request->parent.state_machine,
1662 SCI_BASE_REQUEST_STATE_COMPLETED
1663 );
1664
1665 return SCI_SUCCESS; 1549 return SCI_SUCCESS;
1666} 1550}
1667 1551
1668/** 1552/*
1669 * scic_sds_request_aborting_state_tc_completion_handler() -
1670 * @request: This is the struct sci_base_request object that is cast to the
1671 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1672 *
1673 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1553 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1674 * object receives a scic_sds_request_task_completion() request. This method 1554 * object receives a scic_sds_request_task_completion() request. This method
1675 * decodes the completion type waiting for the abort task complete 1555 * decodes the completion type waiting for the abort task complete
@@ -1687,10 +1567,8 @@ static enum sci_status scic_sds_request_aborting_state_tc_completion_handler(
1687 this_request, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED 1567 this_request, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED
1688 ); 1568 );
1689 1569
1690 sci_base_state_machine_change_state( 1570 sci_base_state_machine_change_state(&this_request->state_machine,
1691 &this_request->parent.state_machine, 1571 SCI_BASE_REQUEST_STATE_COMPLETED);
1692 SCI_BASE_REQUEST_STATE_COMPLETED
1693 );
1694 break; 1572 break;
1695 1573
1696 default: 1574 default:
@@ -1703,11 +1581,7 @@ static enum sci_status scic_sds_request_aborting_state_tc_completion_handler(
1703 return SCI_SUCCESS; 1581 return SCI_SUCCESS;
1704} 1582}
1705 1583
1706/** 1584/*
1707 * scic_sds_request_aborting_state_frame_handler() -
1708 * @request: This is the struct sci_base_request object that is cast to the
1709 * SCIC_SDS_IO_REQUEST_T object for which the start operation is requested.
1710 *
1711 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T 1585 * This method implements the action to be taken when an SCIC_SDS_IO_REQUEST_T
1712 * object receives a scic_sds_request_frame_handler() request. This method 1586 * object receives a scic_sds_request_frame_handler() request. This method
1713 * discards the unsolicited frame since we are waiting for the abort task 1587 * discards the unsolicited frame since we are waiting for the abort task
@@ -1727,58 +1601,58 @@ static enum sci_status scic_sds_request_aborting_state_frame_handler(
1727 1601
1728static const struct scic_sds_io_request_state_handler scic_sds_request_state_handler_table[] = { 1602static const struct scic_sds_io_request_state_handler scic_sds_request_state_handler_table[] = {
1729 [SCI_BASE_REQUEST_STATE_INITIAL] = { 1603 [SCI_BASE_REQUEST_STATE_INITIAL] = {
1730 .parent.start_handler = scic_sds_request_default_start_handler, 1604 .start_handler = scic_sds_request_default_start_handler,
1731 .parent.abort_handler = scic_sds_request_default_abort_handler, 1605 .abort_handler = scic_sds_request_default_abort_handler,
1732 .parent.complete_handler = scic_sds_request_default_complete_handler, 1606 .complete_handler = scic_sds_request_default_complete_handler,
1733 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1607 .destruct_handler = scic_sds_request_default_destruct_handler,
1734 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1608 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1735 .event_handler = scic_sds_request_default_event_handler, 1609 .event_handler = scic_sds_request_default_event_handler,
1736 .frame_handler = scic_sds_request_default_frame_handler, 1610 .frame_handler = scic_sds_request_default_frame_handler,
1737 }, 1611 },
1738 [SCI_BASE_REQUEST_STATE_CONSTRUCTED] = { 1612 [SCI_BASE_REQUEST_STATE_CONSTRUCTED] = {
1739 .parent.start_handler = scic_sds_request_constructed_state_start_handler, 1613 .start_handler = scic_sds_request_constructed_state_start_handler,
1740 .parent.abort_handler = scic_sds_request_constructed_state_abort_handler, 1614 .abort_handler = scic_sds_request_constructed_state_abort_handler,
1741 .parent.complete_handler = scic_sds_request_default_complete_handler, 1615 .complete_handler = scic_sds_request_default_complete_handler,
1742 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1616 .destruct_handler = scic_sds_request_default_destruct_handler,
1743 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1617 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1744 .event_handler = scic_sds_request_default_event_handler, 1618 .event_handler = scic_sds_request_default_event_handler,
1745 .frame_handler = scic_sds_request_default_frame_handler, 1619 .frame_handler = scic_sds_request_default_frame_handler,
1746 }, 1620 },
1747 [SCI_BASE_REQUEST_STATE_STARTED] = { 1621 [SCI_BASE_REQUEST_STATE_STARTED] = {
1748 .parent.start_handler = scic_sds_request_default_start_handler, 1622 .start_handler = scic_sds_request_default_start_handler,
1749 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1623 .abort_handler = scic_sds_request_started_state_abort_handler,
1750 .parent.complete_handler = scic_sds_request_default_complete_handler, 1624 .complete_handler = scic_sds_request_default_complete_handler,
1751 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1625 .destruct_handler = scic_sds_request_default_destruct_handler,
1752 .tc_completion_handler = scic_sds_request_started_state_tc_completion_handler, 1626 .tc_completion_handler = scic_sds_request_started_state_tc_completion_handler,
1753 .event_handler = scic_sds_request_default_event_handler, 1627 .event_handler = scic_sds_request_default_event_handler,
1754 .frame_handler = scic_sds_request_started_state_frame_handler, 1628 .frame_handler = scic_sds_request_started_state_frame_handler,
1755 }, 1629 },
1756 [SCI_BASE_REQUEST_STATE_COMPLETED] = { 1630 [SCI_BASE_REQUEST_STATE_COMPLETED] = {
1757 .parent.start_handler = scic_sds_request_default_start_handler, 1631 .start_handler = scic_sds_request_default_start_handler,
1758 .parent.abort_handler = scic_sds_request_default_abort_handler, 1632 .abort_handler = scic_sds_request_default_abort_handler,
1759 .parent.complete_handler = scic_sds_request_completed_state_complete_handler, 1633 .complete_handler = scic_sds_request_completed_state_complete_handler,
1760 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1634 .destruct_handler = scic_sds_request_default_destruct_handler,
1761 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1635 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1762 .event_handler = scic_sds_request_default_event_handler, 1636 .event_handler = scic_sds_request_default_event_handler,
1763 .frame_handler = scic_sds_request_default_frame_handler, 1637 .frame_handler = scic_sds_request_default_frame_handler,
1764 }, 1638 },
1765 [SCI_BASE_REQUEST_STATE_ABORTING] = { 1639 [SCI_BASE_REQUEST_STATE_ABORTING] = {
1766 .parent.start_handler = scic_sds_request_default_start_handler, 1640 .start_handler = scic_sds_request_default_start_handler,
1767 .parent.abort_handler = scic_sds_request_aborting_state_abort_handler, 1641 .abort_handler = scic_sds_request_aborting_state_abort_handler,
1768 .parent.complete_handler = scic_sds_request_default_complete_handler, 1642 .complete_handler = scic_sds_request_default_complete_handler,
1769 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1643 .destruct_handler = scic_sds_request_default_destruct_handler,
1770 .tc_completion_handler = scic_sds_request_aborting_state_tc_completion_handler, 1644 .tc_completion_handler = scic_sds_request_aborting_state_tc_completion_handler,
1771 .event_handler = scic_sds_request_default_event_handler, 1645 .event_handler = scic_sds_request_default_event_handler,
1772 .frame_handler = scic_sds_request_aborting_state_frame_handler, 1646 .frame_handler = scic_sds_request_aborting_state_frame_handler,
1773 }, 1647 },
1774 [SCI_BASE_REQUEST_STATE_FINAL] = { 1648 [SCI_BASE_REQUEST_STATE_FINAL] = {
1775 .parent.start_handler = scic_sds_request_default_start_handler, 1649 .start_handler = scic_sds_request_default_start_handler,
1776 .parent.abort_handler = scic_sds_request_default_abort_handler, 1650 .abort_handler = scic_sds_request_default_abort_handler,
1777 .parent.complete_handler = scic_sds_request_default_complete_handler, 1651 .complete_handler = scic_sds_request_default_complete_handler,
1778 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1652 .destruct_handler = scic_sds_request_default_destruct_handler,
1779 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1653 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1780 .event_handler = scic_sds_request_default_event_handler, 1654 .event_handler = scic_sds_request_default_event_handler,
1781 .frame_handler = scic_sds_request_default_frame_handler, 1655 .frame_handler = scic_sds_request_default_frame_handler,
1782 }, 1656 },
1783}; 1657};
1784 1658
@@ -1978,7 +1852,11 @@ static void scic_sds_general_request_construct(struct scic_sds_controller *scic,
1978 void *user_io_request_object, 1852 void *user_io_request_object,
1979 struct scic_sds_request *sci_req) 1853 struct scic_sds_request *sci_req)
1980{ 1854{
1981 sci_base_request_construct(&sci_req->parent, scic_sds_request_state_table); 1855 sci_req->parent.private = NULL;
1856 sci_base_state_machine_construct(&sci_req->state_machine, &sci_req->parent,
1857 scic_sds_request_state_table, SCI_BASE_REQUEST_STATE_INITIAL);
1858 sci_base_state_machine_start(&sci_req->state_machine);
1859
1982 sci_req->io_tag = io_tag; 1860 sci_req->io_tag = io_tag;
1983 sci_req->user_request = user_io_request_object; 1861 sci_req->user_request = user_io_request_object;
1984 sci_req->owning_controller = scic; 1862 sci_req->owning_controller = scic;
@@ -2070,7 +1948,7 @@ enum sci_status scic_task_request_construct(struct scic_sds_controller *scic,
2070 /* Construct the started sub-state machine. */ 1948 /* Construct the started sub-state machine. */
2071 sci_base_state_machine_construct( 1949 sci_base_state_machine_construct(
2072 &sci_req->started_substate_machine, 1950 &sci_req->started_substate_machine,
2073 &sci_req->parent.parent, 1951 &sci_req->parent,
2074 scic_sds_io_request_started_task_mgmt_substate_table, 1952 scic_sds_io_request_started_task_mgmt_substate_table,
2075 SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION 1953 SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION
2076 ); 1954 );
diff --git a/drivers/scsi/isci/core/scic_sds_request.h b/drivers/scsi/isci/core/scic_sds_request.h
index 286b74943d68..5b0f88596370 100644
--- a/drivers/scsi/isci/core/scic_sds_request.h
+++ b/drivers/scsi/isci/core/scic_sds_request.h
@@ -64,8 +64,7 @@
64 */ 64 */
65 65
66#include "scic_io_request.h" 66#include "scic_io_request.h"
67 67#include "sci_base_state_machine.h"
68#include "sci_base_request.h"
69#include "scu_task_context.h" 68#include "scu_task_context.h"
70#include "intel_sas.h" 69#include "intel_sas.h"
71 70
@@ -127,9 +126,15 @@ enum scic_sds_smp_request_started_substates {
127 */ 126 */
128struct scic_sds_request { 127struct scic_sds_request {
129 /** 128 /**
130 * This field indictes the parent object of the request. 129 * The field specifies that the parent object for the base request is the
130 * base object itself.
131 */ 131 */
132 struct sci_base_request parent; 132 struct sci_base_object parent;
133
134 /**
135 * This field contains the information for the base request state machine.
136 */
137 struct sci_base_state_machine state_machine;
133 138
134 void *user_request; 139 void *user_request;
135 140
@@ -231,15 +236,59 @@ struct scic_sds_request {
231 236
232}; 237};
233 238
239/**
240 * enum sci_base_request_states - This enumeration depicts all the states for
241 * the common request state machine.
242 *
243 *
244 */
245enum sci_base_request_states {
246 /**
247 * Simply the initial state for the base request state machine.
248 */
249 SCI_BASE_REQUEST_STATE_INITIAL,
250
251 /**
252 * This state indicates that the request has been constructed. This state
253 * is entered from the INITIAL state.
254 */
255 SCI_BASE_REQUEST_STATE_CONSTRUCTED,
256
257 /**
258 * This state indicates that the request has been started. This state is
259 * entered from the CONSTRUCTED state.
260 */
261 SCI_BASE_REQUEST_STATE_STARTED,
262
263 /**
264 * This state indicates that the request has completed.
265 * This state is entered from the STARTED state. This state is entered from
266 * the ABORTING state.
267 */
268 SCI_BASE_REQUEST_STATE_COMPLETED,
234 269
235typedef enum sci_status 270 /**
236(*scic_sds_io_request_frame_handler_t)(struct scic_sds_request *req, u32 frame); 271 * This state indicates that the request is in the process of being
272 * terminated/aborted.
273 * This state is entered from the CONSTRUCTED state.
274 * This state is entered from the STARTED state.
275 */
276 SCI_BASE_REQUEST_STATE_ABORTING,
237 277
238typedef enum sci_status 278 /**
239(*scic_sds_io_request_event_handler_t)(struct scic_sds_request *req, u32 event); 279 * Simply the final state for the base request state machine.
280 */
281 SCI_BASE_REQUEST_STATE_FINAL,
282};
240 283
241typedef enum sci_status 284typedef enum sci_status (*scic_sds_io_request_handler_t)
242(*scic_sds_io_request_task_completion_handler_t)(struct scic_sds_request *req, u32 completion_code); 285 (struct scic_sds_request *request);
286typedef enum sci_status (*scic_sds_io_request_frame_handler_t)
287 (struct scic_sds_request *req, u32 frame);
288typedef enum sci_status (*scic_sds_io_request_event_handler_t)
289 (struct scic_sds_request *req, u32 event);
290typedef enum sci_status (*scic_sds_io_request_task_completion_handler_t)
291 (struct scic_sds_request *req, u32 completion_code);
243 292
244/** 293/**
245 * struct scic_sds_io_request_state_handler - This is the SDS core definition 294 * struct scic_sds_io_request_state_handler - This is the SDS core definition
@@ -248,7 +297,30 @@ typedef enum sci_status
248 * 297 *
249 */ 298 */
250struct scic_sds_io_request_state_handler { 299struct scic_sds_io_request_state_handler {
251 struct sci_base_request_state_handler parent; 300 /**
301 * The start_handler specifies the method invoked when a user attempts to
302 * start a request.
303 */
304 scic_sds_io_request_handler_t start_handler;
305
306 /**
307 * The abort_handler specifies the method invoked when a user attempts to
308 * abort a request.
309 */
310 scic_sds_io_request_handler_t abort_handler;
311
312 /**
313 * The complete_handler specifies the method invoked when a user attempts to
314 * complete a request.
315 */
316 scic_sds_io_request_handler_t complete_handler;
317
318 /**
319 * The destruct_handler specifies the method invoked when a user attempts to
320 * destruct a request.
321 */
322 scic_sds_io_request_handler_t destruct_handler;
323
252 324
253 scic_sds_io_request_task_completion_handler_t tc_completion_handler; 325 scic_sds_io_request_task_completion_handler_t tc_completion_handler;
254 scic_sds_io_request_event_handler_t event_handler; 326 scic_sds_io_request_event_handler_t event_handler;
@@ -319,7 +391,7 @@ extern const struct sci_base_state scic_sds_io_request_started_task_mgmt_substat
319 } 391 }
320 392
321#define scic_sds_request_complete(a_request) \ 393#define scic_sds_request_complete(a_request) \
322 ((a_request)->state_handlers->parent.complete_handler(&(a_request)->parent)) 394 ((a_request)->state_handlers->complete_handler(a_request))
323 395
324 396
325 397
@@ -331,15 +403,15 @@ extern const struct sci_base_state scic_sds_io_request_started_task_mgmt_substat
331 * struct scic_sds_io_request object. 403 * struct scic_sds_io_request object.
332 */ 404 */
333#define scic_sds_io_request_tc_completion(this_request, completion_code) \ 405#define scic_sds_io_request_tc_completion(this_request, completion_code) \
334 { \ 406{ \
335 if (this_request->parent.state_machine.current_state_id \ 407 if (this_request->state_machine.current_state_id \
336 == SCI_BASE_REQUEST_STATE_STARTED \ 408 == SCI_BASE_REQUEST_STATE_STARTED \
337 && this_request->has_started_substate_machine \ 409 && this_request->has_started_substate_machine \
338 == false) \ 410 == false) \
339 scic_sds_request_started_state_tc_completion_handler(this_request, completion_code); \ 411 scic_sds_request_started_state_tc_completion_handler(this_request, completion_code); \
340 else \ 412 else \
341 this_request->state_handlers->tc_completion_handler(this_request, completion_code); \ 413 this_request->state_handlers->tc_completion_handler(this_request, completion_code); \
342 } 414}
343 415
344/** 416/**
345 * SCU_SGL_ZERO() - 417 * SCU_SGL_ZERO() -
@@ -426,14 +498,14 @@ enum sci_status scic_sds_task_request_terminate(
426 * ***************************************************************************** */ 498 * ***************************************************************************** */
427 499
428enum sci_status scic_sds_request_default_start_handler( 500enum sci_status scic_sds_request_default_start_handler(
429 struct sci_base_request *this_request); 501 struct scic_sds_request *request);
430 502
431 503
432enum sci_status scic_sds_request_default_complete_handler( 504enum sci_status scic_sds_request_default_complete_handler(
433 struct sci_base_request *this_request); 505 struct scic_sds_request *request);
434 506
435enum sci_status scic_sds_request_default_destruct_handler( 507enum sci_status scic_sds_request_default_destruct_handler(
436 struct sci_base_request *this_request); 508 struct scic_sds_request *request);
437 509
438enum sci_status scic_sds_request_default_tc_completion_handler( 510enum sci_status scic_sds_request_default_tc_completion_handler(
439 struct scic_sds_request *this_request, 511 struct scic_sds_request *this_request,
@@ -453,7 +525,7 @@ enum sci_status scic_sds_request_default_frame_handler(
453 * ***************************************************************************** */ 525 * ***************************************************************************** */
454 526
455enum sci_status scic_sds_request_started_state_abort_handler( 527enum sci_status scic_sds_request_started_state_abort_handler(
456 struct sci_base_request *this_request); 528 struct scic_sds_request *request);
457 529
458enum sci_status scic_sds_request_started_state_tc_completion_handler( 530enum sci_status scic_sds_request_started_state_tc_completion_handler(
459 struct scic_sds_request *this_request, 531 struct scic_sds_request *this_request,
diff --git a/drivers/scsi/isci/core/scic_sds_smp_remote_device.c b/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
index 06cb93221b4c..040a3d8c08b9 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
@@ -78,29 +78,24 @@
78 */ 78 */
79static enum sci_status scic_sds_smp_remote_device_ready_idle_substate_start_io_handler( 79static enum sci_status scic_sds_smp_remote_device_ready_idle_substate_start_io_handler(
80 struct sci_base_remote_device *device, 80 struct sci_base_remote_device *device,
81 struct sci_base_request *request) 81 struct scic_sds_request *request)
82{ 82{
83 enum sci_status status; 83 enum sci_status status;
84 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 84 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
85 struct scic_sds_request *io_request = (struct scic_sds_request *)request;
86 85
87 /* Will the port allow the io request to start? */ 86 /* Will the port allow the io request to start? */
88 status = this_device->owning_port->state_handlers->start_io_handler( 87 status = this_device->owning_port->state_handlers->start_io_handler(
89 this_device->owning_port, 88 this_device->owning_port, this_device, request);
90 this_device,
91 io_request
92 );
93 89
94 if (status == SCI_SUCCESS) { 90 if (status == SCI_SUCCESS) {
95 status = 91 status =
96 scic_sds_remote_node_context_start_io(this_device->rnc, io_request); 92 scic_sds_remote_node_context_start_io(this_device->rnc, request);
97 93
98 if (status == SCI_SUCCESS) { 94 if (status == SCI_SUCCESS)
99 status = scic_sds_request_start(io_request); 95 status = scic_sds_request_start(request);
100 }
101 96
102 if (status == SCI_SUCCESS) { 97 if (status == SCI_SUCCESS) {
103 this_device->working_request = io_request; 98 this_device->working_request = request;
104 99
105 sci_base_state_machine_change_state( 100 sci_base_state_machine_change_state(
106 &this_device->ready_substate_machine, 101 &this_device->ready_substate_machine,
@@ -108,7 +103,7 @@ static enum sci_status scic_sds_smp_remote_device_ready_idle_substate_start_io_h
108 ); 103 );
109 } 104 }
110 105
111 scic_sds_remote_device_start_request(this_device, io_request, status); 106 scic_sds_remote_device_start_request(this_device, request, status);
112 } 107 }
113 108
114 return status; 109 return status;
@@ -129,7 +124,7 @@ static enum sci_status scic_sds_smp_remote_device_ready_idle_substate_start_io_h
129 */ 124 */
130static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler( 125static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler(
131 struct sci_base_remote_device *device, 126 struct sci_base_remote_device *device,
132 struct sci_base_request *request) 127 struct scic_sds_request *request)
133{ 128{
134 return SCI_FAILURE_INVALID_STATE; 129 return SCI_FAILURE_INVALID_STATE;
135} 130}
@@ -144,7 +139,7 @@ static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_ha
144 */ 139 */
145static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler( 140static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler(
146 struct sci_base_remote_device *device, 141 struct sci_base_remote_device *device,
147 struct sci_base_request *request) 142 struct scic_sds_request *request)
148{ 143{
149 enum sci_status status; 144 enum sci_status status;
150 struct scic_sds_remote_device *this_device; 145 struct scic_sds_remote_device *this_device;
diff --git a/drivers/scsi/isci/core/scic_sds_smp_request.c b/drivers/scsi/isci/core/scic_sds_smp_request.c
index 84b0fdd7ed91..9293c2d5fc91 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_smp_request.c
@@ -394,7 +394,7 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
394 ); 394 );
395 395
396 sci_base_state_machine_change_state( 396 sci_base_state_machine_change_state(
397 &this_request->parent.state_machine, 397 &this_request->state_machine,
398 SCI_BASE_REQUEST_STATE_COMPLETED 398 SCI_BASE_REQUEST_STATE_COMPLETED
399 ); 399 );
400 } 400 }
@@ -433,9 +433,8 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
433 ); 433 );
434 434
435 sci_base_state_machine_change_state( 435 sci_base_state_machine_change_state(
436 &this_request->parent.state_machine, 436 &this_request->state_machine,
437 SCI_BASE_REQUEST_STATE_COMPLETED 437 SCI_BASE_REQUEST_STATE_COMPLETED);
438 );
439 break; 438 break;
440 439
441 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR): 440 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
@@ -452,9 +451,8 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
452 ); 451 );
453 452
454 sci_base_state_machine_change_state( 453 sci_base_state_machine_change_state(
455 &this_request->parent.state_machine, 454 &this_request->state_machine,
456 SCI_BASE_REQUEST_STATE_COMPLETED 455 SCI_BASE_REQUEST_STATE_COMPLETED);
457 );
458 break; 456 break;
459 457
460 default: 458 default:
@@ -468,9 +466,8 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
468 ); 466 );
469 467
470 sci_base_state_machine_change_state( 468 sci_base_state_machine_change_state(
471 &this_request->parent.state_machine, 469 &this_request->state_machine,
472 SCI_BASE_REQUEST_STATE_COMPLETED 470 SCI_BASE_REQUEST_STATE_COMPLETED);
473 );
474 break; 471 break;
475 } 472 }
476 473
@@ -502,9 +499,8 @@ static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_ha
502 ); 499 );
503 500
504 sci_base_state_machine_change_state( 501 sci_base_state_machine_change_state(
505 &this_request->parent.state_machine, 502 &this_request->state_machine,
506 SCI_BASE_REQUEST_STATE_COMPLETED 503 SCI_BASE_REQUEST_STATE_COMPLETED);
507 );
508 break; 504 break;
509 505
510 default: 506 default:
@@ -518,9 +514,8 @@ static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_ha
518 ); 514 );
519 515
520 sci_base_state_machine_change_state( 516 sci_base_state_machine_change_state(
521 &this_request->parent.state_machine, 517 &this_request->state_machine,
522 SCI_BASE_REQUEST_STATE_COMPLETED 518 SCI_BASE_REQUEST_STATE_COMPLETED);
523 );
524 break; 519 break;
525 } 520 }
526 521
@@ -530,22 +525,22 @@ static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_ha
530 525
531static const struct scic_sds_io_request_state_handler scic_sds_smp_request_started_substate_handler_table[] = { 526static const struct scic_sds_io_request_state_handler scic_sds_smp_request_started_substate_handler_table[] = {
532 [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE] = { 527 [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE] = {
533 .parent.start_handler = scic_sds_request_default_start_handler, 528 .start_handler = scic_sds_request_default_start_handler,
534 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 529 .abort_handler = scic_sds_request_started_state_abort_handler,
535 .parent.complete_handler = scic_sds_request_default_complete_handler, 530 .complete_handler = scic_sds_request_default_complete_handler,
536 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 531 .destruct_handler = scic_sds_request_default_destruct_handler,
537 .tc_completion_handler = scic_sds_smp_request_await_response_tc_completion_handler, 532 .tc_completion_handler = scic_sds_smp_request_await_response_tc_completion_handler,
538 .event_handler = scic_sds_request_default_event_handler, 533 .event_handler = scic_sds_request_default_event_handler,
539 .frame_handler = scic_sds_smp_request_await_response_frame_handler, 534 .frame_handler = scic_sds_smp_request_await_response_frame_handler,
540 }, 535 },
541 [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION] = { 536 [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION] = {
542 .parent.start_handler = scic_sds_request_default_start_handler, 537 .start_handler = scic_sds_request_default_start_handler,
543 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 538 .abort_handler = scic_sds_request_started_state_abort_handler,
544 .parent.complete_handler = scic_sds_request_default_complete_handler, 539 .complete_handler = scic_sds_request_default_complete_handler,
545 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 540 .destruct_handler = scic_sds_request_default_destruct_handler,
546 .tc_completion_handler = scic_sds_smp_request_await_tc_completion_tc_completion_handler, 541 .tc_completion_handler = scic_sds_smp_request_await_tc_completion_tc_completion_handler,
547 .event_handler = scic_sds_request_default_event_handler, 542 .event_handler = scic_sds_request_default_event_handler,
548 .frame_handler = scic_sds_request_default_frame_handler, 543 .frame_handler = scic_sds_request_default_frame_handler,
549 } 544 }
550}; 545};
551 546
@@ -626,7 +621,7 @@ enum sci_status scic_io_request_construct_smp(struct scic_sds_request *sci_req)
626 /* Construct the started sub-state machine. */ 621 /* Construct the started sub-state machine. */
627 sci_base_state_machine_construct( 622 sci_base_state_machine_construct(
628 &sci_req->started_substate_machine, 623 &sci_req->started_substate_machine,
629 &sci_req->parent.parent, 624 &sci_req->parent,
630 scic_sds_smp_request_started_substate_table, 625 scic_sds_smp_request_started_substate_table,
631 SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE 626 SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE
632 ); 627 );
@@ -657,10 +652,8 @@ enum sci_status scic_io_request_construct_smp(struct scic_sds_request *sci_req)
657 652
658 scu_smp_request_construct_task_context(sci_req, smp_req); 653 scu_smp_request_construct_task_context(sci_req, smp_req);
659 654
660 sci_base_state_machine_change_state( 655 sci_base_state_machine_change_state(&sci_req->state_machine,
661 &sci_req->parent.state_machine, 656 SCI_BASE_REQUEST_STATE_CONSTRUCTED);
662 SCI_BASE_REQUEST_STATE_CONSTRUCTED
663 );
664 657
665 kfree(smp_req); 658 kfree(smp_req);
666 659
diff --git a/drivers/scsi/isci/core/scic_sds_ssp_request.c b/drivers/scsi/isci/core/scic_sds_ssp_request.c
index c9aa35f5cd15..1eecb19c3ad6 100644
--- a/drivers/scsi/isci/core/scic_sds_ssp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_ssp_request.c
@@ -120,10 +120,8 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completi
120 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR 120 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
121 ); 121 );
122 122
123 sci_base_state_machine_change_state( 123 sci_base_state_machine_change_state(&this_request->state_machine,
124 &this_request->parent.state_machine, 124 SCI_BASE_REQUEST_STATE_COMPLETED);
125 SCI_BASE_REQUEST_STATE_COMPLETED
126 );
127 break; 125 break;
128 } 126 }
129 127
@@ -143,20 +141,12 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completi
143 * pattern for this particular device). 141 * pattern for this particular device).
144 */ 142 */
145static enum sci_status scic_sds_ssp_task_request_await_tc_response_abort_handler( 143static enum sci_status scic_sds_ssp_task_request_await_tc_response_abort_handler(
146 struct sci_base_request *request) 144 struct scic_sds_request *request)
147{ 145{
148 struct scic_sds_request *this_request = (struct scic_sds_request *)request; 146 sci_base_state_machine_change_state(&request->state_machine,
149 147 SCI_BASE_REQUEST_STATE_ABORTING);
150 sci_base_state_machine_change_state( 148 sci_base_state_machine_change_state(&request->state_machine,
151 &this_request->parent.state_machine, 149 SCI_BASE_REQUEST_STATE_COMPLETED);
152 SCI_BASE_REQUEST_STATE_ABORTING
153 );
154
155 sci_base_state_machine_change_state(
156 &this_request->parent.state_machine,
157 SCI_BASE_REQUEST_STATE_COMPLETED
158 );
159
160 return SCI_SUCCESS; 150 return SCI_SUCCESS;
161} 151}
162 152
@@ -176,41 +166,36 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_response_abort_handler
176 * probably update to check frame type and make sure it is a response frame. 166 * probably update to check frame type and make sure it is a response frame.
177 */ 167 */
178static enum sci_status scic_sds_ssp_task_request_await_tc_response_frame_handler( 168static enum sci_status scic_sds_ssp_task_request_await_tc_response_frame_handler(
179 struct scic_sds_request *this_request, 169 struct scic_sds_request *request,
180 u32 frame_index) 170 u32 frame_index)
181{ 171{
182 scic_sds_io_request_copy_response(this_request); 172 scic_sds_io_request_copy_response(request);
183
184 sci_base_state_machine_change_state(
185 &this_request->parent.state_machine,
186 SCI_BASE_REQUEST_STATE_COMPLETED
187 );
188
189 scic_sds_controller_release_frame(
190 this_request->owning_controller, frame_index
191 );
192 173
174 sci_base_state_machine_change_state(&request->state_machine,
175 SCI_BASE_REQUEST_STATE_COMPLETED);
176 scic_sds_controller_release_frame(request->owning_controller,
177 frame_index);
193 return SCI_SUCCESS; 178 return SCI_SUCCESS;
194} 179}
195 180
196static const struct scic_sds_io_request_state_handler scic_sds_ssp_task_request_started_substate_handler_table[] = { 181static const struct scic_sds_io_request_state_handler scic_sds_ssp_task_request_started_substate_handler_table[] = {
197 [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION] = { 182 [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION] = {
198 .parent.start_handler = scic_sds_request_default_start_handler, 183 .start_handler = scic_sds_request_default_start_handler,
199 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 184 .abort_handler = scic_sds_request_started_state_abort_handler,
200 .parent.complete_handler = scic_sds_request_default_complete_handler, 185 .complete_handler = scic_sds_request_default_complete_handler,
201 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 186 .destruct_handler = scic_sds_request_default_destruct_handler,
202 .tc_completion_handler = scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler, 187 .tc_completion_handler = scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler,
203 .event_handler = scic_sds_request_default_event_handler, 188 .event_handler = scic_sds_request_default_event_handler,
204 .frame_handler = scic_sds_request_default_frame_handler, 189 .frame_handler = scic_sds_request_default_frame_handler,
205 }, 190 },
206 [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE] = { 191 [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE] = {
207 .parent.start_handler = scic_sds_request_default_start_handler, 192 .start_handler = scic_sds_request_default_start_handler,
208 .parent.abort_handler = scic_sds_ssp_task_request_await_tc_response_abort_handler, 193 .abort_handler = scic_sds_ssp_task_request_await_tc_response_abort_handler,
209 .parent.complete_handler = scic_sds_request_default_complete_handler, 194 .complete_handler = scic_sds_request_default_complete_handler,
210 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 195 .destruct_handler = scic_sds_request_default_destruct_handler,
211 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 196 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
212 .event_handler = scic_sds_request_default_event_handler, 197 .event_handler = scic_sds_request_default_event_handler,
213 .frame_handler = scic_sds_ssp_task_request_await_tc_response_frame_handler, 198 .frame_handler = scic_sds_ssp_task_request_await_tc_response_frame_handler,
214 } 199 }
215}; 200};
216 201
diff --git a/drivers/scsi/isci/core/scic_sds_stp_packet_request.c b/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
index 9635b37fad16..2d551ad3a46c 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
@@ -659,16 +659,12 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_d2h_fis_frame_ha
659} 659}
660 660
661enum sci_status scic_sds_stp_packet_request_started_completion_delay_complete_handler( 661enum sci_status scic_sds_stp_packet_request_started_completion_delay_complete_handler(
662 struct sci_base_request *request) 662 struct scic_sds_request *request)
663{ 663{
664 struct scic_sds_request *this_request = (struct scic_sds_request *)request; 664 sci_base_state_machine_change_state(&request->parent.state_machine,
665 SCI_BASE_REQUEST_STATE_COMPLETED);
665 666
666 sci_base_state_machine_change_state( 667 return request->sci_status;
667 &this_request->parent.state_machine,
668 SCI_BASE_REQUEST_STATE_COMPLETED
669 );
670
671 return this_request->sci_status;
672} 668}
673 669
674/* --------------------------------------------------------------------------- */ 670/* --------------------------------------------------------------------------- */
diff --git a/drivers/scsi/isci/core/scic_sds_stp_remote_device.c b/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
index 0a00a40bdbbe..bb582497039b 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
@@ -78,22 +78,20 @@
78 */ 78 */
79static enum sci_status scic_sds_stp_remote_device_complete_request( 79static enum sci_status scic_sds_stp_remote_device_complete_request(
80 struct sci_base_remote_device *device, 80 struct sci_base_remote_device *device,
81 struct sci_base_request *request) 81 struct scic_sds_request *request)
82{ 82{
83 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 83 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
84 struct scic_sds_request *the_request = (struct scic_sds_request *)request;
85 enum sci_status status; 84 enum sci_status status;
86 85
87 status = scic_sds_io_request_complete(the_request); 86 status = scic_sds_io_request_complete(request);
88 87
89 if (status == SCI_SUCCESS) { 88 if (status == SCI_SUCCESS) {
90 status = scic_sds_port_complete_io( 89 status = scic_sds_port_complete_io(
91 this_device->owning_port, this_device, the_request 90 this_device->owning_port, this_device, request);
92 );
93 91
94 if (status == SCI_SUCCESS) { 92 if (status == SCI_SUCCESS) {
95 scic_sds_remote_device_decrement_request_count(this_device); 93 scic_sds_remote_device_decrement_request_count(this_device);
96 if (the_request->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) { 94 if (request->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
97 /* 95 /*
98 * This request causes hardware error, device needs to be Lun Reset. 96 * This request causes hardware error, device needs to be Lun Reset.
99 * So here we force the state machine to IDLE state so the rest IOs 97 * So here we force the state machine to IDLE state so the rest IOs
@@ -119,7 +117,7 @@ static enum sci_status scic_sds_stp_remote_device_complete_request(
119 __func__, 117 __func__,
120 this_device->owning_port, 118 this_device->owning_port,
121 this_device, 119 this_device,
122 the_request, 120 request,
123 status); 121 status);
124 122
125 return status; 123 return status;
@@ -143,64 +141,54 @@ static enum sci_status scic_sds_stp_remote_device_complete_request(
143 */ 141 */
144static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_handler( 142static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_handler(
145 struct sci_base_remote_device *device, 143 struct sci_base_remote_device *device,
146 struct sci_base_request *request) 144 struct scic_sds_request *request)
147{ 145{
148 enum sci_status status; 146 enum sci_status status;
149 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 147 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
150 struct scic_sds_request *this_request = (struct scic_sds_request *)request;
151 148
152 /* Will the port allow the io request to start? */ 149 /* Will the port allow the io request to start? */
153 status = this_device->owning_port->state_handlers->start_io_handler( 150 status = this_device->owning_port->state_handlers->start_io_handler(
154 this_device->owning_port, 151 this_device->owning_port, this_device, request);
155 this_device, 152 if (status != SCI_SUCCESS)
156 this_request 153 return status;
157 );
158
159 if (SCI_SUCCESS == status) {
160 status =
161 scic_sds_remote_node_context_start_task(this_device->rnc, this_request);
162
163 if (SCI_SUCCESS == status) {
164 status = this_request->state_handlers->parent.start_handler(request);
165 }
166
167 if (status == SCI_SUCCESS) {
168 /*
169 * / @note If the remote device state is not IDLE this will replace
170 * / the request that probably resulted in the task management
171 * / request. */
172 this_device->working_request = this_request;
173
174 sci_base_state_machine_change_state(
175 &this_device->ready_substate_machine,
176 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD
177 );
178 154
179 /* 155 status = scic_sds_remote_node_context_start_task(this_device->rnc, request);
180 * The remote node context must cleanup the TCi to NCQ mapping table. 156 if (status != SCI_SUCCESS)
181 * The only way to do this correctly is to either write to the TLCR 157 goto out;
182 * register or to invalidate and repost the RNC. In either case the
183 * remote node context state machine will take the correct action when
184 * the remote node context is suspended and later resumed. */
185 scic_sds_remote_node_context_suspend(
186 this_device->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
187
188 scic_sds_remote_node_context_resume(
189 this_device->rnc,
190 scic_sds_remote_device_continue_request,
191 this_device);
192 }
193 158
194 scic_sds_remote_device_start_request(this_device, this_request, status); 159 status = request->state_handlers->start_handler(request);
160 if (status != SCI_SUCCESS)
161 goto out;
195 162
196 /* 163 /*
197 * We need to let the controller start request handler know that it can't 164 * Note: If the remote device state is not IDLE this will replace
198 * post TC yet. We will provide a callback function to post TC when RNC gets 165 * the request that probably resulted in the task management request.
199 * resumed. */ 166 */
200 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS; 167 this_device->working_request = request;
201 } 168 sci_base_state_machine_change_state(&this_device->ready_substate_machine,
169 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
202 170
203 return status; 171 /*
172 * The remote node context must cleanup the TCi to NCQ mapping table.
173 * The only way to do this correctly is to either write to the TLCR
174 * register or to invalidate and repost the RNC. In either case the
175 * remote node context state machine will take the correct action when
176 * the remote node context is suspended and later resumed.
177 */
178 scic_sds_remote_node_context_suspend(this_device->rnc,
179 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
180 scic_sds_remote_node_context_resume(this_device->rnc,
181 scic_sds_remote_device_continue_request,
182 this_device);
183
184out:
185 scic_sds_remote_device_start_request(this_device, request, status);
186 /*
187 * We need to let the controller start request handler know that it can't
188 * post TC yet. We will provide a callback function to post TC when RNC gets
189 * resumed.
190 */
191 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
204} 192}
205 193
206/* 194/*
@@ -221,53 +209,39 @@ static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_h
221 */ 209 */
222static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_start_io_handler( 210static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_start_io_handler(
223 struct sci_base_remote_device *base_device, 211 struct sci_base_remote_device *base_device,
224 struct sci_base_request *base_request) 212 struct scic_sds_request *request)
225{ 213{
226 enum sci_status status; 214 enum sci_status status;
227 struct scic_sds_remote_device *device = 215 struct scic_sds_remote_device *device =
228 (struct scic_sds_remote_device *)&base_device->parent; 216 (struct scic_sds_remote_device *)&base_device->parent;
229 struct scic_sds_request *sds_request =
230 (struct scic_sds_request *)&base_request->parent;
231 struct isci_request *isci_request = 217 struct isci_request *isci_request =
232 (struct isci_request *)sci_object_get_association(sds_request); 218 (struct isci_request *)sci_object_get_association(request);
233 219
234 220
235 /* Will the port allow the io request to start? */ 221 /* Will the port allow the io request to start? */
236 status = device->owning_port->state_handlers->start_io_handler( 222 status = device->owning_port->state_handlers->start_io_handler(
237 device->owning_port, 223 device->owning_port, device, request);
238 device, 224 if (status != SCI_SUCCESS)
239 sds_request); 225 return status;
240
241 if (status == SCI_SUCCESS) {
242 status =
243 scic_sds_remote_node_context_start_io(device->rnc,
244 sds_request);
245
246 if (status == SCI_SUCCESS)
247 status =
248 sds_request->state_handlers->
249 parent.start_handler(base_request);
250 226
251 if (status == SCI_SUCCESS) { 227 status = scic_sds_remote_node_context_start_io(device->rnc, request);
252 if (isci_sata_get_sat_protocol(isci_request) == 228 if (status != SCI_SUCCESS)
253 SAT_PROTOCOL_FPDMA) 229 goto out;
254 sci_base_state_machine_change_state(
255 &device->ready_substate_machine,
256 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ);
257 else {
258 device->working_request = sds_request;
259 230
260 sci_base_state_machine_change_state( 231 status = request->state_handlers->start_handler(request);
261 &device->ready_substate_machine, 232 if (status != SCI_SUCCESS)
262 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD); 233 goto out;
263 }
264 }
265 234
266 scic_sds_remote_device_start_request(device, 235 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) {
267 sds_request, 236 sci_base_state_machine_change_state(&device->ready_substate_machine,
268 status); 237 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ);
238 } else {
239 device->working_request = request;
240 sci_base_state_machine_change_state(&device->ready_substate_machine,
241 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
269 } 242 }
270 243out:
244 scic_sds_remote_device_start_request(device, request, status);
271 return status; 245 return status;
272} 246}
273 247
@@ -308,33 +282,30 @@ static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_event_hand
308 282
309static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler( 283static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler(
310 struct sci_base_remote_device *base_device, 284 struct sci_base_remote_device *base_device,
311 struct sci_base_request *base_request) 285 struct scic_sds_request *request)
312{ 286{
313 enum sci_status status; 287 enum sci_status status;
314 struct scic_sds_remote_device *device = 288 struct scic_sds_remote_device *device =
315 (struct scic_sds_remote_device *)&base_device->parent; 289 (struct scic_sds_remote_device *)&base_device->parent;
316 struct scic_sds_request *sds_request =
317 (struct scic_sds_request *)&base_request->parent;
318 struct isci_request *isci_request = 290 struct isci_request *isci_request =
319 (struct isci_request *)sci_object_get_association(sds_request); 291 (struct isci_request *)sci_object_get_association(request);
320 292
321 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) { 293 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) {
322 status = device->owning_port->state_handlers->start_io_handler( 294 status = device->owning_port->state_handlers->start_io_handler(
323 device->owning_port, 295 device->owning_port,
324 device, 296 device,
325 sds_request); 297 request);
326 298
327 if (status == SCI_SUCCESS) { 299 if (status == SCI_SUCCESS) {
328 status = scic_sds_remote_node_context_start_io( 300 status = scic_sds_remote_node_context_start_io(
329 device->rnc, 301 device->rnc,
330 sds_request); 302 request);
331 303
332 if (status == SCI_SUCCESS) 304 if (status == SCI_SUCCESS)
333 status = sds_request->state_handlers-> 305 status = request->state_handlers->start_handler(request);
334 parent.start_handler(base_request);
335 306
336 scic_sds_remote_device_start_request(device, 307 scic_sds_remote_device_start_request(device,
337 sds_request, 308 request,
338 status); 309 status);
339 } 310 }
340 } else 311 } else
@@ -422,7 +393,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
422 */ 393 */
423static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler( 394static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler(
424 struct sci_base_remote_device *device, 395 struct sci_base_remote_device *device,
425 struct sci_base_request *request) 396 struct scic_sds_request *request)
426{ 397{
427 return SCI_FAILURE_INVALID_STATE; 398 return SCI_FAILURE_INVALID_STATE;
428} 399}
@@ -475,7 +446,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handl
475 * ***************************************************************************** */ 446 * ***************************************************************************** */
476static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler( 447static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler(
477 struct sci_base_remote_device *device, 448 struct sci_base_remote_device *device,
478 struct sci_base_request *request) 449 struct scic_sds_request *request)
479{ 450{
480 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED; 451 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
481} 452}
@@ -494,7 +465,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_sta
494 */ 465 */
495static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler( 466static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler(
496 struct sci_base_remote_device *device, 467 struct sci_base_remote_device *device,
497 struct sci_base_request *request) 468 struct scic_sds_request *request)
498{ 469{
499 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device; 470 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
500 struct scic_sds_request *the_request = (struct scic_sds_request *)request; 471 struct scic_sds_request *the_request = (struct scic_sds_request *)request;
diff --git a/drivers/scsi/isci/core/scic_sds_stp_request.c b/drivers/scsi/isci/core/scic_sds_stp_request.c
index 5dd4896576d4..6d0a17866aac 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_request.c
@@ -465,8 +465,7 @@ static enum sci_status scic_sds_stp_request_non_data_await_h2d_tc_completion_han
465 ); 465 );
466 466
467 sci_base_state_machine_change_state( 467 sci_base_state_machine_change_state(
468 &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED 468 &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
469 );
470 break; 469 break;
471 } 470 }
472 471
@@ -495,7 +494,7 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
495 struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request; 494 struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
496 495
497 status = scic_sds_unsolicited_frame_control_get_header( 496 status = scic_sds_unsolicited_frame_control_get_header(
498 &(this_request->parent.owning_controller->uf_control), 497 &this_request->parent.owning_controller->uf_control,
499 frame_index, 498 frame_index,
500 (void **)&frame_header 499 (void **)&frame_header
501 ); 500 );
@@ -504,7 +503,7 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
504 switch (frame_header->fis_type) { 503 switch (frame_header->fis_type) {
505 case SATA_FIS_TYPE_REGD2H: 504 case SATA_FIS_TYPE_REGD2H:
506 scic_sds_unsolicited_frame_control_get_buffer( 505 scic_sds_unsolicited_frame_control_get_buffer(
507 &(this_request->parent.owning_controller->uf_control), 506 &this_request->parent.owning_controller->uf_control,
508 frame_index, 507 frame_index,
509 (void **)&frame_buffer 508 (void **)&frame_buffer
510 ); 509 );
@@ -536,14 +535,13 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
536 } 535 }
537 536
538 sci_base_state_machine_change_state( 537 sci_base_state_machine_change_state(
539 &this_request->parent.parent.state_machine, 538 &this_request->parent.state_machine,
540 SCI_BASE_REQUEST_STATE_COMPLETED 539 SCI_BASE_REQUEST_STATE_COMPLETED
541 ); 540 );
542 541
543 /* Frame has been decoded return it to the controller */ 542 /* Frame has been decoded return it to the controller */
544 scic_sds_controller_release_frame( 543 scic_sds_controller_release_frame(
545 this_request->parent.owning_controller, frame_index 544 this_request->parent.owning_controller, frame_index);
546 );
547 } else 545 } else
548 dev_err(scic_to_dev(request->owning_controller), 546 dev_err(scic_to_dev(request->owning_controller),
549 "%s: SCIC IO Request 0x%p could not get frame header " 547 "%s: SCIC IO Request 0x%p could not get frame header "
@@ -557,22 +555,22 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
557 555
558static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_non_data_substate_handler_table[] = { 556static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_non_data_substate_handler_table[] = {
559 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE] = { 557 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE] = {
560 .parent.start_handler = scic_sds_request_default_start_handler, 558 .start_handler = scic_sds_request_default_start_handler,
561 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 559 .abort_handler = scic_sds_request_started_state_abort_handler,
562 .parent.complete_handler = scic_sds_request_default_complete_handler, 560 .complete_handler = scic_sds_request_default_complete_handler,
563 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 561 .destruct_handler = scic_sds_request_default_destruct_handler,
564 .tc_completion_handler = scic_sds_stp_request_non_data_await_h2d_tc_completion_handler, 562 .tc_completion_handler = scic_sds_stp_request_non_data_await_h2d_tc_completion_handler,
565 .event_handler = scic_sds_request_default_event_handler, 563 .event_handler = scic_sds_request_default_event_handler,
566 .frame_handler = scic_sds_request_default_frame_handler, 564 .frame_handler = scic_sds_request_default_frame_handler,
567 }, 565 },
568 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE] = { 566 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE] = {
569 .parent.start_handler = scic_sds_request_default_start_handler, 567 .start_handler = scic_sds_request_default_start_handler,
570 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 568 .abort_handler = scic_sds_request_started_state_abort_handler,
571 .parent.complete_handler = scic_sds_request_default_complete_handler, 569 .complete_handler = scic_sds_request_default_complete_handler,
572 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 570 .destruct_handler = scic_sds_request_default_destruct_handler,
573 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 571 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
574 .event_handler = scic_sds_request_default_event_handler, 572 .event_handler = scic_sds_request_default_event_handler,
575 .frame_handler = scic_sds_stp_request_non_data_await_d2h_frame_handler, 573 .frame_handler = scic_sds_stp_request_non_data_await_d2h_frame_handler,
576 } 574 }
577}; 575};
578 576
@@ -625,7 +623,7 @@ enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request
625 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer); 623 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer);
626 624
627 sci_base_state_machine_construct(&sci_req->started_substate_machine, 625 sci_base_state_machine_construct(&sci_req->started_substate_machine,
628 &sci_req->parent.parent, 626 &sci_req->parent,
629 scic_sds_stp_request_started_non_data_substate_table, 627 scic_sds_stp_request_started_non_data_substate_table,
630 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE); 628 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE);
631 629
@@ -677,8 +675,7 @@ static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
677 scic = this_request->owning_controller; 675 scic = this_request->owning_controller;
678 state = scic->state_machine.current_state_id; 676 state = scic->state_machine.current_state_id;
679 continue_io = scic_sds_controller_state_handler_table[state].continue_io; 677 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
680 return continue_io(scic, &this_request->target_device->parent, 678 return continue_io(scic, &this_request->target_device->parent, this_request);
681 &this_request->parent);
682} 679}
683 680
684/** 681/**
@@ -859,7 +856,7 @@ static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completi
859 ); 856 );
860 857
861 sci_base_state_machine_change_state( 858 sci_base_state_machine_change_state(
862 &this_request->parent.state_machine, 859 &this_request->state_machine,
863 SCI_BASE_REQUEST_STATE_COMPLETED 860 SCI_BASE_REQUEST_STATE_COMPLETED
864 ); 861 );
865 break; 862 break;
@@ -961,7 +958,7 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
961 ); 958 );
962 959
963 sci_base_state_machine_change_state( 960 sci_base_state_machine_change_state(
964 &this_request->parent.parent.state_machine, 961 &this_request->parent.state_machine,
965 SCI_BASE_REQUEST_STATE_COMPLETED 962 SCI_BASE_REQUEST_STATE_COMPLETED
966 ); 963 );
967 } else { 964 } else {
@@ -1056,12 +1053,12 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
1056 ); 1053 );
1057 1054
1058 sci_base_state_machine_change_state( 1055 sci_base_state_machine_change_state(
1059 &this_request->parent.parent.state_machine, 1056 &this_request->parent.state_machine,
1060 SCI_BASE_REQUEST_STATE_COMPLETED 1057 SCI_BASE_REQUEST_STATE_COMPLETED
1061 ); 1058 );
1062 } else { 1059 } else {
1063 sci_base_state_machine_change_state( 1060 sci_base_state_machine_change_state(
1064 &this_request->parent.started_substate_machine, 1061 &request->started_substate_machine,
1065 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE 1062 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1066 ); 1063 );
1067 } 1064 }
@@ -1083,7 +1080,7 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
1083 ); 1080 );
1084 1081
1085 sci_base_state_machine_change_state( 1082 sci_base_state_machine_change_state(
1086 &this_request->parent.parent.state_machine, 1083 &this_request->parent.state_machine,
1087 SCI_BASE_REQUEST_STATE_COMPLETED 1084 SCI_BASE_REQUEST_STATE_COMPLETED
1088 ); 1085 );
1089 1086
@@ -1160,7 +1157,7 @@ static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_com
1160 ); 1157 );
1161 1158
1162 sci_base_state_machine_change_state( 1159 sci_base_state_machine_change_state(
1163 &this_request->parent.state_machine, 1160 &this_request->state_machine,
1164 SCI_BASE_REQUEST_STATE_COMPLETED 1161 SCI_BASE_REQUEST_STATE_COMPLETED
1165 ); 1162 );
1166 break; 1163 break;
@@ -1215,40 +1212,40 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_event_handler
1215 1212
1216static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_pio_substate_handler_table[] = { 1213static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_pio_substate_handler_table[] = {
1217 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE] = { 1214 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE] = {
1218 .parent.start_handler = scic_sds_request_default_start_handler, 1215 .start_handler = scic_sds_request_default_start_handler,
1219 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1216 .abort_handler = scic_sds_request_started_state_abort_handler,
1220 .parent.complete_handler = scic_sds_request_default_complete_handler, 1217 .complete_handler = scic_sds_request_default_complete_handler,
1221 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1218 .destruct_handler = scic_sds_request_default_destruct_handler,
1222 .tc_completion_handler = scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler, 1219 .tc_completion_handler = scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler,
1223 .event_handler = scic_sds_request_default_event_handler, 1220 .event_handler = scic_sds_request_default_event_handler,
1224 .frame_handler = scic_sds_request_default_frame_handler 1221 .frame_handler = scic_sds_request_default_frame_handler
1225 }, 1222 },
1226 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE] = { 1223 [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE] = {
1227 .parent.start_handler = scic_sds_request_default_start_handler, 1224 .start_handler = scic_sds_request_default_start_handler,
1228 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1225 .abort_handler = scic_sds_request_started_state_abort_handler,
1229 .parent.complete_handler = scic_sds_request_default_complete_handler, 1226 .complete_handler = scic_sds_request_default_complete_handler,
1230 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1227 .destruct_handler = scic_sds_request_default_destruct_handler,
1231 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1228 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1232 .event_handler = scic_sds_request_default_event_handler, 1229 .event_handler = scic_sds_request_default_event_handler,
1233 .frame_handler = scic_sds_stp_request_pio_await_frame_frame_handler 1230 .frame_handler = scic_sds_stp_request_pio_await_frame_frame_handler
1234 }, 1231 },
1235 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE] = { 1232 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE] = {
1236 .parent.start_handler = scic_sds_request_default_start_handler, 1233 .start_handler = scic_sds_request_default_start_handler,
1237 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1234 .abort_handler = scic_sds_request_started_state_abort_handler,
1238 .parent.complete_handler = scic_sds_request_default_complete_handler, 1235 .complete_handler = scic_sds_request_default_complete_handler,
1239 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1236 .destruct_handler = scic_sds_request_default_destruct_handler,
1240 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1237 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1241 .event_handler = scic_sds_stp_request_pio_data_in_await_data_event_handler, 1238 .event_handler = scic_sds_stp_request_pio_data_in_await_data_event_handler,
1242 .frame_handler = scic_sds_stp_request_pio_data_in_await_data_frame_handler 1239 .frame_handler = scic_sds_stp_request_pio_data_in_await_data_frame_handler
1243 }, 1240 },
1244 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE] = { 1241 [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE] = {
1245 .parent.start_handler = scic_sds_request_default_start_handler, 1242 .start_handler = scic_sds_request_default_start_handler,
1246 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1243 .abort_handler = scic_sds_request_started_state_abort_handler,
1247 .parent.complete_handler = scic_sds_request_default_complete_handler, 1244 .complete_handler = scic_sds_request_default_complete_handler,
1248 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1245 .destruct_handler = scic_sds_request_default_destruct_handler,
1249 .tc_completion_handler = scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler, 1246 .tc_completion_handler = scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler,
1250 .event_handler = scic_sds_request_default_event_handler, 1247 .event_handler = scic_sds_request_default_event_handler,
1251 .frame_handler = scic_sds_request_default_frame_handler, 1248 .frame_handler = scic_sds_request_default_frame_handler,
1252 } 1249 }
1253}; 1250};
1254 1251
@@ -1352,7 +1349,7 @@ enum sci_status scic_sds_stp_pio_request_construct(struct scic_sds_request *sci_
1352 } 1349 }
1353 1350
1354 sci_base_state_machine_construct(&sci_req->started_substate_machine, 1351 sci_base_state_machine_construct(&sci_req->started_substate_machine,
1355 &sci_req->parent.parent, 1352 &sci_req->parent,
1356 scic_sds_stp_request_started_pio_substate_table, 1353 scic_sds_stp_request_started_pio_substate_table,
1357 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE); 1354 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE);
1358 1355
@@ -1360,18 +1357,13 @@ enum sci_status scic_sds_stp_pio_request_construct(struct scic_sds_request *sci_
1360} 1357}
1361 1358
1362static void scic_sds_stp_request_udma_complete_request( 1359static void scic_sds_stp_request_udma_complete_request(
1363 struct scic_sds_request *this_request, 1360 struct scic_sds_request *request,
1364 u32 scu_status, 1361 u32 scu_status,
1365 enum sci_status sci_status) 1362 enum sci_status sci_status)
1366{ 1363{
1367 scic_sds_request_set_status( 1364 scic_sds_request_set_status(request, scu_status, sci_status);
1368 this_request, scu_status, sci_status 1365 sci_base_state_machine_change_state(&request->state_machine,
1369 ); 1366 SCI_BASE_REQUEST_STATE_COMPLETED);
1370
1371 sci_base_state_machine_change_state(
1372 &this_request->parent.state_machine,
1373 SCI_BASE_REQUEST_STATE_COMPLETED
1374 );
1375} 1367}
1376 1368
1377/** 1369/**
@@ -1518,22 +1510,22 @@ static enum sci_status scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler
1518 1510
1519static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_udma_substate_handler_table[] = { 1511static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_udma_substate_handler_table[] = {
1520 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE] = { 1512 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE] = {
1521 .parent.start_handler = scic_sds_request_default_start_handler, 1513 .start_handler = scic_sds_request_default_start_handler,
1522 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1514 .abort_handler = scic_sds_request_started_state_abort_handler,
1523 .parent.complete_handler = scic_sds_request_default_complete_handler, 1515 .complete_handler = scic_sds_request_default_complete_handler,
1524 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1516 .destruct_handler = scic_sds_request_default_destruct_handler,
1525 .tc_completion_handler = scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler, 1517 .tc_completion_handler = scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler,
1526 .event_handler = scic_sds_request_default_event_handler, 1518 .event_handler = scic_sds_request_default_event_handler,
1527 .frame_handler = scic_sds_stp_request_udma_general_frame_handler, 1519 .frame_handler = scic_sds_stp_request_udma_general_frame_handler,
1528 }, 1520 },
1529 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE] = { 1521 [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE] = {
1530 .parent.start_handler = scic_sds_request_default_start_handler, 1522 .start_handler = scic_sds_request_default_start_handler,
1531 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1523 .abort_handler = scic_sds_request_started_state_abort_handler,
1532 .parent.complete_handler = scic_sds_request_default_complete_handler, 1524 .complete_handler = scic_sds_request_default_complete_handler,
1533 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1525 .destruct_handler = scic_sds_request_default_destruct_handler,
1534 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1526 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1535 .event_handler = scic_sds_request_default_event_handler, 1527 .event_handler = scic_sds_request_default_event_handler,
1536 .frame_handler = scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler, 1528 .frame_handler = scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler,
1537 }, 1529 },
1538}; 1530};
1539 1531
@@ -1590,7 +1582,7 @@ enum sci_status scic_sds_stp_udma_request_construct(struct scic_sds_request *sci
1590 1582
1591 sci_base_state_machine_construct( 1583 sci_base_state_machine_construct(
1592 &sci_req->started_substate_machine, 1584 &sci_req->started_substate_machine,
1593 &sci_req->parent.parent, 1585 &sci_req->parent,
1594 scic_sds_stp_request_started_udma_substate_table, 1586 scic_sds_stp_request_started_udma_substate_table,
1595 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE 1587 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
1596 ); 1588 );
@@ -1635,8 +1627,7 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_com
1635 ); 1627 );
1636 1628
1637 sci_base_state_machine_change_state( 1629 sci_base_state_machine_change_state(
1638 &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED 1630 &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
1639 );
1640 break; 1631 break;
1641 } 1632 }
1642 1633
@@ -1679,9 +1670,8 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_c
1679 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR 1670 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
1680 ); 1671 );
1681 1672
1682 sci_base_state_machine_change_state( 1673 sci_base_state_machine_change_state(&this_request->state_machine,
1683 &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED 1674 SCI_BASE_REQUEST_STATE_COMPLETED);
1684 );
1685 break; 1675 break;
1686 } 1676 }
1687 1677
@@ -1753,9 +1743,8 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
1753 } 1743 }
1754 1744
1755 sci_base_state_machine_change_state( 1745 sci_base_state_machine_change_state(
1756 &this_request->parent.parent.state_machine, 1746 &this_request->parent.state_machine,
1757 SCI_BASE_REQUEST_STATE_COMPLETED 1747 SCI_BASE_REQUEST_STATE_COMPLETED);
1758 );
1759 1748
1760 /* Frame has been decoded return it to the controller */ 1749 /* Frame has been decoded return it to the controller */
1761 scic_sds_controller_release_frame( 1750 scic_sds_controller_release_frame(
@@ -1774,31 +1763,31 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
1774 1763
1775static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_soft_reset_substate_handler_table[] = { 1764static const struct scic_sds_io_request_state_handler scic_sds_stp_request_started_soft_reset_substate_handler_table[] = {
1776 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE] = { 1765 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE] = {
1777 .parent.start_handler = scic_sds_request_default_start_handler, 1766 .start_handler = scic_sds_request_default_start_handler,
1778 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1767 .abort_handler = scic_sds_request_started_state_abort_handler,
1779 .parent.complete_handler = scic_sds_request_default_complete_handler, 1768 .complete_handler = scic_sds_request_default_complete_handler,
1780 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1769 .destruct_handler = scic_sds_request_default_destruct_handler,
1781 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler, 1770 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler,
1782 .event_handler = scic_sds_request_default_event_handler, 1771 .event_handler = scic_sds_request_default_event_handler,
1783 .frame_handler = scic_sds_request_default_frame_handler, 1772 .frame_handler = scic_sds_request_default_frame_handler,
1784 }, 1773 },
1785 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE] = { 1774 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE] = {
1786 .parent.start_handler = scic_sds_request_default_start_handler, 1775 .start_handler = scic_sds_request_default_start_handler,
1787 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1776 .abort_handler = scic_sds_request_started_state_abort_handler,
1788 .parent.complete_handler = scic_sds_request_default_complete_handler, 1777 .complete_handler = scic_sds_request_default_complete_handler,
1789 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1778 .destruct_handler = scic_sds_request_default_destruct_handler,
1790 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler, 1779 .tc_completion_handler = scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler,
1791 .event_handler = scic_sds_request_default_event_handler, 1780 .event_handler = scic_sds_request_default_event_handler,
1792 .frame_handler = scic_sds_request_default_frame_handler, 1781 .frame_handler = scic_sds_request_default_frame_handler,
1793 }, 1782 },
1794 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE] = { 1783 [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE] = {
1795 .parent.start_handler = scic_sds_request_default_start_handler, 1784 .start_handler = scic_sds_request_default_start_handler,
1796 .parent.abort_handler = scic_sds_request_started_state_abort_handler, 1785 .abort_handler = scic_sds_request_started_state_abort_handler,
1797 .parent.complete_handler = scic_sds_request_default_complete_handler, 1786 .complete_handler = scic_sds_request_default_complete_handler,
1798 .parent.destruct_handler = scic_sds_request_default_destruct_handler, 1787 .destruct_handler = scic_sds_request_default_destruct_handler,
1799 .tc_completion_handler = scic_sds_request_default_tc_completion_handler, 1788 .tc_completion_handler = scic_sds_request_default_tc_completion_handler,
1800 .event_handler = scic_sds_request_default_event_handler, 1789 .event_handler = scic_sds_request_default_event_handler,
1801 .frame_handler = scic_sds_stp_request_soft_reset_await_d2h_frame_handler, 1790 .frame_handler = scic_sds_stp_request_soft_reset_await_d2h_frame_handler,
1802 }, 1791 },
1803}; 1792};
1804 1793
@@ -1842,8 +1831,7 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_complet
1842 state = scic->state_machine.current_state_id; 1831 state = scic->state_machine.current_state_id;
1843 continue_io = scic_sds_controller_state_handler_table[state].continue_io; 1832 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
1844 1833
1845 status = continue_io(scic, &this_request->target_device->parent, 1834 status = continue_io(scic, &this_request->target_device->parent, this_request);
1846 &this_request->parent);
1847 1835
1848 if (status == SCI_SUCCESS) { 1836 if (status == SCI_SUCCESS) {
1849 SET_STATE_HANDLER( 1837 SET_STATE_HANDLER(
@@ -1888,7 +1876,7 @@ enum sci_status scic_sds_stp_soft_reset_request_construct(struct scic_sds_reques
1888 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer); 1876 scu_stp_raw_request_construct_task_context(stp_req, sci_req->task_context_buffer);
1889 1877
1890 sci_base_state_machine_construct(&sci_req->started_substate_machine, 1878 sci_base_state_machine_construct(&sci_req->started_substate_machine,
1891 &sci_req->parent.parent, 1879 &sci_req->parent,
1892 scic_sds_stp_request_started_soft_reset_substate_table, 1880 scic_sds_stp_request_started_soft_reset_substate_table,
1893 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE); 1881 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE);
1894 1882
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-25 00:25:28 -0400