aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorMaciej Trela <maciej.trela@intel.com>2011-04-12 20:28:35 -0400
committerDan Williams <dan.j.williams@intel.com>2011-07-03 07:00:37 -0400
commit0ea99d52cbcdb4bf5f5dd3097088a2919a115981 (patch)
treef65c280499e2db59582f2c2c51eef661548c5ea2 /drivers
parentc629582d0dea42d8b3617f8c46ea2770b95e23aa (diff)
isci: remove base_remote_device abstraction
Merge struct sci_base_remote_device into scic_sds_remote_device. As for now sci_base_remote_device was accessed indirectly using scic_sds_remote_device->parent field. Both machine state handlers are also merged together. Reported-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Maciej Trela <Maciej.Trela@intel.com> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/scsi/isci/core/sci_base_remote_device.h274
-rw-r--r--drivers/scsi/isci/core/scic_sds_controller.c8
-rw-r--r--drivers/scsi/isci/core/scic_sds_remote_device.c512
-rw-r--r--drivers/scsi/isci/core/scic_sds_remote_device.h188
-rw-r--r--drivers/scsi/isci/core/scic_sds_smp_remote_device.c104
-rw-r--r--drivers/scsi/isci/core/scic_sds_stp_remote_device.c227
6 files changed, 572 insertions, 741 deletions
diff --git a/drivers/scsi/isci/core/sci_base_remote_device.h b/drivers/scsi/isci/core/sci_base_remote_device.h
deleted file mode 100644
index 5db5f31336fc..000000000000
--- a/drivers/scsi/isci/core/sci_base_remote_device.h
+++ /dev/null
@@ -1,274 +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_REMOTE_DEVICE_H_
57#define _SCI_BASE_REMOTE_DEVICE_H_
58
59/**
60 * This file contains all of the structures, constants, and methods common to
61 * all remote device object definitions.
62 *
63 *
64 */
65
66#include "sci_base_state_machine.h"
67
68struct scic_sds_request;
69
70/**
71 * enum sci_base_remote_device_states - This enumeration depicts all the states
72 * for the common remote device state machine.
73 *
74 *
75 */
76enum sci_base_remote_device_states {
77 /**
78 * Simply the initial state for the base remote device state machine.
79 */
80 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL,
81
82 /**
83 * This state indicates that the remote device has successfully been
84 * stopped. In this state no new IO operations are permitted.
85 * This state is entered from the INITIAL state.
86 * This state is entered from the STOPPING state.
87 */
88 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED,
89
90 /**
91 * This state indicates the the remote device is in the process of
92 * becoming ready (i.e. starting). In this state no new IO operations
93 * are permitted.
94 * This state is entered from the STOPPED state.
95 */
96 SCI_BASE_REMOTE_DEVICE_STATE_STARTING,
97
98 /**
99 * This state indicates the remote device is now ready. Thus, the user
100 * is able to perform IO operations on the remote device.
101 * This state is entered from the STARTING state.
102 */
103 SCI_BASE_REMOTE_DEVICE_STATE_READY,
104
105 /**
106 * This state indicates that the remote device is in the process of
107 * stopping. In this state no new IO operations are permitted, but
108 * existing IO operations are allowed to complete.
109 * This state is entered from the READY state.
110 * This state is entered from the FAILED state.
111 */
112 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING,
113
114 /**
115 * This state indicates that the remote device has failed.
116 * In this state no new IO operations are permitted.
117 * This state is entered from the INITIALIZING state.
118 * This state is entered from the READY state.
119 */
120 SCI_BASE_REMOTE_DEVICE_STATE_FAILED,
121
122 /**
123 * This state indicates the device is being reset.
124 * In this state no new IO operations are permitted.
125 * This state is entered from the READY state.
126 */
127 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING,
128
129 /**
130 * Simply the final state for the base remote device state machine.
131 */
132 SCI_BASE_REMOTE_DEVICE_STATE_FINAL,
133};
134
135/**
136 * struct sci_base_remote_device - The base remote device object abstracts the
137 * fields common to all SCI remote device objects.
138 *
139 *
140 */
141struct sci_base_remote_device {
142 /**
143 * The field specifies that the parent object for the base remote
144 * device is the base object itself.
145 */
146 struct sci_base_object parent;
147
148 /**
149 * This field contains the information for the base remote device state
150 * machine.
151 */
152 struct sci_base_state_machine state_machine;
153};
154
155
156typedef enum sci_status (*sci_base_remote_device_handler_t)(
157 struct sci_base_remote_device *
158 );
159
160typedef enum sci_status (*sci_base_remote_device_request_handler_t)(
161 struct sci_base_remote_device *,
162 struct scic_sds_request *
163 );
164
165typedef enum sci_status (*sci_base_remote_device_high_priority_request_complete_handler_t)(
166 struct sci_base_remote_device *,
167 struct scic_sds_request *,
168 void *,
169 enum sci_io_status
170 );
171
172/**
173 * struct sci_base_remote_device_state_handler - This structure contains all of
174 * the state handler methods common to base remote device state machines.
175 * Handler methods provide the ability to change the behavior for user
176 * requests or transitions depending on the state the machine is in.
177 *
178 *
179 */
180struct sci_base_remote_device_state_handler {
181 /**
182 * The start_handler specifies the method invoked when a user attempts to
183 * start a remote device.
184 */
185 sci_base_remote_device_handler_t start_handler;
186
187 /**
188 * The stop_handler specifies the method invoked when a user attempts to
189 * stop a remote device.
190 */
191 sci_base_remote_device_handler_t stop_handler;
192
193 /**
194 * The fail_handler specifies the method invoked when a remote device
195 * failure has occurred. A failure may be due to an inability to
196 * initialize/configure the device.
197 */
198 sci_base_remote_device_handler_t fail_handler;
199
200 /**
201 * The destruct_handler specifies the method invoked when attempting to
202 * destruct a remote device.
203 */
204 sci_base_remote_device_handler_t destruct_handler;
205
206 /**
207 * The reset handler specifies the method invloked when requesting to reset a
208 * remote device.
209 */
210 sci_base_remote_device_handler_t reset_handler;
211
212 /**
213 * The reset complete handler specifies the method invloked when reporting
214 * that a reset has completed to the remote device.
215 */
216 sci_base_remote_device_handler_t reset_complete_handler;
217
218 /**
219 * The start_io_handler specifies the method invoked when a user
220 * attempts to start an IO request for a remote device.
221 */
222 sci_base_remote_device_request_handler_t start_io_handler;
223
224 /**
225 * The complete_io_handler specifies the method invoked when a user
226 * attempts to complete an IO request for a remote device.
227 */
228 sci_base_remote_device_request_handler_t complete_io_handler;
229
230 /**
231 * The continue_io_handler specifies the method invoked when a user
232 * attempts to continue an IO request for a remote device.
233 */
234 sci_base_remote_device_request_handler_t continue_io_handler;
235
236 /**
237 * The start_task_handler specifies the method invoked when a user
238 * attempts to start a task management request for a remote device.
239 */
240 sci_base_remote_device_request_handler_t start_task_handler;
241
242 /**
243 * The complete_task_handler specifies the method invoked when a user
244 * attempts to complete a task management request for a remote device.
245 */
246 sci_base_remote_device_request_handler_t complete_task_handler;
247
248};
249
250/**
251 * sci_base_remote_device_construct() - Construct the base remote device
252 * @this_remote_device: This parameter specifies the base remote device to be
253 * constructed.
254 * @state_table: This parameter specifies the table of state definitions to be
255 * utilized for the remote device state machine.
256 *
257 */
258static inline void sci_base_remote_device_construct(
259 struct sci_base_remote_device *base_dev,
260 const struct sci_base_state *state_table)
261{
262 base_dev->parent.private = NULL;
263 sci_base_state_machine_construct(
264 &base_dev->state_machine,
265 &base_dev->parent,
266 state_table,
267 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL
268 );
269
270 sci_base_state_machine_start(
271 &base_dev->state_machine
272 );
273}
274#endif /* _SCI_BASE_REMOTE_DEVICE_H_ */
diff --git a/drivers/scsi/isci/core/scic_sds_controller.c b/drivers/scsi/isci/core/scic_sds_controller.c
index f16a23a2f9e4..7a0c5905cfbe 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.c
+++ b/drivers/scsi/isci/core/scic_sds_controller.c
@@ -1500,13 +1500,13 @@ void scic_sds_controller_link_down(struct scic_sds_controller *scic,
1500 * 1500 *
1501 */ 1501 */
1502static bool scic_sds_controller_has_remote_devices_stopping( 1502static bool scic_sds_controller_has_remote_devices_stopping(
1503 struct scic_sds_controller *this_controller) 1503 struct scic_sds_controller *controller)
1504{ 1504{
1505 u32 index; 1505 u32 index;
1506 1506
1507 for (index = 0; index < this_controller->remote_node_entries; index++) { 1507 for (index = 0; index < controller->remote_node_entries; index++) {
1508 if ((this_controller->device_table[index] != NULL) && 1508 if ((controller->device_table[index] != NULL) &&
1509 (this_controller->device_table[index]->parent.state_machine.current_state_id 1509 (controller->device_table[index]->state_machine.current_state_id
1510 == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING)) 1510 == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING))
1511 return true; 1511 return true;
1512 } 1512 }
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.c b/drivers/scsi/isci/core/scic_sds_remote_device.c
index f0d1c098f9b6..d756216872b5 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.c
@@ -123,7 +123,7 @@ enum sci_status scic_remote_device_da_construct(
123 123
124 sci_base_state_machine_construct( 124 sci_base_state_machine_construct(
125 &sci_dev->ready_substate_machine, 125 &sci_dev->ready_substate_machine,
126 &sci_dev->parent.parent, 126 &sci_dev->parent,
127 scic_sds_stp_remote_device_ready_substate_table, 127 scic_sds_stp_remote_device_ready_substate_table,
128 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE); 128 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
129 } else if (sci_dev->target_protocols.u.bits.attached_smp_target) { 129 } else if (sci_dev->target_protocols.u.bits.attached_smp_target) {
@@ -132,7 +132,7 @@ enum sci_status scic_remote_device_da_construct(
132 /* add the SMP ready substate machine construction here */ 132 /* add the SMP ready substate machine construction here */
133 sci_base_state_machine_construct( 133 sci_base_state_machine_construct(
134 &sci_dev->ready_substate_machine, 134 &sci_dev->ready_substate_machine,
135 &sci_dev->parent.parent, 135 &sci_dev->parent,
136 scic_sds_smp_remote_device_ready_substate_table, 136 scic_sds_smp_remote_device_ready_substate_table,
137 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE); 137 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
138 } 138 }
@@ -187,7 +187,7 @@ enum sci_status scic_remote_device_ea_construct(
187 /* add the SMP ready substate machine construction here */ 187 /* add the SMP ready substate machine construction here */
188 sci_base_state_machine_construct( 188 sci_base_state_machine_construct(
189 &sci_dev->ready_substate_machine, 189 &sci_dev->ready_substate_machine,
190 &sci_dev->parent.parent, 190 &sci_dev->parent,
191 scic_sds_smp_remote_device_ready_substate_table, 191 scic_sds_smp_remote_device_ready_substate_table,
192 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE); 192 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
193 } else if (sci_dev->target_protocols.u.bits.attached_stp_target) { 193 } else if (sci_dev->target_protocols.u.bits.attached_stp_target) {
@@ -195,7 +195,7 @@ enum sci_status scic_remote_device_ea_construct(
195 195
196 sci_base_state_machine_construct( 196 sci_base_state_machine_construct(
197 &sci_dev->ready_substate_machine, 197 &sci_dev->ready_substate_machine,
198 &sci_dev->parent.parent, 198 &sci_dev->parent,
199 scic_sds_stp_remote_device_ready_substate_table, 199 scic_sds_stp_remote_device_ready_substate_table,
200 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE); 200 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
201 } 201 }
@@ -222,7 +222,7 @@ enum sci_status scic_remote_device_ea_construct(
222enum sci_status scic_remote_device_destruct( 222enum sci_status scic_remote_device_destruct(
223 struct scic_sds_remote_device *sci_dev) 223 struct scic_sds_remote_device *sci_dev)
224{ 224{
225 return sci_dev->state_handlers->parent.destruct_handler(&sci_dev->parent); 225 return sci_dev->state_handlers->destruct_handler(sci_dev);
226} 226}
227 227
228 228
@@ -230,7 +230,7 @@ enum sci_status scic_remote_device_start(
230 struct scic_sds_remote_device *sci_dev, 230 struct scic_sds_remote_device *sci_dev,
231 u32 timeout) 231 u32 timeout)
232{ 232{
233 return sci_dev->state_handlers->parent.start_handler(&sci_dev->parent); 233 return sci_dev->state_handlers->start_handler(sci_dev);
234} 234}
235 235
236 236
@@ -238,21 +238,21 @@ enum sci_status scic_remote_device_stop(
238 struct scic_sds_remote_device *sci_dev, 238 struct scic_sds_remote_device *sci_dev,
239 u32 timeout) 239 u32 timeout)
240{ 240{
241 return sci_dev->state_handlers->parent.stop_handler(&sci_dev->parent); 241 return sci_dev->state_handlers->stop_handler(sci_dev);
242} 242}
243 243
244 244
245enum sci_status scic_remote_device_reset( 245enum sci_status scic_remote_device_reset(
246 struct scic_sds_remote_device *sci_dev) 246 struct scic_sds_remote_device *sci_dev)
247{ 247{
248 return sci_dev->state_handlers->parent.reset_handler(&sci_dev->parent); 248 return sci_dev->state_handlers->reset_handler(sci_dev);
249} 249}
250 250
251 251
252enum sci_status scic_remote_device_reset_complete( 252enum sci_status scic_remote_device_reset_complete(
253 struct scic_sds_remote_device *sci_dev) 253 struct scic_sds_remote_device *sci_dev)
254{ 254{
255 return sci_dev->state_handlers->parent.reset_complete_handler(&sci_dev->parent); 255 return sci_dev->state_handlers->reset_complete_handler(sci_dev);
256} 256}
257 257
258 258
@@ -362,8 +362,8 @@ enum sci_status scic_sds_remote_device_start_io(
362 struct scic_sds_remote_device *this_device, 362 struct scic_sds_remote_device *this_device,
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->start_io_handler(
366 &this_device->parent, io_request); 366 this_device, io_request);
367} 367}
368 368
369/** 369/**
@@ -380,8 +380,8 @@ enum sci_status scic_sds_remote_device_complete_io(
380 struct scic_sds_remote_device *this_device, 380 struct scic_sds_remote_device *this_device,
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->complete_io_handler(
384 &this_device->parent, io_request); 384 this_device, io_request);
385} 385}
386 386
387/** 387/**
@@ -398,8 +398,8 @@ enum sci_status scic_sds_remote_device_start_task(
398 struct scic_sds_remote_device *this_device, 398 struct scic_sds_remote_device *this_device,
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->start_task_handler(
402 &this_device->parent, io_request); 402 this_device, io_request);
403} 403}
404 404
405/** 405/**
@@ -491,7 +491,7 @@ static void scic_sds_cb_remote_device_rnc_destruct_complete(
491 491
492 BUG_ON(sci_dev->started_request_count != 0); 492 BUG_ON(sci_dev->started_request_count != 0);
493 493
494 sci_base_state_machine_change_state(&sci_dev->parent.state_machine, 494 sci_base_state_machine_change_state(&sci_dev->state_machine,
495 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED); 495 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
496} 496}
497 497
@@ -511,11 +511,11 @@ static void scic_sds_remote_device_resume_complete_handler(
511 this_device = (struct scic_sds_remote_device *)user_parameter; 511 this_device = (struct scic_sds_remote_device *)user_parameter;
512 512
513 if ( 513 if (
514 sci_base_state_machine_get_state(&this_device->parent.state_machine) 514 sci_base_state_machine_get_state(&this_device->state_machine)
515 != SCI_BASE_REMOTE_DEVICE_STATE_READY 515 != SCI_BASE_REMOTE_DEVICE_STATE_READY
516 ) { 516 ) {
517 sci_base_state_machine_change_state( 517 sci_base_state_machine_change_state(
518 &this_device->parent.state_machine, 518 &this_device->state_machine,
519 SCI_BASE_REMOTE_DEVICE_STATE_READY 519 SCI_BASE_REMOTE_DEVICE_STATE_READY
520 ); 520 );
521 } 521 }
@@ -614,69 +614,67 @@ static enum sci_status scic_sds_remote_device_terminate_requests(
614 return status; 614 return status;
615} 615}
616 616
617static enum sci_status default_device_handler(struct sci_base_remote_device *base_dev, 617static enum sci_status
618 const char *func) 618default_device_handler(struct scic_sds_remote_device *sci_dev,
619 const char *func)
619{ 620{
620 struct scic_sds_remote_device *sci_dev;
621
622 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
623 dev_warn(scirdev_to_dev(sci_dev), 621 dev_warn(scirdev_to_dev(sci_dev),
624 "%s: in wrong state: %d\n", func, 622 "%s: in wrong state: %d\n", func,
625 sci_base_state_machine_get_state(&base_dev->state_machine)); 623 sci_base_state_machine_get_state(&sci_dev->state_machine));
626 return SCI_FAILURE_INVALID_STATE; 624 return SCI_FAILURE_INVALID_STATE;
627} 625}
628 626
629enum sci_status scic_sds_remote_device_default_start_handler( 627enum sci_status scic_sds_remote_device_default_start_handler(
630 struct sci_base_remote_device *base_dev) 628 struct scic_sds_remote_device *sci_dev)
631{ 629{
632 return default_device_handler(base_dev, __func__); 630 return default_device_handler(sci_dev, __func__);
633} 631}
634 632
635static enum sci_status scic_sds_remote_device_default_stop_handler( 633static enum sci_status scic_sds_remote_device_default_stop_handler(
636 struct sci_base_remote_device *base_dev) 634 struct scic_sds_remote_device *sci_dev)
637{ 635{
638 return default_device_handler(base_dev, __func__); 636 return default_device_handler(sci_dev, __func__);
639} 637}
640 638
641enum sci_status scic_sds_remote_device_default_fail_handler( 639enum sci_status scic_sds_remote_device_default_fail_handler(
642 struct sci_base_remote_device *base_dev) 640 struct scic_sds_remote_device *sci_dev)
643{ 641{
644 return default_device_handler(base_dev, __func__); 642 return default_device_handler(sci_dev, __func__);
645} 643}
646 644
647enum sci_status scic_sds_remote_device_default_destruct_handler( 645enum sci_status scic_sds_remote_device_default_destruct_handler(
648 struct sci_base_remote_device *base_dev) 646 struct scic_sds_remote_device *sci_dev)
649{ 647{
650 return default_device_handler(base_dev, __func__); 648 return default_device_handler(sci_dev, __func__);
651} 649}
652 650
653enum sci_status scic_sds_remote_device_default_reset_handler( 651enum sci_status scic_sds_remote_device_default_reset_handler(
654 struct sci_base_remote_device *base_dev) 652 struct scic_sds_remote_device *sci_dev)
655{ 653{
656 return default_device_handler(base_dev, __func__); 654 return default_device_handler(sci_dev, __func__);
657} 655}
658 656
659enum sci_status scic_sds_remote_device_default_reset_complete_handler( 657enum sci_status scic_sds_remote_device_default_reset_complete_handler(
660 struct sci_base_remote_device *base_dev) 658 struct scic_sds_remote_device *sci_dev)
661{ 659{
662 return default_device_handler(base_dev, __func__); 660 return default_device_handler(sci_dev, __func__);
663} 661}
664 662
665enum sci_status scic_sds_remote_device_default_suspend_handler( 663enum sci_status scic_sds_remote_device_default_suspend_handler(
666 struct scic_sds_remote_device *sci_dev, u32 suspend_type) 664 struct scic_sds_remote_device *sci_dev, u32 suspend_type)
667{ 665{
668 return default_device_handler(&sci_dev->parent, __func__); 666 return default_device_handler(sci_dev, __func__);
669} 667}
670 668
671enum sci_status scic_sds_remote_device_default_resume_handler( 669enum sci_status scic_sds_remote_device_default_resume_handler(
672 struct scic_sds_remote_device *sci_dev) 670 struct scic_sds_remote_device *sci_dev)
673{ 671{
674 return default_device_handler(&sci_dev->parent, __func__); 672 return default_device_handler(sci_dev, __func__);
675} 673}
676 674
677/** 675/**
678 * 676 *
679 * @device: The struct sci_base_remote_device which is then cast into a 677 * @device: The struct scic_sds_remote_device which is then cast into a
680 * struct scic_sds_remote_device. 678 * struct scic_sds_remote_device.
681 * @event_code: The event code that the struct scic_sds_controller wants the device 679 * @event_code: The event code that the struct scic_sds_controller wants the device
682 * object to process. 680 * object to process.
@@ -734,7 +732,7 @@ static enum sci_status scic_sds_remote_device_core_event_handler(
734} 732}
735/** 733/**
736 * 734 *
737 * @device: The struct sci_base_remote_device which is then cast into a 735 * @device: The struct scic_sds_remote_device which is then cast into a
738 * struct scic_sds_remote_device. 736 * struct scic_sds_remote_device.
739 * @event_code: The event code that the struct scic_sds_controller wants the device 737 * @event_code: The event code that the struct scic_sds_controller wants the device
740 * object to process. 738 * object to process.
@@ -754,7 +752,7 @@ static enum sci_status scic_sds_remote_device_default_event_handler(
754 752
755/** 753/**
756 * 754 *
757 * @device: The struct sci_base_remote_device which is then cast into a 755 * @device: The struct scic_sds_remote_device which is then cast into a
758 * struct scic_sds_remote_device. 756 * struct scic_sds_remote_device.
759 * @frame_index: The frame index for which the struct scic_sds_controller wants this 757 * @frame_index: The frame index for which the struct scic_sds_controller wants this
760 * device object to process. 758 * device object to process.
@@ -773,7 +771,7 @@ enum sci_status scic_sds_remote_device_default_frame_handler(
773 __func__, 771 __func__,
774 frame_index, 772 frame_index,
775 sci_base_state_machine_get_state( 773 sci_base_state_machine_get_state(
776 &this_device->parent.state_machine)); 774 &this_device->state_machine));
777 775
778 /* Return the frame back to the controller */ 776 /* Return the frame back to the controller */
779 scic_sds_controller_release_frame( 777 scic_sds_controller_release_frame(
@@ -784,29 +782,29 @@ enum sci_status scic_sds_remote_device_default_frame_handler(
784} 782}
785 783
786enum sci_status scic_sds_remote_device_default_start_request_handler( 784enum sci_status scic_sds_remote_device_default_start_request_handler(
787 struct sci_base_remote_device *base_dev, 785 struct scic_sds_remote_device *sci_dev,
788 struct scic_sds_request *request) 786 struct scic_sds_request *request)
789{ 787{
790 return default_device_handler(base_dev, __func__); 788 return default_device_handler(sci_dev, __func__);
791} 789}
792 790
793enum sci_status scic_sds_remote_device_default_complete_request_handler( 791enum sci_status scic_sds_remote_device_default_complete_request_handler(
794 struct sci_base_remote_device *base_dev, 792 struct scic_sds_remote_device *sci_dev,
795 struct scic_sds_request *request) 793 struct scic_sds_request *request)
796{ 794{
797 return default_device_handler(base_dev, __func__); 795 return default_device_handler(sci_dev, __func__);
798} 796}
799 797
800enum sci_status scic_sds_remote_device_default_continue_request_handler( 798enum sci_status scic_sds_remote_device_default_continue_request_handler(
801 struct sci_base_remote_device *base_dev, 799 struct scic_sds_remote_device *sci_dev,
802 struct scic_sds_request *request) 800 struct scic_sds_request *request)
803{ 801{
804 return default_device_handler(base_dev, __func__); 802 return default_device_handler(sci_dev, __func__);
805} 803}
806 804
807/** 805/**
808 * 806 *
809 * @device: The struct sci_base_remote_device which is then cast into a 807 * @device: The struct scic_sds_remote_device which is then cast into a
810 * struct scic_sds_remote_device. 808 * struct scic_sds_remote_device.
811 * @frame_index: The frame index for which the struct scic_sds_controller wants this 809 * @frame_index: The frame index for which the struct scic_sds_controller wants this
812 * device object to process. 810 * device object to process.
@@ -887,32 +885,29 @@ enum sci_status scic_sds_remote_device_general_event_handler(
887 * which to construct the remote device. 885 * which to construct the remote device.
888 */ 886 */
889static enum sci_status scic_sds_remote_device_stopped_state_start_handler( 887static enum sci_status scic_sds_remote_device_stopped_state_start_handler(
890 struct sci_base_remote_device *base_dev) 888 struct scic_sds_remote_device *sci_dev)
891{ 889{
892 enum sci_status status; 890 enum sci_status status;
893 struct scic_sds_remote_device *sci_dev;
894
895 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
896 891
897 status = scic_sds_remote_node_context_resume(sci_dev->rnc, 892 status = scic_sds_remote_node_context_resume(sci_dev->rnc,
898 scic_sds_remote_device_resume_complete_handler, sci_dev); 893 scic_sds_remote_device_resume_complete_handler, sci_dev);
899 894
900 if (status == SCI_SUCCESS) 895 if (status == SCI_SUCCESS)
901 sci_base_state_machine_change_state(&base_dev->state_machine, 896 sci_base_state_machine_change_state(&sci_dev->state_machine,
902 SCI_BASE_REMOTE_DEVICE_STATE_STARTING); 897 SCI_BASE_REMOTE_DEVICE_STATE_STARTING);
903 898
904 return status; 899 return status;
905} 900}
906 901
907static enum sci_status scic_sds_remote_device_stopped_state_stop_handler( 902static enum sci_status scic_sds_remote_device_stopped_state_stop_handler(
908 struct sci_base_remote_device *base_dev) 903 struct scic_sds_remote_device *sci_dev)
909{ 904{
910 return SCI_SUCCESS; 905 return SCI_SUCCESS;
911} 906}
912 907
913/** 908/**
914 * 909 *
915 * @sci_dev: The struct sci_base_remote_device which is cast into a 910 * @sci_dev: The struct scic_sds_remote_device which is cast into a
916 * struct scic_sds_remote_device. 911 * struct scic_sds_remote_device.
917 * 912 *
918 * This method will destruct a struct scic_sds_remote_device that is in a stopped 913 * This method will destruct a struct scic_sds_remote_device that is in a stopped
@@ -922,18 +917,16 @@ static enum sci_status scic_sds_remote_device_stopped_state_stop_handler(
922 * enum sci_status SCI_SUCCESS 917 * enum sci_status SCI_SUCCESS
923 */ 918 */
924static enum sci_status scic_sds_remote_device_stopped_state_destruct_handler( 919static enum sci_status scic_sds_remote_device_stopped_state_destruct_handler(
925 struct sci_base_remote_device *base_dev) 920 struct scic_sds_remote_device *sci_dev)
926{ 921{
927 struct scic_sds_remote_device *sci_dev;
928 struct scic_sds_controller *scic; 922 struct scic_sds_controller *scic;
929 923
930 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
931 scic = scic_sds_remote_device_get_controller(sci_dev); 924 scic = scic_sds_remote_device_get_controller(sci_dev);
932 scic_sds_controller_free_remote_node_context(scic, sci_dev, 925 scic_sds_controller_free_remote_node_context(scic, sci_dev,
933 sci_dev->rnc->remote_node_index); 926 sci_dev->rnc->remote_node_index);
934 sci_dev->rnc->remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX; 927 sci_dev->rnc->remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
935 928
936 sci_base_state_machine_change_state(&base_dev->state_machine, 929 sci_base_state_machine_change_state(&sci_dev->state_machine,
937 SCI_BASE_REMOTE_DEVICE_STATE_FINAL); 930 SCI_BASE_REMOTE_DEVICE_STATE_FINAL);
938 931
939 return SCI_SUCCESS; 932 return SCI_SUCCESS;
@@ -945,11 +938,8 @@ static enum sci_status scic_sds_remote_device_stopped_state_destruct_handler(
945 * ***************************************************************************** */ 938 * ***************************************************************************** */
946 939
947static enum sci_status scic_sds_remote_device_starting_state_stop_handler( 940static enum sci_status scic_sds_remote_device_starting_state_stop_handler(
948 struct sci_base_remote_device *base_dev) 941 struct scic_sds_remote_device *sci_dev)
949{ 942{
950 struct scic_sds_remote_device *sci_dev;
951
952 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
953 /* 943 /*
954 * This device has not yet started so there had better be no IO requests 944 * This device has not yet started so there had better be no IO requests
955 */ 945 */
@@ -965,21 +955,19 @@ static enum sci_status scic_sds_remote_device_starting_state_stop_handler(
965 * Transition to the stopping state and wait for the remote node to 955 * Transition to the stopping state and wait for the remote node to
966 * complete being posted and invalidated. 956 * complete being posted and invalidated.
967 */ 957 */
968 sci_base_state_machine_change_state(&base_dev->state_machine, 958 sci_base_state_machine_change_state(&sci_dev->state_machine,
969 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING); 959 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
970 960
971 return SCI_SUCCESS; 961 return SCI_SUCCESS;
972} 962}
973 963
974enum sci_status scic_sds_remote_device_ready_state_stop_handler( 964enum sci_status scic_sds_remote_device_ready_state_stop_handler(
975 struct sci_base_remote_device *base_dev) 965 struct scic_sds_remote_device *sci_dev)
976{ 966{
977 struct scic_sds_remote_device *sci_dev;
978 enum sci_status status = SCI_SUCCESS; 967 enum sci_status status = SCI_SUCCESS;
979 968
980 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
981 /* Request the parent state machine to transition to the stopping state */ 969 /* Request the parent state machine to transition to the stopping state */
982 sci_base_state_machine_change_state(&base_dev->state_machine, 970 sci_base_state_machine_change_state(&sci_dev->state_machine,
983 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING); 971 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
984 972
985 if (sci_dev->started_request_count == 0) { 973 if (sci_dev->started_request_count == 0) {
@@ -994,19 +982,16 @@ enum sci_status scic_sds_remote_device_ready_state_stop_handler(
994 982
995/** 983/**
996 * 984 *
997 * @device: The struct sci_base_remote_device object which is cast to a 985 * @device: The struct scic_sds_remote_device object which is cast to a
998 * struct scic_sds_remote_device object. 986 * struct scic_sds_remote_device object.
999 * 987 *
1000 * This is the ready state device reset handler enum sci_status 988 * This is the ready state device reset handler enum sci_status
1001 */ 989 */
1002enum sci_status scic_sds_remote_device_ready_state_reset_handler( 990enum sci_status scic_sds_remote_device_ready_state_reset_handler(
1003 struct sci_base_remote_device *base_dev) 991 struct scic_sds_remote_device *sci_dev)
1004{ 992{
1005 struct scic_sds_remote_device *sci_dev;
1006
1007 sci_dev = container_of(base_dev, typeof(*sci_dev), parent);
1008 /* Request the parent state machine to transition to the stopping state */ 993 /* Request the parent state machine to transition to the stopping state */
1009 sci_base_state_machine_change_state(&base_dev->state_machine, 994 sci_base_state_machine_change_state(&sci_dev->state_machine,
1010 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING); 995 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING);
1011 996
1012 return SCI_SUCCESS; 997 return SCI_SUCCESS;
@@ -1021,23 +1006,22 @@ enum sci_status scic_sds_remote_device_ready_state_reset_handler(
1021 * object could not get the resources to start. 1006 * object could not get the resources to start.
1022 */ 1007 */
1023static enum sci_status scic_sds_remote_device_ready_state_start_task_handler( 1008static enum sci_status scic_sds_remote_device_ready_state_start_task_handler(
1024 struct sci_base_remote_device *device, 1009 struct scic_sds_remote_device *sci_dev,
1025 struct scic_sds_request *request) 1010 struct scic_sds_request *request)
1026{ 1011{
1027 enum sci_status result; 1012 enum sci_status result;
1028 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1029 1013
1030 /* See if the port is in a state where we can start the IO request */ 1014 /* See if the port is in a state where we can start the IO request */
1031 result = scic_sds_port_start_io( 1015 result = scic_sds_port_start_io(
1032 scic_sds_remote_device_get_port(this_device), this_device, request); 1016 scic_sds_remote_device_get_port(sci_dev), sci_dev, request);
1033 1017
1034 if (result == SCI_SUCCESS) { 1018 if (result == SCI_SUCCESS) {
1035 result = scic_sds_remote_node_context_start_task( 1019 result = scic_sds_remote_node_context_start_task(
1036 this_device->rnc, request); 1020 sci_dev->rnc, request);
1037 if (result == SCI_SUCCESS) 1021 if (result == SCI_SUCCESS)
1038 result = scic_sds_request_start(request); 1022 result = scic_sds_request_start(request);
1039 1023
1040 scic_sds_remote_device_start_request(this_device, request, result); 1024 scic_sds_remote_device_start_request(sci_dev, request, result);
1041 } 1025 }
1042 1026
1043 return result; 1027 return result;
@@ -1052,23 +1036,22 @@ static enum sci_status scic_sds_remote_device_ready_state_start_task_handler(
1052 * object could not get the resources to start. 1036 * object could not get the resources to start.
1053 */ 1037 */
1054static enum sci_status scic_sds_remote_device_ready_state_start_io_handler( 1038static enum sci_status scic_sds_remote_device_ready_state_start_io_handler(
1055 struct sci_base_remote_device *device, 1039 struct scic_sds_remote_device *sci_dev,
1056 struct scic_sds_request *request) 1040 struct scic_sds_request *request)
1057{ 1041{
1058 enum sci_status result; 1042 enum sci_status result;
1059 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1060 1043
1061 /* See if the port is in a state where we can start the IO request */ 1044 /* See if the port is in a state where we can start the IO request */
1062 result = scic_sds_port_start_io( 1045 result = scic_sds_port_start_io(
1063 scic_sds_remote_device_get_port(this_device), this_device, request); 1046 scic_sds_remote_device_get_port(sci_dev), sci_dev, request);
1064 1047
1065 if (result == SCI_SUCCESS) { 1048 if (result == SCI_SUCCESS) {
1066 result = scic_sds_remote_node_context_start_io( 1049 result = scic_sds_remote_node_context_start_io(
1067 this_device->rnc, request); 1050 sci_dev->rnc, request);
1068 if (result == SCI_SUCCESS) 1051 if (result == SCI_SUCCESS)
1069 result = scic_sds_request_start(request); 1052 result = scic_sds_request_start(request);
1070 1053
1071 scic_sds_remote_device_start_request(this_device, request, result); 1054 scic_sds_remote_device_start_request(sci_dev, request, result);
1072 } 1055 }
1073 1056
1074 return result; 1057 return result;
@@ -1081,23 +1064,24 @@ static enum sci_status scic_sds_remote_device_ready_state_start_io_handler(
1081 * its own started_request_count. enum sci_status 1064 * its own started_request_count. enum sci_status
1082 */ 1065 */
1083static enum sci_status scic_sds_remote_device_ready_state_complete_request_handler( 1066static enum sci_status scic_sds_remote_device_ready_state_complete_request_handler(
1084 struct sci_base_remote_device *device, 1067 struct scic_sds_remote_device *sci_dev,
1085 struct scic_sds_request *request) 1068 struct scic_sds_request *request)
1086{ 1069{
1087 enum sci_status result; 1070 enum sci_status result;
1088 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1089 1071
1090 result = scic_sds_request_complete(request); 1072 result = scic_sds_request_complete(request);
1091 1073
1092 if (result == SCI_SUCCESS) { 1074 if (result != SCI_SUCCESS)
1093 /* See if the port is in a state where we can start the IO request */ 1075 return result;
1094 result = scic_sds_port_complete_io(
1095 scic_sds_remote_device_get_port(this_device), this_device, request);
1096 1076
1097 if (result == SCI_SUCCESS) { 1077 /* See if the port is in a state
1098 scic_sds_remote_device_decrement_request_count(this_device); 1078 * where we can start the IO request */
1099 } 1079 result = scic_sds_port_complete_io(
1100 } 1080 scic_sds_remote_device_get_port(sci_dev),
1081 sci_dev, request);
1082
1083 if (result == SCI_SUCCESS)
1084 scic_sds_remote_device_decrement_request_count(sci_dev);
1101 1085
1102 return result; 1086 return result;
1103} 1087}
@@ -1109,7 +1093,7 @@ static enum sci_status scic_sds_remote_device_ready_state_complete_request_handl
1109 1093
1110/** 1094/**
1111 * 1095 *
1112 * @this_device: The struct sci_base_remote_device which is cast into a 1096 * @this_device: The struct scic_sds_remote_device which is cast into a
1113 * struct scic_sds_remote_device. 1097 * struct scic_sds_remote_device.
1114 * 1098 *
1115 * This method will stop a struct scic_sds_remote_device that is already in the 1099 * This method will stop a struct scic_sds_remote_device that is already in the
@@ -1118,14 +1102,13 @@ static enum sci_status scic_sds_remote_device_ready_state_complete_request_handl
1118 * stopped. enum sci_status SCI_SUCCESS 1102 * stopped. enum sci_status SCI_SUCCESS
1119 */ 1103 */
1120static enum sci_status scic_sds_remote_device_stopping_state_stop_handler( 1104static enum sci_status scic_sds_remote_device_stopping_state_stop_handler(
1121 struct sci_base_remote_device *device) 1105 struct scic_sds_remote_device *device)
1122{ 1106{
1123 /* 1107 /*
1124 * All requests should have been terminated, but if there is an 1108 * All requests should have been terminated, but if there is an
1125 * attempt to stop a device already in the stopping state, then 1109 * attempt to stop a device already in the stopping state, then
1126 * try again to terminate. */ 1110 * try again to terminate. */
1127 return scic_sds_remote_device_terminate_requests( 1111 return scic_sds_remote_device_terminate_requests(device);
1128 (struct scic_sds_remote_device *)device);
1129} 1112}
1130 1113
1131 1114
@@ -1143,54 +1126,44 @@ static enum sci_status scic_sds_remote_device_stopping_state_stop_handler(
1143 * transition to the SCI_BASE_REMOTE_DEVICE_STATE_STOPPED. enum sci_status 1126 * transition to the SCI_BASE_REMOTE_DEVICE_STATE_STOPPED. enum sci_status
1144 */ 1127 */
1145static enum sci_status scic_sds_remote_device_stopping_state_complete_request_handler( 1128static enum sci_status scic_sds_remote_device_stopping_state_complete_request_handler(
1146 struct sci_base_remote_device *device, 1129 struct scic_sds_remote_device *sci_dev,
1147 struct scic_sds_request *request) 1130 struct scic_sds_request *request)
1148{ 1131{
1149 enum sci_status status = SCI_SUCCESS; 1132 enum sci_status status = SCI_SUCCESS;
1150 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1151 1133
1152 status = scic_sds_request_complete(request); 1134 status = scic_sds_request_complete(request);
1153 if (status == SCI_SUCCESS) {
1154 status = scic_sds_port_complete_io(
1155 scic_sds_remote_device_get_port(this_device),
1156 this_device, request);
1157 1135
1158 if (status == SCI_SUCCESS) { 1136 if (status != SCI_SUCCESS)
1159 scic_sds_remote_device_decrement_request_count(this_device); 1137 return status;
1160
1161 if (scic_sds_remote_device_get_request_count(this_device) == 0) {
1162 scic_sds_remote_node_context_destruct(
1163 this_device->rnc,
1164 scic_sds_cb_remote_device_rnc_destruct_complete,
1165 this_device
1166 );
1167 }
1168 }
1169 }
1170 1138
1171 return status; 1139 status = scic_sds_port_complete_io(scic_sds_remote_device_get_port(sci_dev),
1172} 1140 sci_dev, request);
1141 if (status != SCI_SUCCESS)
1142 return status;
1173 1143
1174/* 1144 scic_sds_remote_device_decrement_request_count(sci_dev);
1175 * ***************************************************************************** 1145
1176 * * RESETTING STATE HANDLERS 1146 if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
1177 * ***************************************************************************** */ 1147 scic_sds_remote_node_context_destruct(sci_dev->rnc,
1148 scic_sds_cb_remote_device_rnc_destruct_complete,
1149 sci_dev);
1150 return SCI_SUCCESS;
1151}
1178 1152
1179/** 1153/**
1180 * 1154 *
1181 * @device: The struct sci_base_remote_device which is to be cast into a 1155 * @device: The struct scic_sds_remote_device which is to be cast into a
1182 * struct scic_sds_remote_device object. 1156 * struct scic_sds_remote_device object.
1183 * 1157 *
1184 * This method will complete the reset operation when the device is in the 1158 * This method will complete the reset operation when the device is in the
1185 * resetting state. enum sci_status 1159 * resetting state. enum sci_status
1186 */ 1160 */
1187static enum sci_status scic_sds_remote_device_resetting_state_reset_complete_handler( 1161static enum sci_status scic_sds_remote_device_resetting_state_reset_complete_handler(
1188 struct sci_base_remote_device *device) 1162 struct scic_sds_remote_device *sci_dev)
1189{ 1163{
1190 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1191 1164
1192 sci_base_state_machine_change_state( 1165 sci_base_state_machine_change_state(
1193 &this_device->parent.state_machine, 1166 &sci_dev->state_machine,
1194 SCI_BASE_REMOTE_DEVICE_STATE_READY 1167 SCI_BASE_REMOTE_DEVICE_STATE_READY
1195 ); 1168 );
1196 1169
@@ -1199,19 +1172,17 @@ static enum sci_status scic_sds_remote_device_resetting_state_reset_complete_han
1199 1172
1200/** 1173/**
1201 * 1174 *
1202 * @device: The struct sci_base_remote_device which is to be cast into a 1175 * @device: The struct scic_sds_remote_device which is to be cast into a
1203 * struct scic_sds_remote_device object. 1176 * struct scic_sds_remote_device object.
1204 * 1177 *
1205 * This method will stop the remote device while in the resetting state. 1178 * This method will stop the remote device while in the resetting state.
1206 * enum sci_status 1179 * enum sci_status
1207 */ 1180 */
1208static enum sci_status scic_sds_remote_device_resetting_state_stop_handler( 1181static enum sci_status scic_sds_remote_device_resetting_state_stop_handler(
1209 struct sci_base_remote_device *device) 1182 struct scic_sds_remote_device *sci_dev)
1210{ 1183{
1211 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1212
1213 sci_base_state_machine_change_state( 1184 sci_base_state_machine_change_state(
1214 &this_device->parent.state_machine, 1185 &sci_dev->state_machine,
1215 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING 1186 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
1216 ); 1187 );
1217 1188
@@ -1226,20 +1197,20 @@ static enum sci_status scic_sds_remote_device_resetting_state_stop_handler(
1226 * completes the task request. enum sci_status 1197 * completes the task request. enum sci_status
1227 */ 1198 */
1228static enum sci_status scic_sds_remote_device_resetting_state_complete_request_handler( 1199static enum sci_status scic_sds_remote_device_resetting_state_complete_request_handler(
1229 struct sci_base_remote_device *device, 1200 struct scic_sds_remote_device *sci_dev,
1230 struct scic_sds_request *request) 1201 struct scic_sds_request *request)
1231{ 1202{
1232 enum sci_status status = SCI_SUCCESS; 1203 enum sci_status status = SCI_SUCCESS;
1233 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
1234 1204
1235 status = scic_sds_request_complete(request); 1205 status = scic_sds_request_complete(request);
1236 1206
1237 if (status == SCI_SUCCESS) { 1207 if (status == SCI_SUCCESS) {
1238 status = scic_sds_port_complete_io( 1208 status = scic_sds_port_complete_io(
1239 scic_sds_remote_device_get_port(this_device), this_device, request); 1209 scic_sds_remote_device_get_port(sci_dev),
1210 sci_dev, request);
1240 1211
1241 if (status == SCI_SUCCESS) { 1212 if (status == SCI_SUCCESS) {
1242 scic_sds_remote_device_decrement_request_count(this_device); 1213 scic_sds_remote_device_decrement_request_count(sci_dev);
1243 } 1214 }
1244 } 1215 }
1245 1216
@@ -1253,7 +1224,7 @@ static enum sci_status scic_sds_remote_device_resetting_state_complete_request_h
1253 1224
1254/** 1225/**
1255 * 1226 *
1256 * @device: The struct sci_base_remote_device which is to be cast into a 1227 * @device: The struct scic_sds_remote_device which is to be cast into a
1257 * struct scic_sds_remote_device object. 1228 * struct scic_sds_remote_device object.
1258 * 1229 *
1259 * This method handles the remove request for a failed struct scic_sds_remote_device 1230 * This method handles the remove request for a failed struct scic_sds_remote_device
@@ -1265,140 +1236,140 @@ static enum sci_status scic_sds_remote_device_resetting_state_complete_request_h
1265 1236
1266static const struct scic_sds_remote_device_state_handler scic_sds_remote_device_state_handler_table[] = { 1237static const struct scic_sds_remote_device_state_handler scic_sds_remote_device_state_handler_table[] = {
1267 [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = { 1238 [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = {
1268 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1239 .start_handler = scic_sds_remote_device_default_start_handler,
1269 .parent.stop_handler = scic_sds_remote_device_default_stop_handler, 1240 .stop_handler = scic_sds_remote_device_default_stop_handler,
1270 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1241 .fail_handler = scic_sds_remote_device_default_fail_handler,
1271 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1242 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1272 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1243 .reset_handler = scic_sds_remote_device_default_reset_handler,
1273 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1244 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1274 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1245 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1275 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 1246 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
1276 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1247 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1277 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1248 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1278 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 1249 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
1279 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1250 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1280 .resume_handler = scic_sds_remote_device_default_resume_handler, 1251 .resume_handler = scic_sds_remote_device_default_resume_handler,
1281 .event_handler = scic_sds_remote_device_default_event_handler, 1252 .event_handler = scic_sds_remote_device_default_event_handler,
1282 .frame_handler = scic_sds_remote_device_default_frame_handler 1253 .frame_handler = scic_sds_remote_device_default_frame_handler
1283 }, 1254 },
1284 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = { 1255 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = {
1285 .parent.start_handler = scic_sds_remote_device_stopped_state_start_handler, 1256 .start_handler = scic_sds_remote_device_stopped_state_start_handler,
1286 .parent.stop_handler = scic_sds_remote_device_stopped_state_stop_handler, 1257 .stop_handler = scic_sds_remote_device_stopped_state_stop_handler,
1287 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1258 .fail_handler = scic_sds_remote_device_default_fail_handler,
1288 .parent.destruct_handler = scic_sds_remote_device_stopped_state_destruct_handler, 1259 .destruct_handler = scic_sds_remote_device_stopped_state_destruct_handler,
1289 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1260 .reset_handler = scic_sds_remote_device_default_reset_handler,
1290 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1261 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1291 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1262 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1292 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 1263 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
1293 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1264 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1294 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1265 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1295 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 1266 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
1296 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1267 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1297 .resume_handler = scic_sds_remote_device_default_resume_handler, 1268 .resume_handler = scic_sds_remote_device_default_resume_handler,
1298 .event_handler = scic_sds_remote_device_default_event_handler, 1269 .event_handler = scic_sds_remote_device_default_event_handler,
1299 .frame_handler = scic_sds_remote_device_default_frame_handler 1270 .frame_handler = scic_sds_remote_device_default_frame_handler
1300 }, 1271 },
1301 [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = { 1272 [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = {
1302 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1273 .start_handler = scic_sds_remote_device_default_start_handler,
1303 .parent.stop_handler = scic_sds_remote_device_starting_state_stop_handler, 1274 .stop_handler = scic_sds_remote_device_starting_state_stop_handler,
1304 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1275 .fail_handler = scic_sds_remote_device_default_fail_handler,
1305 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1276 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1306 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1277 .reset_handler = scic_sds_remote_device_default_reset_handler,
1307 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1278 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1308 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1279 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1309 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 1280 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
1310 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1281 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1311 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1282 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1312 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 1283 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
1313 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1284 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1314 .resume_handler = scic_sds_remote_device_default_resume_handler, 1285 .resume_handler = scic_sds_remote_device_default_resume_handler,
1315 .event_handler = scic_sds_remote_device_general_event_handler, 1286 .event_handler = scic_sds_remote_device_general_event_handler,
1316 .frame_handler = scic_sds_remote_device_default_frame_handler 1287 .frame_handler = scic_sds_remote_device_default_frame_handler
1317 }, 1288 },
1318 [SCI_BASE_REMOTE_DEVICE_STATE_READY] = { 1289 [SCI_BASE_REMOTE_DEVICE_STATE_READY] = {
1319 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1290 .start_handler = scic_sds_remote_device_default_start_handler,
1320 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 1291 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
1321 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1292 .fail_handler = scic_sds_remote_device_default_fail_handler,
1322 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1293 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1323 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 1294 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
1324 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1295 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1325 .parent.start_io_handler = scic_sds_remote_device_ready_state_start_io_handler, 1296 .start_io_handler = scic_sds_remote_device_ready_state_start_io_handler,
1326 .parent.complete_io_handler = scic_sds_remote_device_ready_state_complete_request_handler, 1297 .complete_io_handler = scic_sds_remote_device_ready_state_complete_request_handler,
1327 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1298 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1328 .parent.start_task_handler = scic_sds_remote_device_ready_state_start_task_handler, 1299 .start_task_handler = scic_sds_remote_device_ready_state_start_task_handler,
1329 .parent.complete_task_handler = scic_sds_remote_device_ready_state_complete_request_handler, 1300 .complete_task_handler = scic_sds_remote_device_ready_state_complete_request_handler,
1330 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1301 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1331 .resume_handler = scic_sds_remote_device_default_resume_handler, 1302 .resume_handler = scic_sds_remote_device_default_resume_handler,
1332 .event_handler = scic_sds_remote_device_general_event_handler, 1303 .event_handler = scic_sds_remote_device_general_event_handler,
1333 .frame_handler = scic_sds_remote_device_general_frame_handler, 1304 .frame_handler = scic_sds_remote_device_general_frame_handler,
1334 }, 1305 },
1335 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = { 1306 [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = {
1336 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1307 .start_handler = scic_sds_remote_device_default_start_handler,
1337 .parent.stop_handler = scic_sds_remote_device_stopping_state_stop_handler, 1308 .stop_handler = scic_sds_remote_device_stopping_state_stop_handler,
1338 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1309 .fail_handler = scic_sds_remote_device_default_fail_handler,
1339 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1310 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1340 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1311 .reset_handler = scic_sds_remote_device_default_reset_handler,
1341 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1312 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1342 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1313 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1343 .parent.complete_io_handler = scic_sds_remote_device_stopping_state_complete_request_handler, 1314 .complete_io_handler = scic_sds_remote_device_stopping_state_complete_request_handler,
1344 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1315 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1345 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1316 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1346 .parent.complete_task_handler = scic_sds_remote_device_stopping_state_complete_request_handler, 1317 .complete_task_handler = scic_sds_remote_device_stopping_state_complete_request_handler,
1347 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1318 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1348 .resume_handler = scic_sds_remote_device_default_resume_handler, 1319 .resume_handler = scic_sds_remote_device_default_resume_handler,
1349 .event_handler = scic_sds_remote_device_general_event_handler, 1320 .event_handler = scic_sds_remote_device_general_event_handler,
1350 .frame_handler = scic_sds_remote_device_general_frame_handler 1321 .frame_handler = scic_sds_remote_device_general_frame_handler
1351 }, 1322 },
1352 [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = { 1323 [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = {
1353 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1324 .start_handler = scic_sds_remote_device_default_start_handler,
1354 .parent.stop_handler = scic_sds_remote_device_default_stop_handler, 1325 .stop_handler = scic_sds_remote_device_default_stop_handler,
1355 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1326 .fail_handler = scic_sds_remote_device_default_fail_handler,
1356 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1327 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1357 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1328 .reset_handler = scic_sds_remote_device_default_reset_handler,
1358 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1329 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1359 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1330 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1360 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 1331 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
1361 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1332 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1362 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1333 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1363 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 1334 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
1364 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1335 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1365 .resume_handler = scic_sds_remote_device_default_resume_handler, 1336 .resume_handler = scic_sds_remote_device_default_resume_handler,
1366 .event_handler = scic_sds_remote_device_default_event_handler, 1337 .event_handler = scic_sds_remote_device_default_event_handler,
1367 .frame_handler = scic_sds_remote_device_general_frame_handler 1338 .frame_handler = scic_sds_remote_device_general_frame_handler
1368 }, 1339 },
1369 [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = { 1340 [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = {
1370 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1341 .start_handler = scic_sds_remote_device_default_start_handler,
1371 .parent.stop_handler = scic_sds_remote_device_resetting_state_stop_handler, 1342 .stop_handler = scic_sds_remote_device_resetting_state_stop_handler,
1372 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1343 .fail_handler = scic_sds_remote_device_default_fail_handler,
1373 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1344 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1374 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1345 .reset_handler = scic_sds_remote_device_default_reset_handler,
1375 .parent.reset_complete_handler = scic_sds_remote_device_resetting_state_reset_complete_handler, 1346 .reset_complete_handler = scic_sds_remote_device_resetting_state_reset_complete_handler,
1376 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1347 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1377 .parent.complete_io_handler = scic_sds_remote_device_resetting_state_complete_request_handler, 1348 .complete_io_handler = scic_sds_remote_device_resetting_state_complete_request_handler,
1378 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1349 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1379 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1350 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1380 .parent.complete_task_handler = scic_sds_remote_device_resetting_state_complete_request_handler, 1351 .complete_task_handler = scic_sds_remote_device_resetting_state_complete_request_handler,
1381 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1352 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1382 .resume_handler = scic_sds_remote_device_default_resume_handler, 1353 .resume_handler = scic_sds_remote_device_default_resume_handler,
1383 .event_handler = scic_sds_remote_device_default_event_handler, 1354 .event_handler = scic_sds_remote_device_default_event_handler,
1384 .frame_handler = scic_sds_remote_device_general_frame_handler 1355 .frame_handler = scic_sds_remote_device_general_frame_handler
1385 }, 1356 },
1386 [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = { 1357 [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = {
1387 .parent.start_handler = scic_sds_remote_device_default_start_handler, 1358 .start_handler = scic_sds_remote_device_default_start_handler,
1388 .parent.stop_handler = scic_sds_remote_device_default_stop_handler, 1359 .stop_handler = scic_sds_remote_device_default_stop_handler,
1389 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 1360 .fail_handler = scic_sds_remote_device_default_fail_handler,
1390 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 1361 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
1391 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 1362 .reset_handler = scic_sds_remote_device_default_reset_handler,
1392 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 1363 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
1393 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 1364 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
1394 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 1365 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
1395 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 1366 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
1396 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 1367 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
1397 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 1368 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
1398 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 1369 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
1399 .resume_handler = scic_sds_remote_device_default_resume_handler, 1370 .resume_handler = scic_sds_remote_device_default_resume_handler,
1400 .event_handler = scic_sds_remote_device_default_event_handler, 1371 .event_handler = scic_sds_remote_device_default_event_handler,
1401 .frame_handler = scic_sds_remote_device_default_frame_handler 1372 .frame_handler = scic_sds_remote_device_default_frame_handler
1402 } 1373 }
1403}; 1374};
1404 1375
@@ -1415,12 +1386,12 @@ static void scic_sds_remote_device_initial_state_enter(
1415{ 1386{
1416 struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object; 1387 struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
1417 1388
1418 sci_dev = container_of(object, typeof(*sci_dev), parent.parent); 1389 sci_dev = container_of(object, typeof(*sci_dev), parent);
1419 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table, 1390 SET_STATE_HANDLER(sci_dev, scic_sds_remote_device_state_handler_table,
1420 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL); 1391 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL);
1421 1392
1422 /* Initial state is a transitional state to the stopped state */ 1393 /* Initial state is a transitional state to the stopped state */
1423 sci_base_state_machine_change_state(&sci_dev->parent.state_machine, 1394 sci_base_state_machine_change_state(&sci_dev->state_machine,
1424 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED); 1395 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
1425} 1396}
1426 1397
@@ -1443,7 +1414,7 @@ static void scic_sds_remote_device_stopped_state_enter(
1443 struct isci_host *ihost; 1414 struct isci_host *ihost;
1444 u32 prev_state; 1415 u32 prev_state;
1445 1416
1446 sci_dev = container_of(object, typeof(*sci_dev), parent.parent); 1417 sci_dev = container_of(object, typeof(*sci_dev), parent);
1447 scic = scic_sds_remote_device_get_controller(sci_dev); 1418 scic = scic_sds_remote_device_get_controller(sci_dev);
1448 ihost = sci_object_get_association(scic); 1419 ihost = sci_object_get_association(scic);
1449 idev = sci_object_get_association(sci_dev); 1420 idev = sci_object_get_association(sci_dev);
@@ -1454,7 +1425,7 @@ static void scic_sds_remote_device_stopped_state_enter(
1454 /* If we are entering from the stopping state let the SCI User know that 1425 /* If we are entering from the stopping state let the SCI User know that
1455 * the stop operation has completed. 1426 * the stop operation has completed.
1456 */ 1427 */
1457 prev_state = sci_dev->parent.state_machine.previous_state_id; 1428 prev_state = sci_dev->state_machine.previous_state_id;
1458 if (prev_state == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING) 1429 if (prev_state == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING)
1459 isci_remote_device_stop_complete(ihost, idev, SCI_SUCCESS); 1430 isci_remote_device_stop_complete(ihost, idev, SCI_SUCCESS);
1460 1431
@@ -1473,7 +1444,7 @@ static void scic_sds_remote_device_stopped_state_enter(
1473static void scic_sds_remote_device_starting_state_enter(struct sci_base_object *object) 1444static void scic_sds_remote_device_starting_state_enter(struct sci_base_object *object)
1474{ 1445{
1475 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 1446 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
1476 parent.parent); 1447 parent);
1477 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 1448 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1478 struct isci_host *ihost = sci_object_get_association(scic); 1449 struct isci_host *ihost = sci_object_get_association(scic);
1479 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 1450 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -1488,7 +1459,7 @@ static void scic_sds_remote_device_starting_state_enter(struct sci_base_object *
1488static void scic_sds_remote_device_starting_state_exit(struct sci_base_object *object) 1459static void scic_sds_remote_device_starting_state_exit(struct sci_base_object *object)
1489{ 1460{
1490 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 1461 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
1491 parent.parent); 1462 parent);
1492 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 1463 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1493 struct isci_host *ihost = sci_object_get_association(scic); 1464 struct isci_host *ihost = sci_object_get_association(scic);
1494 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 1465 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -1511,7 +1482,7 @@ static void scic_sds_remote_device_starting_state_exit(struct sci_base_object *o
1511static void scic_sds_remote_device_ready_state_enter(struct sci_base_object *object) 1482static void scic_sds_remote_device_ready_state_enter(struct sci_base_object *object)
1512{ 1483{
1513 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 1484 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
1514 parent.parent); 1485 parent);
1515 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 1486 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
1516 struct isci_host *ihost = sci_object_get_association(scic); 1487 struct isci_host *ihost = sci_object_get_association(scic);
1517 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 1488 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -1540,7 +1511,7 @@ static void scic_sds_remote_device_ready_state_exit(
1540 struct sci_base_object *object) 1511 struct sci_base_object *object)
1541{ 1512{
1542 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 1513 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
1543 parent.parent); 1514 parent);
1544 if (sci_dev->has_ready_substate_machine) 1515 if (sci_dev->has_ready_substate_machine)
1545 sci_base_state_machine_stop(&sci_dev->ready_substate_machine); 1516 sci_base_state_machine_stop(&sci_dev->ready_substate_machine);
1546 else { 1517 else {
@@ -1691,10 +1662,17 @@ void scic_remote_device_construct(struct scic_sds_port *sci_port,
1691 sci_dev->owning_port = sci_port; 1662 sci_dev->owning_port = sci_port;
1692 sci_dev->started_request_count = 0; 1663 sci_dev->started_request_count = 0;
1693 sci_dev->rnc = (struct scic_sds_remote_node_context *) &sci_dev[1]; 1664 sci_dev->rnc = (struct scic_sds_remote_node_context *) &sci_dev[1];
1665 sci_dev->parent.private = NULL;
1694 1666
1695 sci_base_remote_device_construct( 1667 sci_base_state_machine_construct(
1668 &sci_dev->state_machine,
1696 &sci_dev->parent, 1669 &sci_dev->parent,
1697 scic_sds_remote_device_state_table 1670 scic_sds_remote_device_state_table,
1671 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL
1672 );
1673
1674 sci_base_state_machine_start(
1675 &sci_dev->state_machine
1698 ); 1676 );
1699 1677
1700 scic_sds_remote_node_context_construct( 1678 scic_sds_remote_node_context_construct(
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.h b/drivers/scsi/isci/core/scic_sds_remote_device.h
index 90b231833872..0e8bb0f98b1e 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.h
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.h
@@ -56,22 +56,74 @@
56#ifndef _SCIC_SDS_REMOTE_DEVICE_H_ 56#ifndef _SCIC_SDS_REMOTE_DEVICE_H_
57#define _SCIC_SDS_REMOTE_DEVICE_H_ 57#define _SCIC_SDS_REMOTE_DEVICE_H_
58 58
59#include "intel_sas.h"
60#include "scu_remote_node_context.h"
61#include "scic_sds_remote_node_context.h"
62
59/** 63/**
60 * This file contains the structures, constants, and prototypes for the 64 * enum scic_sds_remote_device_states - This enumeration depicts all the states
61 * struct scic_sds_remote_device object. 65 * for the common remote device state machine.
62 * 66 *
63 * 67 *
64 */ 68 */
69enum scic_sds_remote_device_states {
70 /**
71 * Simply the initial state for the base remote device state machine.
72 */
73 SCI_BASE_REMOTE_DEVICE_STATE_INITIAL,
65 74
66#include "intel_sas.h" 75 /**
67#include "sci_base_remote_device.h" 76 * This state indicates that the remote device has successfully been
68#include "scu_remote_node_context.h" 77 * stopped. In this state no new IO operations are permitted.
69#include "scic_sds_remote_node_context.h" 78 * This state is entered from the INITIAL state.
79 * This state is entered from the STOPPING state.
80 */
81 SCI_BASE_REMOTE_DEVICE_STATE_STOPPED,
82
83 /**
84 * This state indicates the the remote device is in the process of
85 * becoming ready (i.e. starting). In this state no new IO operations
86 * are permitted.
87 * This state is entered from the STOPPED state.
88 */
89 SCI_BASE_REMOTE_DEVICE_STATE_STARTING,
90
91 /**
92 * This state indicates the remote device is now ready. Thus, the user
93 * is able to perform IO operations on the remote device.
94 * This state is entered from the STARTING state.
95 */
96 SCI_BASE_REMOTE_DEVICE_STATE_READY,
97
98 /**
99 * This state indicates that the remote device is in the process of
100 * stopping. In this state no new IO operations are permitted, but
101 * existing IO operations are allowed to complete.
102 * This state is entered from the READY state.
103 * This state is entered from the FAILED state.
104 */
105 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING,
106
107 /**
108 * This state indicates that the remote device has failed.
109 * In this state no new IO operations are permitted.
110 * This state is entered from the INITIALIZING state.
111 * This state is entered from the READY state.
112 */
113 SCI_BASE_REMOTE_DEVICE_STATE_FAILED,
70 114
71struct scic_sds_controller; 115 /**
72struct scic_sds_port; 116 * This state indicates the device is being reset.
73struct scic_sds_request; 117 * In this state no new IO operations are permitted.
74struct scic_sds_remote_device_state_handler; 118 * This state is entered from the READY state.
119 */
120 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING,
121
122 /**
123 * Simply the final state for the base remote device state machine.
124 */
125 SCI_BASE_REMOTE_DEVICE_STATE_FINAL,
126};
75 127
76/** 128/**
77 * enum scic_sds_ssp_remote_device_ready_substates - 129 * enum scic_sds_ssp_remote_device_ready_substates -
@@ -186,14 +238,21 @@ enum scic_sds_smp_remote_device_ready_substates {
186 */ 238 */
187struct scic_sds_remote_device { 239struct scic_sds_remote_device {
188 /** 240 /**
189 * This field is the common base for all remote device objects. 241 * The field specifies that the parent object for the base remote
242 * device is the base object itself.
243 */
244 struct sci_base_object parent;
245
246 /**
247 * This field contains the information for the base remote device state
248 * machine.
190 */ 249 */
191 struct sci_base_remote_device parent; 250 struct sci_base_state_machine state_machine;
192 251
193 /** 252 /**
194 * This field is the programmed device port width. This value is written to 253 * This field is the programmed device port width. This value is
195 * the RCN data structure to tell the SCU how many open connections this 254 * written to the RCN data structure to tell the SCU how many open
196 * device can have. 255 * connections this device can have.
197 */ 256 */
198 u32 device_port_width; 257 u32 device_port_width;
199 258
@@ -279,6 +338,16 @@ struct scic_sds_remote_device {
279 const struct scic_sds_remote_device_state_handler *state_handlers; 338 const struct scic_sds_remote_device_state_handler *state_handlers;
280}; 339};
281 340
341typedef enum sci_status (*scic_sds_remote_device_request_handler_t)(
342 struct scic_sds_remote_device *device,
343 struct scic_sds_request *request);
344
345typedef enum sci_status (*scic_sds_remote_device_high_priority_request_complete_handler_t)(
346 struct scic_sds_remote_device *device,
347 struct scic_sds_request *request,
348 void *,
349 enum sci_io_status);
350
282typedef enum sci_status (*scic_sds_remote_device_handler_t)( 351typedef enum sci_status (*scic_sds_remote_device_handler_t)(
283 struct scic_sds_remote_device *this_device); 352 struct scic_sds_remote_device *this_device);
284 353
@@ -308,7 +377,74 @@ typedef void (*scic_sds_remote_device_ready_not_ready_handler_t)(
308 * 377 *
309 */ 378 */
310struct scic_sds_remote_device_state_handler { 379struct scic_sds_remote_device_state_handler {
311 struct sci_base_remote_device_state_handler parent; 380 /**
381 * The start_handler specifies the method invoked when a user
382 * attempts to start a remote device.
383 */
384 scic_sds_remote_device_handler_t start_handler;
385
386 /**
387 * The stop_handler specifies the method invoked when a user attempts to
388 * stop a remote device.
389 */
390 scic_sds_remote_device_handler_t stop_handler;
391
392 /**
393 * The fail_handler specifies the method invoked when a remote device
394 * failure has occurred. A failure may be due to an inability to
395 * initialize/configure the device.
396 */
397 scic_sds_remote_device_handler_t fail_handler;
398
399 /**
400 * The destruct_handler specifies the method invoked when attempting to
401 * destruct a remote device.
402 */
403 scic_sds_remote_device_handler_t destruct_handler;
404
405 /**
406 * The reset handler specifies the method invloked when requesting to
407 * reset a remote device.
408 */
409 scic_sds_remote_device_handler_t reset_handler;
410
411 /**
412 * The reset complete handler specifies the method invloked when
413 * reporting that a reset has completed to the remote device.
414 */
415 scic_sds_remote_device_handler_t reset_complete_handler;
416
417 /**
418 * The start_io_handler specifies the method invoked when a user
419 * attempts to start an IO request for a remote device.
420 */
421 scic_sds_remote_device_request_handler_t start_io_handler;
422
423 /**
424 * The complete_io_handler specifies the method invoked when a user
425 * attempts to complete an IO request for a remote device.
426 */
427 scic_sds_remote_device_request_handler_t complete_io_handler;
428
429 /**
430 * The continue_io_handler specifies the method invoked when a user
431 * attempts to continue an IO request for a remote device.
432 */
433 scic_sds_remote_device_request_handler_t continue_io_handler;
434
435 /**
436 * The start_task_handler specifies the method invoked when a user
437 * attempts to start a task management request for a remote device.
438 */
439 scic_sds_remote_device_request_handler_t start_task_handler;
440
441 /**
442 * The complete_task_handler specifies the method invoked when a user
443 * attempts to complete a task management request for a remote device.
444 */
445 scic_sds_remote_device_request_handler_t complete_task_handler;
446
447
312 scic_sds_remote_device_suspend_handler_t suspend_handler; 448 scic_sds_remote_device_suspend_handler_t suspend_handler;
313 scic_sds_remote_device_resume_handler_t resume_handler; 449 scic_sds_remote_device_resume_handler_t resume_handler;
314 scic_sds_remote_device_event_handler_t event_handler; 450 scic_sds_remote_device_event_handler_t event_handler;
@@ -490,30 +626,30 @@ void scic_sds_remote_device_start_request(
490void scic_sds_remote_device_continue_request(void *sci_dev); 626void scic_sds_remote_device_continue_request(void *sci_dev);
491 627
492enum sci_status scic_sds_remote_device_default_start_handler( 628enum sci_status scic_sds_remote_device_default_start_handler(
493 struct sci_base_remote_device *this_device); 629 struct scic_sds_remote_device *this_device);
494 630
495enum sci_status scic_sds_remote_device_default_fail_handler( 631enum sci_status scic_sds_remote_device_default_fail_handler(
496 struct sci_base_remote_device *this_device); 632 struct scic_sds_remote_device *this_device);
497 633
498enum sci_status scic_sds_remote_device_default_destruct_handler( 634enum sci_status scic_sds_remote_device_default_destruct_handler(
499 struct sci_base_remote_device *this_device); 635 struct scic_sds_remote_device *this_device);
500 636
501enum sci_status scic_sds_remote_device_default_reset_handler( 637enum sci_status scic_sds_remote_device_default_reset_handler(
502 struct sci_base_remote_device *device); 638 struct scic_sds_remote_device *device);
503 639
504enum sci_status scic_sds_remote_device_default_reset_complete_handler( 640enum sci_status scic_sds_remote_device_default_reset_complete_handler(
505 struct sci_base_remote_device *device); 641 struct scic_sds_remote_device *device);
506 642
507enum sci_status scic_sds_remote_device_default_start_request_handler( 643enum sci_status scic_sds_remote_device_default_start_request_handler(
508 struct sci_base_remote_device *device, 644 struct scic_sds_remote_device *device,
509 struct scic_sds_request *request); 645 struct scic_sds_request *request);
510 646
511enum sci_status scic_sds_remote_device_default_complete_request_handler( 647enum sci_status scic_sds_remote_device_default_complete_request_handler(
512 struct sci_base_remote_device *device, 648 struct scic_sds_remote_device *device,
513 struct scic_sds_request *request); 649 struct scic_sds_request *request);
514 650
515enum sci_status scic_sds_remote_device_default_continue_request_handler( 651enum sci_status scic_sds_remote_device_default_continue_request_handler(
516 struct sci_base_remote_device *device, 652 struct scic_sds_remote_device *device,
517 struct scic_sds_request *request); 653 struct scic_sds_request *request);
518 654
519enum sci_status scic_sds_remote_device_default_suspend_handler( 655enum sci_status scic_sds_remote_device_default_suspend_handler(
@@ -529,10 +665,10 @@ enum sci_status scic_sds_remote_device_default_frame_handler(
529 u32 frame_index); 665 u32 frame_index);
530 666
531enum sci_status scic_sds_remote_device_ready_state_stop_handler( 667enum sci_status scic_sds_remote_device_ready_state_stop_handler(
532 struct sci_base_remote_device *device); 668 struct scic_sds_remote_device *device);
533 669
534enum sci_status scic_sds_remote_device_ready_state_reset_handler( 670enum sci_status scic_sds_remote_device_ready_state_reset_handler(
535 struct sci_base_remote_device *device); 671 struct scic_sds_remote_device *device);
536 672
537enum sci_status scic_sds_remote_device_general_frame_handler( 673enum sci_status scic_sds_remote_device_general_frame_handler(
538 struct scic_sds_remote_device *this_device, 674 struct scic_sds_remote_device *this_device,
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 040a3d8c08b9..88c359548c1b 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
@@ -77,33 +77,32 @@
77 * the idle state. enum sci_status 77 * the idle state. enum sci_status
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 scic_sds_remote_device *device,
81 struct scic_sds_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;
85 84
86 /* Will the port allow the io request to start? */ 85 /* Will the port allow the io request to start? */
87 status = this_device->owning_port->state_handlers->start_io_handler( 86 status = device->owning_port->state_handlers->start_io_handler(
88 this_device->owning_port, this_device, request); 87 device->owning_port, device, request);
89 88
90 if (status == SCI_SUCCESS) { 89 if (status == SCI_SUCCESS) {
91 status = 90 status = scic_sds_remote_node_context_start_io(
92 scic_sds_remote_node_context_start_io(this_device->rnc, request); 91 device->rnc, request);
93 92
94 if (status == SCI_SUCCESS) 93 if (status == SCI_SUCCESS)
95 status = scic_sds_request_start(request); 94 status = scic_sds_request_start(request);
96 95
97 if (status == SCI_SUCCESS) { 96 if (status == SCI_SUCCESS) {
98 this_device->working_request = request; 97 device->working_request = request;
99 98
100 sci_base_state_machine_change_state( 99 sci_base_state_machine_change_state(
101 &this_device->ready_substate_machine, 100 &device->ready_substate_machine,
102 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD 101 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD
103 ); 102 );
104 } 103 }
105 104
106 scic_sds_remote_device_start_request(this_device, request, status); 105 scic_sds_remote_device_start_request(device, request, status);
107 } 106 }
108 107
109 return status; 108 return status;
@@ -123,7 +122,7 @@ static enum sci_status scic_sds_smp_remote_device_ready_idle_substate_start_io_h
123 * until this one is complete. enum sci_status 122 * until this one is complete. enum sci_status
124 */ 123 */
125static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler( 124static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler(
126 struct sci_base_remote_device *device, 125 struct scic_sds_remote_device *device,
127 struct scic_sds_request *request) 126 struct scic_sds_request *request)
128{ 127{
129 return SCI_FAILURE_INVALID_STATE; 128 return SCI_FAILURE_INVALID_STATE;
@@ -137,38 +136,37 @@ static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_start_io_ha
137 * 136 *
138 * enum sci_status 137 * enum sci_status
139 */ 138 */
140static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler( 139static enum sci_status
141 struct sci_base_remote_device *device, 140scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler(
141 struct scic_sds_remote_device *device,
142 struct scic_sds_request *request) 142 struct scic_sds_request *request)
143{ 143{
144 enum sci_status status; 144 enum sci_status status;
145 struct scic_sds_remote_device *this_device;
146 struct scic_sds_request *the_request; 145 struct scic_sds_request *the_request;
147 146
148 this_device = (struct scic_sds_remote_device *)device;
149 the_request = (struct scic_sds_request *)request; 147 the_request = (struct scic_sds_request *)request;
150 148
151 status = scic_sds_io_request_complete(the_request); 149 status = scic_sds_io_request_complete(the_request);
152 150
153 if (status == SCI_SUCCESS) { 151 if (status == SCI_SUCCESS) {
154 status = scic_sds_port_complete_io( 152 status = scic_sds_port_complete_io(
155 this_device->owning_port, this_device, the_request); 153 device->owning_port, device, the_request);
156 154
157 if (status == SCI_SUCCESS) { 155 if (status == SCI_SUCCESS) {
158 scic_sds_remote_device_decrement_request_count(this_device); 156 scic_sds_remote_device_decrement_request_count(device);
159 sci_base_state_machine_change_state( 157 sci_base_state_machine_change_state(
160 &this_device->ready_substate_machine, 158 &device->ready_substate_machine,
161 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE 159 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE
162 ); 160 );
163 } else 161 } else
164 dev_err(scirdev_to_dev(this_device), 162 dev_err(scirdev_to_dev(device),
165 "%s: SCIC SDS Remote Device 0x%p io request " 163 "%s: SCIC SDS Remote Device 0x%p io request "
166 "0x%p could not be completd on the port 0x%p " 164 "0x%p could not be completd on the port 0x%p "
167 "failed with status %d.\n", 165 "failed with status %d.\n",
168 __func__, 166 __func__,
169 this_device, 167 device,
170 the_request, 168 the_request,
171 this_device->owning_port, 169 device->owning_port,
172 status); 170 status);
173 } 171 }
174 172
@@ -204,38 +202,38 @@ static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_frame_handl
204 202
205static const struct scic_sds_remote_device_state_handler scic_sds_smp_remote_device_ready_substate_handler_table[] = { 203static const struct scic_sds_remote_device_state_handler scic_sds_smp_remote_device_ready_substate_handler_table[] = {
206 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = { 204 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
207 .parent.start_handler = scic_sds_remote_device_default_start_handler, 205 .start_handler = scic_sds_remote_device_default_start_handler,
208 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 206 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
209 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 207 .fail_handler = scic_sds_remote_device_default_fail_handler,
210 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 208 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
211 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 209 .reset_handler = scic_sds_remote_device_default_reset_handler,
212 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 210 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
213 .parent.start_io_handler = scic_sds_smp_remote_device_ready_idle_substate_start_io_handler, 211 .start_io_handler = scic_sds_smp_remote_device_ready_idle_substate_start_io_handler,
214 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 212 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
215 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 213 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
216 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 214 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
217 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 215 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
218 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 216 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
219 .resume_handler = scic_sds_remote_device_default_resume_handler, 217 .resume_handler = scic_sds_remote_device_default_resume_handler,
220 .event_handler = scic_sds_remote_device_general_event_handler, 218 .event_handler = scic_sds_remote_device_general_event_handler,
221 .frame_handler = scic_sds_remote_device_default_frame_handler 219 .frame_handler = scic_sds_remote_device_default_frame_handler
222 }, 220 },
223 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = { 221 [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
224 .parent.start_handler = scic_sds_remote_device_default_start_handler, 222 .start_handler = scic_sds_remote_device_default_start_handler,
225 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 223 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
226 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 224 .fail_handler = scic_sds_remote_device_default_fail_handler,
227 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 225 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
228 .parent.reset_handler = scic_sds_remote_device_default_reset_handler, 226 .reset_handler = scic_sds_remote_device_default_reset_handler,
229 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 227 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
230 .parent.start_io_handler = scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler, 228 .start_io_handler = scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler,
231 .parent.complete_io_handler = scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler, 229 .complete_io_handler = scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler,
232 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 230 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
233 .parent.start_task_handler = scic_sds_remote_device_default_start_request_handler, 231 .start_task_handler = scic_sds_remote_device_default_start_request_handler,
234 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 232 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
235 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 233 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
236 .resume_handler = scic_sds_remote_device_default_resume_handler, 234 .resume_handler = scic_sds_remote_device_default_resume_handler,
237 .event_handler = scic_sds_remote_device_general_event_handler, 235 .event_handler = scic_sds_remote_device_general_event_handler,
238 .frame_handler = scic_sds_smp_remote_device_ready_cmd_substate_frame_handler 236 .frame_handler = scic_sds_smp_remote_device_ready_cmd_substate_frame_handler
239 } 237 }
240}; 238};
241 239
@@ -251,7 +249,7 @@ static const struct scic_sds_remote_device_state_handler scic_sds_smp_remote_dev
251static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base_object *object) 249static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base_object *object)
252{ 250{
253 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 251 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
254 parent.parent); 252 parent);
255 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 253 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
256 struct isci_host *ihost = sci_object_get_association(scic); 254 struct isci_host *ihost = sci_object_get_association(scic);
257 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 255 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -276,7 +274,7 @@ static void scic_sds_smp_remote_device_ready_cmd_substate_enter(
276 struct sci_base_object *object) 274 struct sci_base_object *object)
277{ 275{
278 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 276 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
279 parent.parent); 277 parent);
280 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 278 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
281 struct isci_host *ihost = sci_object_get_association(scic); 279 struct isci_host *ihost = sci_object_get_association(scic);
282 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 280 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -301,7 +299,7 @@ static void scic_sds_smp_remote_device_ready_cmd_substate_enter(
301static void scic_sds_smp_remote_device_ready_cmd_substate_exit(struct sci_base_object *object) 299static void scic_sds_smp_remote_device_ready_cmd_substate_exit(struct sci_base_object *object)
302{ 300{
303 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 301 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
304 parent.parent); 302 parent);
305 sci_dev->working_request = NULL; 303 sci_dev->working_request = NULL;
306} 304}
307 305
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 bb582497039b..a5b1fe3229ce 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
@@ -77,20 +77,19 @@
77 * completed successfully. 77 * completed successfully.
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 scic_sds_remote_device *device,
81 struct scic_sds_request *request) 81 struct scic_sds_request *request)
82{ 82{
83 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
84 enum sci_status status; 83 enum sci_status status;
85 84
86 status = scic_sds_io_request_complete(request); 85 status = scic_sds_io_request_complete(request);
87 86
88 if (status == SCI_SUCCESS) { 87 if (status == SCI_SUCCESS) {
89 status = scic_sds_port_complete_io( 88 status = scic_sds_port_complete_io(
90 this_device->owning_port, this_device, request); 89 device->owning_port, device, request);
91 90
92 if (status == SCI_SUCCESS) { 91 if (status == SCI_SUCCESS) {
93 scic_sds_remote_device_decrement_request_count(this_device); 92 scic_sds_remote_device_decrement_request_count(device);
94 if (request->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) { 93 if (request->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
95 /* 94 /*
96 * This request causes hardware error, device needs to be Lun Reset. 95 * This request causes hardware error, device needs to be Lun Reset.
@@ -98,12 +97,12 @@ static enum sci_status scic_sds_stp_remote_device_complete_request(
98 * can reach RNC state handler, these IOs will be completed by RNC with 97 * can reach RNC state handler, these IOs will be completed by RNC with
99 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE". */ 98 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE". */
100 sci_base_state_machine_change_state( 99 sci_base_state_machine_change_state(
101 &this_device->ready_substate_machine, 100 &device->ready_substate_machine,
102 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET 101 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET
103 ); 102 );
104 } else if (scic_sds_remote_device_get_request_count(this_device) == 0) { 103 } else if (scic_sds_remote_device_get_request_count(device) == 0) {
105 sci_base_state_machine_change_state( 104 sci_base_state_machine_change_state(
106 &this_device->ready_substate_machine, 105 &device->ready_substate_machine,
107 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE 106 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE
108 ); 107 );
109 } 108 }
@@ -111,12 +110,12 @@ static enum sci_status scic_sds_stp_remote_device_complete_request(
111 } 110 }
112 111
113 if (status != SCI_SUCCESS) 112 if (status != SCI_SUCCESS)
114 dev_err(scirdev_to_dev(this_device), 113 dev_err(scirdev_to_dev(device),
115 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x " 114 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
116 "could not complete\n", 115 "could not complete\n",
117 __func__, 116 __func__,
118 this_device->owning_port, 117 device->owning_port,
119 this_device, 118 device,
120 request, 119 request,
121 status); 120 status);
122 121
@@ -140,19 +139,18 @@ static enum sci_status scic_sds_stp_remote_device_complete_request(
140 * callback will be called. 139 * callback will be called.
141 */ 140 */
142static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_handler( 141static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_handler(
143 struct sci_base_remote_device *device, 142 struct scic_sds_remote_device *device,
144 struct scic_sds_request *request) 143 struct scic_sds_request *request)
145{ 144{
146 enum sci_status status; 145 enum sci_status status;
147 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
148 146
149 /* Will the port allow the io request to start? */ 147 /* Will the port allow the io request to start? */
150 status = this_device->owning_port->state_handlers->start_io_handler( 148 status = device->owning_port->state_handlers->start_io_handler(
151 this_device->owning_port, this_device, request); 149 device->owning_port, device, request);
152 if (status != SCI_SUCCESS) 150 if (status != SCI_SUCCESS)
153 return status; 151 return status;
154 152
155 status = scic_sds_remote_node_context_start_task(this_device->rnc, request); 153 status = scic_sds_remote_node_context_start_task(device->rnc, request);
156 if (status != SCI_SUCCESS) 154 if (status != SCI_SUCCESS)
157 goto out; 155 goto out;
158 156
@@ -164,8 +162,8 @@ static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_h
164 * Note: If the remote device state is not IDLE this will replace 162 * Note: If the remote device state is not IDLE this will replace
165 * the request that probably resulted in the task management request. 163 * the request that probably resulted in the task management request.
166 */ 164 */
167 this_device->working_request = request; 165 device->working_request = request;
168 sci_base_state_machine_change_state(&this_device->ready_substate_machine, 166 sci_base_state_machine_change_state(&device->ready_substate_machine,
169 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD); 167 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
170 168
171 /* 169 /*
@@ -175,14 +173,14 @@ static enum sci_status scic_sds_stp_remote_device_ready_substate_start_request_h
175 * remote node context state machine will take the correct action when 173 * remote node context state machine will take the correct action when
176 * the remote node context is suspended and later resumed. 174 * the remote node context is suspended and later resumed.
177 */ 175 */
178 scic_sds_remote_node_context_suspend(this_device->rnc, 176 scic_sds_remote_node_context_suspend(device->rnc,
179 SCI_SOFTWARE_SUSPENSION, NULL, NULL); 177 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
180 scic_sds_remote_node_context_resume(this_device->rnc, 178 scic_sds_remote_node_context_resume(device->rnc,
181 scic_sds_remote_device_continue_request, 179 scic_sds_remote_device_continue_request,
182 this_device); 180 device);
183 181
184out: 182out:
185 scic_sds_remote_device_start_request(this_device, request, status); 183 scic_sds_remote_device_start_request(device, request, status);
186 /* 184 /*
187 * We need to let the controller start request handler know that it can't 185 * 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 186 * post TC yet. We will provide a callback function to post TC when RNC gets
@@ -208,23 +206,21 @@ out:
208 * enum sci_status 206 * enum sci_status
209 */ 207 */
210static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_start_io_handler( 208static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_start_io_handler(
211 struct sci_base_remote_device *base_device, 209 struct scic_sds_remote_device *sci_dev,
212 struct scic_sds_request *request) 210 struct scic_sds_request *request)
213{ 211{
214 enum sci_status status; 212 enum sci_status status;
215 struct scic_sds_remote_device *device =
216 (struct scic_sds_remote_device *)&base_device->parent;
217 struct isci_request *isci_request = 213 struct isci_request *isci_request =
218 (struct isci_request *)sci_object_get_association(request); 214 (struct isci_request *)sci_object_get_association(request);
219 215
220 216
221 /* Will the port allow the io request to start? */ 217 /* Will the port allow the io request to start? */
222 status = device->owning_port->state_handlers->start_io_handler( 218 status = sci_dev->owning_port->state_handlers->start_io_handler(
223 device->owning_port, device, request); 219 sci_dev->owning_port, sci_dev, request);
224 if (status != SCI_SUCCESS) 220 if (status != SCI_SUCCESS)
225 return status; 221 return status;
226 222
227 status = scic_sds_remote_node_context_start_io(device->rnc, request); 223 status = scic_sds_remote_node_context_start_io(sci_dev->rnc, request);
228 if (status != SCI_SUCCESS) 224 if (status != SCI_SUCCESS)
229 goto out; 225 goto out;
230 226
@@ -233,15 +229,15 @@ static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_start_io_h
233 goto out; 229 goto out;
234 230
235 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) { 231 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) {
236 sci_base_state_machine_change_state(&device->ready_substate_machine, 232 sci_base_state_machine_change_state(&sci_dev->ready_substate_machine,
237 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ); 233 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ);
238 } else { 234 } else {
239 device->working_request = request; 235 sci_dev->working_request = request;
240 sci_base_state_machine_change_state(&device->ready_substate_machine, 236 sci_base_state_machine_change_state(&sci_dev->ready_substate_machine,
241 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD); 237 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
242 } 238 }
243out: 239out:
244 scic_sds_remote_device_start_request(device, request, status); 240 scic_sds_remote_device_start_request(sci_dev, request, status);
245 return status; 241 return status;
246} 242}
247 243
@@ -281,30 +277,28 @@ static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_event_hand
281 * ***************************************************************************** */ 277 * ***************************************************************************** */
282 278
283static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler( 279static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler(
284 struct sci_base_remote_device *base_device, 280 struct scic_sds_remote_device *sci_dev,
285 struct scic_sds_request *request) 281 struct scic_sds_request *request)
286{ 282{
287 enum sci_status status; 283 enum sci_status status;
288 struct scic_sds_remote_device *device =
289 (struct scic_sds_remote_device *)&base_device->parent;
290 struct isci_request *isci_request = 284 struct isci_request *isci_request =
291 (struct isci_request *)sci_object_get_association(request); 285 (struct isci_request *)sci_object_get_association(request);
292 286
293 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) { 287 if (isci_sata_get_sat_protocol(isci_request) == SAT_PROTOCOL_FPDMA) {
294 status = device->owning_port->state_handlers->start_io_handler( 288 status = sci_dev->owning_port->state_handlers->start_io_handler(
295 device->owning_port, 289 sci_dev->owning_port,
296 device, 290 sci_dev,
297 request); 291 request);
298 292
299 if (status == SCI_SUCCESS) { 293 if (status == SCI_SUCCESS) {
300 status = scic_sds_remote_node_context_start_io( 294 status = scic_sds_remote_node_context_start_io(
301 device->rnc, 295 sci_dev->rnc,
302 request); 296 request);
303 297
304 if (status == SCI_SUCCESS) 298 if (status == SCI_SUCCESS)
305 status = request->state_handlers->start_handler(request); 299 status = request->state_handlers->start_handler(request);
306 300
307 scic_sds_remote_device_start_request(device, 301 scic_sds_remote_device_start_request(sci_dev,
308 request, 302 request,
309 status); 303 status);
310 } 304 }
@@ -392,7 +386,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
392 * enum sci_status 386 * enum sci_status
393 */ 387 */
394static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler( 388static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler(
395 struct sci_base_remote_device *device, 389 struct scic_sds_remote_device *device,
396 struct scic_sds_request *request) 390 struct scic_sds_request *request)
397{ 391{
398 return SCI_FAILURE_INVALID_STATE; 392 return SCI_FAILURE_INVALID_STATE;
@@ -445,7 +439,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handl
445 * * STP REMOTE DEVICE READY AWAIT RESET SUBSTATE HANDLERS 439 * * STP REMOTE DEVICE READY AWAIT RESET SUBSTATE HANDLERS
446 * ***************************************************************************** */ 440 * ***************************************************************************** */
447static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler( 441static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler(
448 struct sci_base_remote_device *device, 442 struct scic_sds_remote_device *device,
449 struct scic_sds_request *request) 443 struct scic_sds_request *request)
450{ 444{
451 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED; 445 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
@@ -464,10 +458,9 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_sta
464 * completed successfully. 458 * completed successfully.
465 */ 459 */
466static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler( 460static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler(
467 struct sci_base_remote_device *device, 461 struct scic_sds_remote_device *device,
468 struct scic_sds_request *request) 462 struct scic_sds_request *request)
469{ 463{
470 struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)device;
471 struct scic_sds_request *the_request = (struct scic_sds_request *)request; 464 struct scic_sds_request *the_request = (struct scic_sds_request *)request;
472 enum sci_status status; 465 enum sci_status status;
473 466
@@ -475,20 +468,20 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_com
475 468
476 if (status == SCI_SUCCESS) { 469 if (status == SCI_SUCCESS) {
477 status = scic_sds_port_complete_io( 470 status = scic_sds_port_complete_io(
478 this_device->owning_port, this_device, the_request 471 device->owning_port, device, the_request
479 ); 472 );
480 473
481 if (status == SCI_SUCCESS) 474 if (status == SCI_SUCCESS)
482 scic_sds_remote_device_decrement_request_count(this_device); 475 scic_sds_remote_device_decrement_request_count(device);
483 } 476 }
484 477
485 if (status != SCI_SUCCESS) 478 if (status != SCI_SUCCESS)
486 dev_err(scirdev_to_dev(this_device), 479 dev_err(scirdev_to_dev(device),
487 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x " 480 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
488 "could not complete\n", 481 "could not complete\n",
489 __func__, 482 __func__,
490 this_device->owning_port, 483 device->owning_port,
491 this_device, 484 device,
492 the_request, 485 the_request,
493 status); 486 status);
494 487
@@ -538,68 +531,68 @@ enum sci_status scic_sds_stp_remote_device_ready_atapi_error_substate_event_hand
538 531
539static const struct scic_sds_remote_device_state_handler scic_sds_stp_remote_device_ready_substate_handler_table[] = { 532static const struct scic_sds_remote_device_state_handler scic_sds_stp_remote_device_ready_substate_handler_table[] = {
540 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = { 533 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
541 .parent.start_handler = scic_sds_remote_device_default_start_handler, 534 .start_handler = scic_sds_remote_device_default_start_handler,
542 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 535 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
543 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 536 .fail_handler = scic_sds_remote_device_default_fail_handler,
544 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 537 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
545 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 538 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
546 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 539 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
547 .parent.start_io_handler = scic_sds_stp_remote_device_ready_idle_substate_start_io_handler, 540 .start_io_handler = scic_sds_stp_remote_device_ready_idle_substate_start_io_handler,
548 .parent.complete_io_handler = scic_sds_remote_device_default_complete_request_handler, 541 .complete_io_handler = scic_sds_remote_device_default_complete_request_handler,
549 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 542 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
550 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 543 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
551 .parent.complete_task_handler = scic_sds_remote_device_default_complete_request_handler, 544 .complete_task_handler = scic_sds_remote_device_default_complete_request_handler,
552 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 545 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
553 .resume_handler = scic_sds_remote_device_default_resume_handler, 546 .resume_handler = scic_sds_remote_device_default_resume_handler,
554 .event_handler = scic_sds_stp_remote_device_ready_idle_substate_event_handler, 547 .event_handler = scic_sds_stp_remote_device_ready_idle_substate_event_handler,
555 .frame_handler = scic_sds_remote_device_default_frame_handler 548 .frame_handler = scic_sds_remote_device_default_frame_handler
556 }, 549 },
557 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = { 550 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
558 .parent.start_handler = scic_sds_remote_device_default_start_handler, 551 .start_handler = scic_sds_remote_device_default_start_handler,
559 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 552 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
560 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 553 .fail_handler = scic_sds_remote_device_default_fail_handler,
561 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 554 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
562 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 555 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
563 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 556 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
564 .parent.start_io_handler = scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler, 557 .start_io_handler = scic_sds_stp_remote_device_ready_cmd_substate_start_io_handler,
565 .parent.complete_io_handler = scic_sds_stp_remote_device_complete_request, 558 .complete_io_handler = scic_sds_stp_remote_device_complete_request,
566 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 559 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
567 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 560 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
568 .parent.complete_task_handler = scic_sds_stp_remote_device_complete_request, 561 .complete_task_handler = scic_sds_stp_remote_device_complete_request,
569 .suspend_handler = scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler, 562 .suspend_handler = scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler,
570 .resume_handler = scic_sds_remote_device_default_resume_handler, 563 .resume_handler = scic_sds_remote_device_default_resume_handler,
571 .event_handler = scic_sds_remote_device_general_event_handler, 564 .event_handler = scic_sds_remote_device_general_event_handler,
572 .frame_handler = scic_sds_stp_remote_device_ready_cmd_substate_frame_handler 565 .frame_handler = scic_sds_stp_remote_device_ready_cmd_substate_frame_handler
573 }, 566 },
574 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = { 567 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = {
575 .parent.start_handler = scic_sds_remote_device_default_start_handler, 568 .start_handler = scic_sds_remote_device_default_start_handler,
576 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 569 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
577 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 570 .fail_handler = scic_sds_remote_device_default_fail_handler,
578 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 571 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
579 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 572 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
580 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 573 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
581 .parent.start_io_handler = scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler, 574 .start_io_handler = scic_sds_stp_remote_device_ready_ncq_substate_start_io_handler,
582 .parent.complete_io_handler = scic_sds_stp_remote_device_complete_request, 575 .complete_io_handler = scic_sds_stp_remote_device_complete_request,
583 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 576 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
584 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 577 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
585 .parent.complete_task_handler = scic_sds_stp_remote_device_complete_request, 578 .complete_task_handler = scic_sds_stp_remote_device_complete_request,
586 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 579 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
587 .resume_handler = scic_sds_remote_device_default_resume_handler, 580 .resume_handler = scic_sds_remote_device_default_resume_handler,
588 .event_handler = scic_sds_remote_device_general_event_handler, 581 .event_handler = scic_sds_remote_device_general_event_handler,
589 .frame_handler = scic_sds_stp_remote_device_ready_ncq_substate_frame_handler 582 .frame_handler = scic_sds_stp_remote_device_ready_ncq_substate_frame_handler
590 }, 583 },
591 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = { 584 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = {
592 .parent.start_handler = scic_sds_remote_device_default_start_handler, 585 .start_handler = scic_sds_remote_device_default_start_handler,
593 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 586 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
594 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 587 .fail_handler = scic_sds_remote_device_default_fail_handler,
595 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 588 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
596 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 589 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
597 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 590 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
598 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 591 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
599 .parent.complete_io_handler = scic_sds_stp_remote_device_complete_request, 592 .complete_io_handler = scic_sds_stp_remote_device_complete_request,
600 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 593 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
601 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 594 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
602 .parent.complete_task_handler = scic_sds_stp_remote_device_complete_request, 595 .complete_task_handler = scic_sds_stp_remote_device_complete_request,
603 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 596 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
604 .resume_handler = scic_sds_remote_device_default_resume_handler, 597 .resume_handler = scic_sds_remote_device_default_resume_handler,
605 .event_handler = scic_sds_remote_device_general_event_handler, 598 .event_handler = scic_sds_remote_device_general_event_handler,
@@ -607,17 +600,17 @@ static const struct scic_sds_remote_device_state_handler scic_sds_stp_remote_dev
607 }, 600 },
608#if !defined(DISABLE_ATAPI) 601#if !defined(DISABLE_ATAPI)
609 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR] = { 602 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR] = {
610 .parent.start_handler = scic_sds_remote_device_default_start_handler, 603 .start_handler = scic_sds_remote_device_default_start_handler,
611 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 604 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
612 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 605 .fail_handler = scic_sds_remote_device_default_fail_handler,
613 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 606 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
614 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 607 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
615 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 608 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
616 .parent.start_io_handler = scic_sds_remote_device_default_start_request_handler, 609 .start_io_handler = scic_sds_remote_device_default_start_request_handler,
617 .parent.complete_io_handler = scic_sds_stp_remote_device_complete_request, 610 .complete_io_handler = scic_sds_stp_remote_device_complete_request,
618 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 611 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
619 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 612 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
620 .parent.complete_task_handler = scic_sds_stp_remote_device_complete_request, 613 .complete_task_handler = scic_sds_stp_remote_device_complete_request,
621 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 614 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
622 .resume_handler = scic_sds_remote_device_default_resume_handler, 615 .resume_handler = scic_sds_remote_device_default_resume_handler,
623 .event_handler = scic_sds_stp_remote_device_ready_atapi_error_substate_event_handler, 616 .event_handler = scic_sds_stp_remote_device_ready_atapi_error_substate_event_handler,
@@ -625,17 +618,17 @@ static const struct scic_sds_remote_device_state_handler scic_sds_stp_remote_dev
625 }, 618 },
626#endif 619#endif
627 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = { 620 [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = {
628 .parent.start_handler = scic_sds_remote_device_default_start_handler, 621 .start_handler = scic_sds_remote_device_default_start_handler,
629 .parent.stop_handler = scic_sds_remote_device_ready_state_stop_handler, 622 .stop_handler = scic_sds_remote_device_ready_state_stop_handler,
630 .parent.fail_handler = scic_sds_remote_device_default_fail_handler, 623 .fail_handler = scic_sds_remote_device_default_fail_handler,
631 .parent.destruct_handler = scic_sds_remote_device_default_destruct_handler, 624 .destruct_handler = scic_sds_remote_device_default_destruct_handler,
632 .parent.reset_handler = scic_sds_remote_device_ready_state_reset_handler, 625 .reset_handler = scic_sds_remote_device_ready_state_reset_handler,
633 .parent.reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler, 626 .reset_complete_handler = scic_sds_remote_device_default_reset_complete_handler,
634 .parent.start_io_handler = scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler, 627 .start_io_handler = scic_sds_stp_remote_device_ready_await_reset_substate_start_io_handler,
635 .parent.complete_io_handler = scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler, 628 .complete_io_handler = scic_sds_stp_remote_device_ready_await_reset_substate_complete_request_handler,
636 .parent.continue_io_handler = scic_sds_remote_device_default_continue_request_handler, 629 .continue_io_handler = scic_sds_remote_device_default_continue_request_handler,
637 .parent.start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler, 630 .start_task_handler = scic_sds_stp_remote_device_ready_substate_start_request_handler,
638 .parent.complete_task_handler = scic_sds_stp_remote_device_complete_request, 631 .complete_task_handler = scic_sds_stp_remote_device_complete_request,
639 .suspend_handler = scic_sds_remote_device_default_suspend_handler, 632 .suspend_handler = scic_sds_remote_device_default_suspend_handler,
640 .resume_handler = scic_sds_remote_device_default_resume_handler, 633 .resume_handler = scic_sds_remote_device_default_resume_handler,
641 .event_handler = scic_sds_remote_device_general_event_handler, 634 .event_handler = scic_sds_remote_device_general_event_handler,
@@ -711,7 +704,7 @@ static void scic_sds_stp_remote_device_ready_idle_substate_enter(
711static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_object *object) 704static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_object *object)
712{ 705{
713 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 706 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
714 parent.parent); 707 parent);
715 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 708 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
716 struct isci_host *ihost = sci_object_get_association(scic); 709 struct isci_host *ihost = sci_object_get_association(scic);
717 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 710 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
@@ -729,7 +722,7 @@ static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_
729static void scic_sds_stp_remote_device_ready_ncq_substate_enter(struct sci_base_object *object) 722static void scic_sds_stp_remote_device_ready_ncq_substate_enter(struct sci_base_object *object)
730{ 723{
731 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 724 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
732 parent.parent); 725 parent);
733 SET_STATE_HANDLER(sci_dev, 726 SET_STATE_HANDLER(sci_dev,
734 scic_sds_stp_remote_device_ready_substate_handler_table, 727 scic_sds_stp_remote_device_ready_substate_handler_table,
735 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ); 728 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ);
@@ -738,7 +731,7 @@ static void scic_sds_stp_remote_device_ready_ncq_substate_enter(struct sci_base_
738static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_object *object) 731static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_object *object)
739{ 732{
740 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev), 733 struct scic_sds_remote_device *sci_dev = container_of(object, typeof(*sci_dev),
741 parent.parent); 734 parent);
742 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev); 735 struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
743 struct isci_host *ihost = sci_object_get_association(scic); 736 struct isci_host *ihost = sci_object_get_association(scic);
744 struct isci_remote_device *idev = sci_object_get_association(sci_dev); 737 struct isci_remote_device *idev = sci_object_get_association(sci_dev);
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-31 21:24:19 -0400