aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorChristoph Hellwig <hch@infradead.org>2011-03-28 09:21:04 -0400
committerDan Williams <dan.j.williams@intel.com>2011-07-03 07:00:37 -0400
commitca841f0e862bccd61f537b76c94579c1bd391448 (patch)
treef2330231b556b6c1767bf83a0e3f6675acd4d787
parentbc99aa47108e9fd759071d4741c7abdf7b903579 (diff)
isci: remove base_controller abstraction
Merge struct sci_base_controller into scic_sds_controller, and also factor the two types of state machine handlers into one function. While we're at it also remove lots of duplicate incorrect kerneldoc comments for the state machine handlers. Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Diffstat
-rw-r--r--drivers/scsi/isci/core/sci_base_controller.h304
-rw-r--r--drivers/scsi/isci/core/sci_controller.h29
-rw-r--r--drivers/scsi/isci/core/scic_sds_controller.c438
-rw-r--r--drivers/scsi/isci/core/scic_sds_controller.h198
-rw-r--r--drivers/scsi/isci/core/scic_sds_remote_device.c9
-rw-r--r--drivers/scsi/isci/core/scic_sds_stp_request.c16
-rw-r--r--drivers/scsi/isci/host.c6
-rw-r--r--drivers/scsi/isci/isci.h2
8 files changed, 364 insertions, 638 deletions
diff --git a/drivers/scsi/isci/core/sci_base_controller.h b/drivers/scsi/isci/core/sci_base_controller.h
deleted file mode 100644
index 8e0c46f8b221..000000000000
--- a/drivers/scsi/isci/core/sci_base_controller.h
+++ /dev/null
@@ -1,304 +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_CONTROLLER_H_
57#define _SCI_BASE_CONTROLLER_H_
58
59#include "intel_sas.h"
60#include "sci_controller_constants.h"
61#include "sci_base_state.h"
62#include "sci_base_memory_descriptor_list.h"
63#include "sci_base_state_machine.h"
64#include "sci_object.h"
65
66struct sci_base_memory_descriptor_list;
67
68/**
69 * enum sci_base_controller_states - This enumeration depicts all the states
70 * for the common controller state machine.
71 *
72 *
73 */
74enum sci_base_controller_states {
75 /**
76 * Simply the initial state for the base controller state machine.
77 */
78 SCI_BASE_CONTROLLER_STATE_INITIAL = 0,
79
80 /**
81 * This state indicates that the controller is reset. The memory for
82 * the controller is in it's initial state, but the controller requires
83 * initialization.
84 * This state is entered from the INITIAL state.
85 * This state is entered from the RESETTING state.
86 */
87 SCI_BASE_CONTROLLER_STATE_RESET,
88
89 /**
90 * This state is typically an action state that indicates the controller
91 * is in the process of initialization. In this state no new IO operations
92 * are permitted.
93 * This state is entered from the RESET state.
94 */
95 SCI_BASE_CONTROLLER_STATE_INITIALIZING,
96
97 /**
98 * This state indicates that the controller has been successfully
99 * initialized. In this state no new IO operations are permitted.
100 * This state is entered from the INITIALIZING state.
101 */
102 SCI_BASE_CONTROLLER_STATE_INITIALIZED,
103
104 /**
105 * This state indicates the the controller is in the process of becoming
106 * ready (i.e. starting). In this state no new IO operations are permitted.
107 * This state is entered from the INITIALIZED state.
108 */
109 SCI_BASE_CONTROLLER_STATE_STARTING,
110
111 /**
112 * This state indicates the controller is now ready. Thus, the user
113 * is able to perform IO operations on the controller.
114 * This state is entered from the STARTING state.
115 */
116 SCI_BASE_CONTROLLER_STATE_READY,
117
118 /**
119 * This state is typically an action state that indicates the controller
120 * is in the process of resetting. Thus, the user is unable to perform
121 * IO operations on the controller. A reset is considered destructive in
122 * most cases.
123 * This state is entered from the READY state.
124 * This state is entered from the FAILED state.
125 * This state is entered from the STOPPED state.
126 */
127 SCI_BASE_CONTROLLER_STATE_RESETTING,
128
129 /**
130 * This state indicates that the controller is in the process of stopping.
131 * In this state no new IO operations are permitted, but existing IO
132 * operations are allowed to complete.
133 * This state is entered from the READY state.
134 */
135 SCI_BASE_CONTROLLER_STATE_STOPPING,
136
137 /**
138 * This state indicates that the controller has successfully been stopped.
139 * In this state no new IO operations are permitted.
140 * This state is entered from the STOPPING state.
141 */
142 SCI_BASE_CONTROLLER_STATE_STOPPED,
143
144 /**
145 * This state indicates that the controller could not successfully be
146 * initialized. In this state no new IO operations are permitted.
147 * This state is entered from the INITIALIZING state.
148 * This state is entered from the STARTING state.
149 * This state is entered from the STOPPING state.
150 * This state is entered from the RESETTING state.
151 */
152 SCI_BASE_CONTROLLER_STATE_FAILED,
153
154 SCI_BASE_CONTROLLER_MAX_STATES
155
156};
157
158/**
159 * struct sci_base_controller - The base controller object abstracts the fields
160 * common to all SCI controller objects.
161 *
162 *
163 */
164struct sci_base_controller {
165 /**
166 * The field specifies that the parent object for the base controller
167 * is the base object itself.
168 */
169 struct sci_base_object parent;
170
171 /**
172 * This field points to the memory descriptor list associated with this
173 * controller. The MDL indicates the memory requirements necessary for
174 * this controller object.
175 */
176 struct sci_base_memory_descriptor_list mdl;
177
178 /**
179 * This field contains the information for the base controller state
180 * machine.
181 */
182 struct sci_base_state_machine state_machine;
183};
184
185/* Forward declarations */
186struct sci_base_remote_device;
187struct sci_base_request;
188
189typedef enum sci_status
190(*sci_base_controller_handler_t)(struct sci_base_controller *);
191
192typedef enum sci_status
193(*sci_base_controller_timed_handler_t)(struct sci_base_controller *, u32);
194
195typedef enum sci_status
196(*sci_base_controller_request_handler_t)(struct sci_base_controller *,
197 struct sci_base_remote_device *,
198 struct sci_base_request *);
199
200typedef enum sci_status
201(*sci_base_controller_start_request_handler_t)(struct sci_base_controller *,
202 struct sci_base_remote_device *,
203 struct sci_base_request *, u16);
204
205/**
206 * struct sci_base_controller_state_handler - This structure contains all of
207 * the state handler methods common to base controller state machines.
208 * Handler methods provide the ability to change the behavior for user
209 * requests or transitions depending on the state the machine is in.
210 *
211 *
212 */
213struct sci_base_controller_state_handler {
214 /**
215 * The start_handler specifies the method invoked when a user attempts to
216 * start a controller.
217 */
218 sci_base_controller_timed_handler_t start;
219
220 /**
221 * The stop_handler specifies the method invoked when a user attempts to
222 * stop a controller.
223 */
224 sci_base_controller_timed_handler_t stop;
225
226 /**
227 * The reset_handler specifies the method invoked when a user attempts to
228 * reset a controller.
229 */
230 sci_base_controller_handler_t reset;
231
232 /**
233 * The initialize_handler specifies the method invoked when a user
234 * attempts to initialize a controller.
235 */
236 sci_base_controller_handler_t initialize;
237
238 /**
239 * The start_io_handler specifies the method invoked when a user
240 * attempts to start an IO request for a controller.
241 */
242 sci_base_controller_start_request_handler_t start_io;
243
244 /**
245 * The complete_io_handler specifies the method invoked when a user
246 * attempts to complete an IO request for a controller.
247 */
248 sci_base_controller_request_handler_t complete_io;
249
250 /**
251 * The continue_io_handler specifies the method invoked when a user
252 * attempts to continue an IO request for a controller.
253 */
254 sci_base_controller_request_handler_t continue_io;
255
256 /**
257 * The start_task_handler specifies the method invoked when a user
258 * attempts to start a task management request for a controller.
259 */
260 sci_base_controller_start_request_handler_t start_task;
261
262 /**
263 * The complete_task_handler specifies the method invoked when a user
264 * attempts to complete a task management request for a controller.
265 */
266 sci_base_controller_request_handler_t complete_task;
267
268};
269
270/**
271 * sci_base_controller_construct() - Construct the base controller
272 * @this_controller: This parameter specifies the base controller to be
273 * constructed.
274 * @state_table: This parameter specifies the table of state definitions to be
275 * utilized for the controller state machine.
276 * @mde_array: This parameter specifies the array of memory descriptor entries
277 * to be managed by this list.
278 * @mde_array_length: This parameter specifies the size of the array of entries.
279 * @next_mdl: This parameter specifies a subsequent MDL object to be managed by
280 * this MDL object.
281 * @oem_parameters: This parameter specifies the original equipment
282 * manufacturer parameters to be utilized by this controller object.
283 *
284 */
285static inline void sci_base_controller_construct(
286 struct sci_base_controller *scic_base,
287 const struct sci_base_state *state_table,
288 struct sci_physical_memory_descriptor *mdes,
289 u32 mde_count,
290 struct sci_base_memory_descriptor_list *next_mdl)
291{
292 sci_base_state_machine_construct(
293 &scic_base->state_machine,
294 &scic_base->parent,
295 state_table,
296 SCI_BASE_CONTROLLER_STATE_INITIAL
297 );
298
299 sci_base_mdl_construct(&scic_base->mdl, mdes, mde_count, next_mdl);
300
301 sci_base_state_machine_start(&scic_base->state_machine);
302}
303
304#endif /* _SCI_BASE_CONTROLLER_H_ */
diff --git a/drivers/scsi/isci/core/sci_controller.h b/drivers/scsi/isci/core/sci_controller.h
index 5c7774e75ddf..01316b1a8f27 100644
--- a/drivers/scsi/isci/core/sci_controller.h
+++ b/drivers/scsi/isci/core/sci_controller.h
@@ -63,36 +63,7 @@
63 * 63 *
64 */ 64 */
65 65
66
67struct sci_base_memory_descriptor_list;
68struct scic_sds_controller;
69
70#define SCI_CONTROLLER_INVALID_IO_TAG 0xFFFF 66#define SCI_CONTROLLER_INVALID_IO_TAG 0xFFFF
71 67
72/**
73 * sci_controller_get_memory_descriptor_list_handle() - This method simply
74 * returns a handle for the memory descriptor list associated with the
75 * supplied controller. The descriptor list provides DMA safe/capable
76 * memory requirements for this controller.
77 * @controller: This parameter specifies the controller for which to retrieve
78 * the DMA safe memory descriptor list.
79 *
80 * The user must adhere to the alignment requirements specified in memory
81 * descriptor. In situations where the operating environment does not offer
82 * memory allocation utilities supporting alignment, then it is the
83 * responsibility of the user to manually align the memory buffer for SCI.
84 * Thus, the user may have to allocate a larger buffer to meet the alignment.
85 * Additionally, the user will need to remember the actual memory allocation
86 * addresses in order to ensure the memory can be properly freed when necessary
87 * to do so. This method will return a valid handle, but the MDL may not be
88 * accurate until after the user has invoked the associated
89 * sci_controller_initialize() routine. A pointer to a physical memory
90 * descriptor array.
91 */
92struct sci_base_memory_descriptor_list *
93 sci_controller_get_memory_descriptor_list_handle(
94 struct scic_sds_controller *controller);
95
96
97#endif /* _SCI_CONTROLLER_H_ */ 68#endif /* _SCI_CONTROLLER_H_ */
98 69
diff --git a/drivers/scsi/isci/core/scic_sds_controller.c b/drivers/scsi/isci/core/scic_sds_controller.c
index 774c4b3b0dfb..e7790bb7dfdd 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.c
+++ b/drivers/scsi/isci/core/scic_sds_controller.c
@@ -212,12 +212,6 @@ static void scic_sds_controller_power_control_timer_handler(
212 SMU_CQGR_EVENT_CYCLE_BIT \ 212 SMU_CQGR_EVENT_CYCLE_BIT \
213 ) 213 )
214 214
215struct sci_base_memory_descriptor_list *
216sci_controller_get_memory_descriptor_list_handle(struct scic_sds_controller *scic)
217{
218 return &scic->parent.mdl;
219}
220
221static void scic_sds_controller_initialize_power_control(struct scic_sds_controller *scic) 215static void scic_sds_controller_initialize_power_control(struct scic_sds_controller *scic)
222{ 216{
223 struct isci_host *ihost = sci_object_get_association(scic); 217 struct isci_host *ihost = sci_object_get_association(scic);
@@ -688,13 +682,13 @@ static void scic_sds_controller_transition_to_ready(
688{ 682{
689 struct isci_host *ihost = sci_object_get_association(scic); 683 struct isci_host *ihost = sci_object_get_association(scic);
690 684
691 if (scic->parent.state_machine.current_state_id == 685 if (scic->state_machine.current_state_id ==
692 SCI_BASE_CONTROLLER_STATE_STARTING) { 686 SCI_BASE_CONTROLLER_STATE_STARTING) {
693 /* 687 /*
694 * We move into the ready state, because some of the phys/ports 688 * We move into the ready state, because some of the phys/ports
695 * may be up and operational. 689 * may be up and operational.
696 */ 690 */
697 sci_base_state_machine_change_state(&scic->parent.state_machine, 691 sci_base_state_machine_change_state(&scic->state_machine,
698 SCI_BASE_CONTROLLER_STATE_READY); 692 SCI_BASE_CONTROLLER_STATE_READY);
699 693
700 isci_host_start_complete(ihost, status); 694 isci_host_start_complete(ihost, status);
@@ -705,7 +699,7 @@ static void scic_sds_controller_timeout_handler(void *_scic)
705{ 699{
706 struct scic_sds_controller *scic = _scic; 700 struct scic_sds_controller *scic = _scic;
707 struct isci_host *ihost = sci_object_get_association(scic); 701 struct isci_host *ihost = sci_object_get_association(scic);
708 struct sci_base_state_machine *sm = &scic->parent.state_machine; 702 struct sci_base_state_machine *sm = &scic->state_machine;
709 703
710 if (sm->current_state_id == SCI_BASE_CONTROLLER_STATE_STARTING) 704 if (sm->current_state_id == SCI_BASE_CONTROLLER_STATE_STARTING)
711 scic_sds_controller_transition_to_ready(scic, SCI_FAILURE_TIMEOUT); 705 scic_sds_controller_transition_to_ready(scic, SCI_FAILURE_TIMEOUT);
@@ -1549,7 +1543,7 @@ void scic_sds_controller_error_handler(struct scic_sds_controller *scic)
1549 dev_err(scic_to_dev(scic), "%s: status: %#x\n", __func__, 1543 dev_err(scic_to_dev(scic), "%s: status: %#x\n", __func__,
1550 interrupt_status); 1544 interrupt_status);
1551 1545
1552 sci_base_state_machine_change_state(&scic->parent.state_machine, 1546 sci_base_state_machine_change_state(&scic->state_machine,
1553 SCI_BASE_CONTROLLER_STATE_FAILED); 1547 SCI_BASE_CONTROLLER_STATE_FAILED);
1554 1548
1555 return; 1549 return;
@@ -1572,7 +1566,7 @@ void scic_sds_controller_link_up(
1572 scic_sds_controller_phy_handler_t link_up; 1566 scic_sds_controller_phy_handler_t link_up;
1573 u32 state; 1567 u32 state;
1574 1568
1575 state = scic->parent.state_machine.current_state_id; 1569 state = scic->state_machine.current_state_id;
1576 link_up = scic_sds_controller_state_handler_table[state].link_up; 1570 link_up = scic_sds_controller_state_handler_table[state].link_up;
1577 1571
1578 if (link_up) 1572 if (link_up)
@@ -1593,7 +1587,7 @@ void scic_sds_controller_link_down(
1593 u32 state; 1587 u32 state;
1594 scic_sds_controller_phy_handler_t link_down; 1588 scic_sds_controller_phy_handler_t link_down;
1595 1589
1596 state = scic->parent.state_machine.current_state_id; 1590 state = scic->state_machine.current_state_id;
1597 link_down = scic_sds_controller_state_handler_table[state].link_down; 1591 link_down = scic_sds_controller_state_handler_table[state].link_down;
1598 1592
1599 if (link_down) 1593 if (link_down)
@@ -1639,7 +1633,7 @@ void scic_sds_controller_remote_device_stopped(struct scic_sds_controller *scic,
1639 u32 state; 1633 u32 state;
1640 scic_sds_controller_device_handler_t stopped; 1634 scic_sds_controller_device_handler_t stopped;
1641 1635
1642 state = scic->parent.state_machine.current_state_id; 1636 state = scic->state_machine.current_state_id;
1643 stopped = scic_sds_controller_state_handler_table[state].device_stopped; 1637 stopped = scic_sds_controller_state_handler_table[state].device_stopped;
1644 1638
1645 if (stopped) 1639 if (stopped)
@@ -1969,14 +1963,14 @@ enum sci_status scic_controller_initialize(
1969 struct scic_sds_controller *scic) 1963 struct scic_sds_controller *scic)
1970{ 1964{
1971 enum sci_status status = SCI_FAILURE_INVALID_STATE; 1965 enum sci_status status = SCI_FAILURE_INVALID_STATE;
1972 sci_base_controller_handler_t initialize; 1966 scic_sds_controller_handler_t initialize;
1973 u32 state; 1967 u32 state;
1974 1968
1975 state = scic->parent.state_machine.current_state_id; 1969 state = scic->state_machine.current_state_id;
1976 initialize = scic_sds_controller_state_handler_table[state].base.initialize; 1970 initialize = scic_sds_controller_state_handler_table[state].initialize;
1977 1971
1978 if (initialize) 1972 if (initialize)
1979 status = initialize(&scic->parent); 1973 status = initialize(scic);
1980 else 1974 else
1981 dev_warn(scic_to_dev(scic), 1975 dev_warn(scic_to_dev(scic),
1982 "%s: SCIC Controller initialize operation requested " 1976 "%s: SCIC Controller initialize operation requested "
@@ -2050,14 +2044,14 @@ enum sci_status scic_controller_start(
2050 u32 timeout) 2044 u32 timeout)
2051{ 2045{
2052 enum sci_status status = SCI_FAILURE_INVALID_STATE; 2046 enum sci_status status = SCI_FAILURE_INVALID_STATE;
2053 sci_base_controller_timed_handler_t start; 2047 scic_sds_controller_timed_handler_t start;
2054 u32 state; 2048 u32 state;
2055 2049
2056 state = scic->parent.state_machine.current_state_id; 2050 state = scic->state_machine.current_state_id;
2057 start = scic_sds_controller_state_handler_table[state].base.start; 2051 start = scic_sds_controller_state_handler_table[state].start;
2058 2052
2059 if (start) 2053 if (start)
2060 status = start(&scic->parent, timeout); 2054 status = start(scic, timeout);
2061 else 2055 else
2062 dev_warn(scic_to_dev(scic), 2056 dev_warn(scic_to_dev(scic),
2063 "%s: SCIC Controller start operation requested in " 2057 "%s: SCIC Controller start operation requested in "
@@ -2089,14 +2083,14 @@ enum sci_status scic_controller_stop(
2089 u32 timeout) 2083 u32 timeout)
2090{ 2084{
2091 enum sci_status status = SCI_FAILURE_INVALID_STATE; 2085 enum sci_status status = SCI_FAILURE_INVALID_STATE;
2092 sci_base_controller_timed_handler_t stop; 2086 scic_sds_controller_timed_handler_t stop;
2093 u32 state; 2087 u32 state;
2094 2088
2095 state = scic->parent.state_machine.current_state_id; 2089 state = scic->state_machine.current_state_id;
2096 stop = scic_sds_controller_state_handler_table[state].base.stop; 2090 stop = scic_sds_controller_state_handler_table[state].stop;
2097 2091
2098 if (stop) 2092 if (stop)
2099 status = stop(&scic->parent, timeout); 2093 status = stop(scic, timeout);
2100 else 2094 else
2101 dev_warn(scic_to_dev(scic), 2095 dev_warn(scic_to_dev(scic),
2102 "%s: SCIC Controller stop operation requested in " 2096 "%s: SCIC Controller stop operation requested in "
@@ -2121,14 +2115,14 @@ enum sci_status scic_controller_reset(
2121 struct scic_sds_controller *scic) 2115 struct scic_sds_controller *scic)
2122{ 2116{
2123 enum sci_status status = SCI_FAILURE_INVALID_STATE; 2117 enum sci_status status = SCI_FAILURE_INVALID_STATE;
2124 sci_base_controller_handler_t reset; 2118 scic_sds_controller_handler_t reset;
2125 u32 state; 2119 u32 state;
2126 2120
2127 state = scic->parent.state_machine.current_state_id; 2121 state = scic->state_machine.current_state_id;
2128 reset = scic_sds_controller_state_handler_table[state].base.reset; 2122 reset = scic_sds_controller_state_handler_table[state].reset;
2129 2123
2130 if (reset) 2124 if (reset)
2131 status = reset(&scic->parent); 2125 status = reset(scic);
2132 else 2126 else
2133 dev_warn(scic_to_dev(scic), 2127 dev_warn(scic_to_dev(scic),
2134 "%s: SCIC Controller reset operation requested in " 2128 "%s: SCIC Controller reset operation requested in "
@@ -2171,12 +2165,12 @@ enum sci_io_status scic_controller_start_io(
2171 u16 io_tag) 2165 u16 io_tag)
2172{ 2166{
2173 u32 state; 2167 u32 state;
2174 sci_base_controller_start_request_handler_t start_io; 2168 scic_sds_controller_start_request_handler_t start_io;
2175 2169
2176 state = scic->parent.state_machine.current_state_id; 2170 state = scic->state_machine.current_state_id;
2177 start_io = scic_sds_controller_state_handler_table[state].base.start_io; 2171 start_io = scic_sds_controller_state_handler_table[state].start_io;
2178 2172
2179 return start_io(&scic->parent, 2173 return start_io(scic,
2180 (struct sci_base_remote_device *) remote_device, 2174 (struct sci_base_remote_device *) remote_device,
2181 (struct sci_base_request *)io_request, io_tag); 2175 (struct sci_base_request *)io_request, io_tag);
2182} 2176}
@@ -2202,13 +2196,13 @@ enum sci_status scic_controller_terminate_request(
2202 struct scic_sds_remote_device *remote_device, 2196 struct scic_sds_remote_device *remote_device,
2203 struct scic_sds_request *request) 2197 struct scic_sds_request *request)
2204{ 2198{
2205 sci_base_controller_request_handler_t terminate_request; 2199 scic_sds_controller_request_handler_t terminate_request;
2206 u32 state; 2200 u32 state;
2207 2201
2208 state = scic->parent.state_machine.current_state_id; 2202 state = scic->state_machine.current_state_id;
2209 terminate_request = scic_sds_controller_state_handler_table[state].terminate_request; 2203 terminate_request = scic_sds_controller_state_handler_table[state].terminate_request;
2210 2204
2211 return terminate_request(&scic->parent, 2205 return terminate_request(scic,
2212 (struct sci_base_remote_device *)remote_device, 2206 (struct sci_base_remote_device *)remote_device,
2213 (struct sci_base_request *)request); 2207 (struct sci_base_request *)request);
2214} 2208}
@@ -2241,12 +2235,12 @@ enum sci_status scic_controller_complete_io(
2241 struct scic_sds_request *io_request) 2235 struct scic_sds_request *io_request)
2242{ 2236{
2243 u32 state; 2237 u32 state;
2244 sci_base_controller_request_handler_t complete_io; 2238 scic_sds_controller_request_handler_t complete_io;
2245 2239
2246 state = scic->parent.state_machine.current_state_id; 2240 state = scic->state_machine.current_state_id;
2247 complete_io = scic_sds_controller_state_handler_table[state].base.complete_io; 2241 complete_io = scic_sds_controller_state_handler_table[state].complete_io;
2248 2242
2249 return complete_io(&scic->parent, 2243 return complete_io(scic,
2250 (struct sci_base_remote_device *)remote_device, 2244 (struct sci_base_remote_device *)remote_device,
2251 (struct sci_base_request *)io_request); 2245 (struct sci_base_request *)io_request);
2252} 2246}
@@ -2286,14 +2280,14 @@ enum sci_task_status scic_controller_start_task(
2286 u16 task_tag) 2280 u16 task_tag)
2287{ 2281{
2288 u32 state; 2282 u32 state;
2289 sci_base_controller_start_request_handler_t start_task; 2283 scic_sds_controller_start_request_handler_t start_task;
2290 enum sci_task_status status = SCI_TASK_FAILURE_INVALID_STATE; 2284 enum sci_task_status status = SCI_TASK_FAILURE_INVALID_STATE;
2291 2285
2292 state = scic->parent.state_machine.current_state_id; 2286 state = scic->state_machine.current_state_id;
2293 start_task = scic_sds_controller_state_handler_table[state].base.start_task; 2287 start_task = scic_sds_controller_state_handler_table[state].start_task;
2294 2288
2295 if (start_task) 2289 if (start_task)
2296 status = start_task(&scic->parent, 2290 status = start_task(scic,
2297 (struct sci_base_remote_device *)remote_device, 2291 (struct sci_base_remote_device *)remote_device,
2298 (struct sci_base_request *)task_request, 2292 (struct sci_base_request *)task_request,
2299 task_tag); 2293 task_tag);
@@ -2326,14 +2320,14 @@ enum sci_status scic_controller_complete_task(
2326 struct scic_sds_request *task_request) 2320 struct scic_sds_request *task_request)
2327{ 2321{
2328 u32 state; 2322 u32 state;
2329 sci_base_controller_request_handler_t complete_task; 2323 scic_sds_controller_request_handler_t complete_task;
2330 enum sci_status status = SCI_FAILURE_INVALID_STATE; 2324 enum sci_status status = SCI_FAILURE_INVALID_STATE;
2331 2325
2332 state = scic->parent.state_machine.current_state_id; 2326 state = scic->state_machine.current_state_id;
2333 complete_task = scic_sds_controller_state_handler_table[state].base.complete_task; 2327 complete_task = scic_sds_controller_state_handler_table[state].complete_task;
2334 2328
2335 if (complete_task) 2329 if (complete_task)
2336 status = complete_task(&scic->parent, 2330 status = complete_task(scic,
2337 (struct sci_base_remote_device *)remote_device, 2331 (struct sci_base_remote_device *)remote_device,
2338 (struct sci_base_request *)task_request); 2332 (struct sci_base_request *)task_request);
2339 else 2333 else
@@ -2518,9 +2512,9 @@ static enum sci_status scic_controller_set_mode(
2518{ 2512{
2519 enum sci_status status = SCI_SUCCESS; 2513 enum sci_status status = SCI_SUCCESS;
2520 2514
2521 if ((scic->parent.state_machine.current_state_id == 2515 if ((scic->state_machine.current_state_id ==
2522 SCI_BASE_CONTROLLER_STATE_INITIALIZING) || 2516 SCI_BASE_CONTROLLER_STATE_INITIALIZING) ||
2523 (scic->parent.state_machine.current_state_id == 2517 (scic->state_machine.current_state_id ==
2524 SCI_BASE_CONTROLLER_STATE_INITIALIZED)) { 2518 SCI_BASE_CONTROLLER_STATE_INITIALIZED)) {
2525 switch (operating_mode) { 2519 switch (operating_mode) {
2526 case SCI_MODE_SPEED: 2520 case SCI_MODE_SPEED:
@@ -2583,7 +2577,7 @@ enum sci_status scic_user_parameters_set(
2583 struct scic_sds_controller *scic, 2577 struct scic_sds_controller *scic,
2584 union scic_user_parameters *scic_parms) 2578 union scic_user_parameters *scic_parms)
2585{ 2579{
2586 u32 state = scic->parent.state_machine.current_state_id; 2580 u32 state = scic->state_machine.current_state_id;
2587 2581
2588 if (state == SCI_BASE_CONTROLLER_STATE_RESET || 2582 if (state == SCI_BASE_CONTROLLER_STATE_RESET ||
2589 state == SCI_BASE_CONTROLLER_STATE_INITIALIZING || 2583 state == SCI_BASE_CONTROLLER_STATE_INITIALIZING ||
@@ -2637,7 +2631,7 @@ enum sci_status scic_oem_parameters_set(
2637 struct scic_sds_controller *scic, 2631 struct scic_sds_controller *scic,
2638 union scic_oem_parameters *scic_parms) 2632 union scic_oem_parameters *scic_parms)
2639{ 2633{
2640 u32 state = scic->parent.state_machine.current_state_id; 2634 u32 state = scic->state_machine.current_state_id;
2641 2635
2642 if (state == SCI_BASE_CONTROLLER_STATE_RESET || 2636 if (state == SCI_BASE_CONTROLLER_STATE_RESET ||
2643 state == SCI_BASE_CONTROLLER_STATE_INITIALIZING || 2637 state == SCI_BASE_CONTROLLER_STATE_INITIALIZING ||
@@ -2819,54 +2813,52 @@ struct scic_sds_controller *scic_controller_alloc(struct device *dev)
2819 return devm_kzalloc(dev, sizeof(struct scic_sds_controller), GFP_KERNEL); 2813 return devm_kzalloc(dev, sizeof(struct scic_sds_controller), GFP_KERNEL);
2820} 2814}
2821 2815
2822static enum sci_status default_controller_handler(struct sci_base_controller *base_scic, 2816static enum sci_status
2823 const char *func) 2817default_controller_handler(struct scic_sds_controller *scic, const char *func)
2824{ 2818{
2825 struct scic_sds_controller *scic = container_of(base_scic, typeof(*scic), parent); 2819 dev_warn(scic_to_dev(scic), "%s: invalid state %d\n", func,
2826 u32 state = base_scic->state_machine.current_state_id; 2820 scic->state_machine.current_state_id);
2827
2828 dev_warn(scic_to_dev(scic), "%s: invalid state %d\n", func, state);
2829 2821
2830 return SCI_FAILURE_INVALID_STATE; 2822 return SCI_FAILURE_INVALID_STATE;
2831} 2823}
2832 2824
2833static enum sci_status scic_sds_controller_default_start_operation_handler( 2825static enum sci_status scic_sds_controller_default_start_operation_handler(
2834 struct sci_base_controller *base_scic, 2826 struct scic_sds_controller *scic,
2835 struct sci_base_remote_device *remote_device, 2827 struct sci_base_remote_device *remote_device,
2836 struct sci_base_request *io_request, 2828 struct sci_base_request *io_request,
2837 u16 io_tag) 2829 u16 io_tag)
2838{ 2830{
2839 return default_controller_handler(base_scic, __func__); 2831 return default_controller_handler(scic, __func__);
2840} 2832}
2841 2833
2842static enum sci_status scic_sds_controller_default_request_handler( 2834static enum sci_status scic_sds_controller_default_request_handler(
2843 struct sci_base_controller *base_scic, 2835 struct scic_sds_controller *scic,
2844 struct sci_base_remote_device *remote_device, 2836 struct sci_base_remote_device *remote_device,
2845 struct sci_base_request *io_request) 2837 struct sci_base_request *io_request)
2846{ 2838{
2847 return default_controller_handler(base_scic, __func__); 2839 return default_controller_handler(scic, __func__);
2848} 2840}
2849 2841
2850static enum sci_status scic_sds_controller_general_reset_handler(struct sci_base_controller *base_scic) 2842static enum sci_status
2843scic_sds_controller_general_reset_handler(struct scic_sds_controller *scic)
2851{ 2844{
2852 /* The reset operation is not a graceful cleanup just perform the state 2845 /* The reset operation is not a graceful cleanup just perform the state
2853 * transition. 2846 * transition.
2854 */ 2847 */
2855 sci_base_state_machine_change_state(&base_scic->state_machine, 2848 sci_base_state_machine_change_state(&scic->state_machine,
2856 SCI_BASE_CONTROLLER_STATE_RESETTING); 2849 SCI_BASE_CONTROLLER_STATE_RESETTING);
2857 2850
2858 return SCI_SUCCESS; 2851 return SCI_SUCCESS;
2859} 2852}
2860 2853
2861static enum sci_status scic_sds_controller_reset_state_initialize_handler(struct sci_base_controller *base_scic) 2854static enum sci_status
2855scic_sds_controller_reset_state_initialize_handler(struct scic_sds_controller *scic)
2862{ 2856{
2863 struct sci_base_state_machine *sm = &base_scic->state_machine; 2857 struct sci_base_state_machine *sm = &scic->state_machine;
2864 enum sci_status result = SCI_SUCCESS; 2858 enum sci_status result = SCI_SUCCESS;
2865 struct scic_sds_controller *scic;
2866 struct isci_host *ihost; 2859 struct isci_host *ihost;
2867 u32 index, state; 2860 u32 index, state;
2868 2861
2869 scic = container_of(base_scic, typeof(*scic), parent);
2870 ihost = sci_object_get_association(scic); 2862 ihost = sci_object_get_association(scic);
2871 2863
2872 sci_base_state_machine_change_state(sm, SCI_BASE_CONTROLLER_STATE_INITIALIZING); 2864 sci_base_state_machine_change_state(sm, SCI_BASE_CONTROLLER_STATE_INITIALIZING);
@@ -3028,13 +3020,7 @@ static enum sci_status scic_sds_controller_reset_state_initialize_handler(struct
3028 * * INITIALIZED STATE HANDLERS 3020 * * INITIALIZED STATE HANDLERS
3029 * ***************************************************************************** */ 3021 * ***************************************************************************** */
3030 3022
3031/** 3023/*
3032 *
3033 * @controller: This is the struct sci_base_controller object which is cast
3034 * into a struct scic_sds_controller object.
3035 * @timeout: This is the allowed time for the controller object to reach the
3036 * started state.
3037 *
3038 * This function is the struct scic_sds_controller start handler for the 3024 * This function is the struct scic_sds_controller start handler for the
3039 * initialized state. 3025 * initialized state.
3040 * - Validate we have a good memory descriptor table - Initialze the 3026 * - Validate we have a good memory descriptor table - Initialze the
@@ -3049,14 +3035,10 @@ static enum sci_status scic_sds_controller_reset_state_initialize_handler(struct
3049 * descriptor fields is invalid. 3035 * descriptor fields is invalid.
3050 */ 3036 */
3051static enum sci_status scic_sds_controller_initialized_state_start_handler( 3037static enum sci_status scic_sds_controller_initialized_state_start_handler(
3052 struct sci_base_controller *base_scic, 3038 struct scic_sds_controller *scic, u32 timeout)
3053 u32 timeout)
3054{ 3039{
3055 u16 index; 3040 u16 index;
3056 enum sci_status result; 3041 enum sci_status result;
3057 struct scic_sds_controller *scic;
3058
3059 scic = container_of(base_scic, typeof(*scic), parent);
3060 3042
3061 /* 3043 /*
3062 * Make sure that the SCI User filled in the memory descriptor 3044 * Make sure that the SCI User filled in the memory descriptor
@@ -3119,7 +3101,7 @@ static enum sci_status scic_sds_controller_initialized_state_start_handler(
3119 3101
3120 isci_timer_start(scic->timeout_timer, timeout); 3102 isci_timer_start(scic->timeout_timer, timeout);
3121 3103
3122 sci_base_state_machine_change_state(&base_scic->state_machine, 3104 sci_base_state_machine_change_state(&scic->state_machine,
3123 SCI_BASE_CONTROLLER_STATE_STARTING); 3105 SCI_BASE_CONTROLLER_STATE_STARTING);
3124 } 3106 }
3125 3107
@@ -3180,79 +3162,54 @@ static void scic_sds_controller_starting_state_link_down_handler(
3180 /* scic_sds_port_link_down(port, phy); */ 3162 /* scic_sds_port_link_down(port, phy); */
3181} 3163}
3182 3164
3183static enum sci_status scic_sds_controller_ready_state_stop_handler(struct sci_base_controller *base_scic, 3165static enum sci_status scic_sds_controller_ready_state_stop_handler(
3184 u32 timeout) 3166 struct scic_sds_controller *scic,
3167 u32 timeout)
3185{ 3168{
3186 struct scic_sds_controller *scic;
3187
3188 scic = container_of(base_scic, typeof(*scic), parent);
3189 isci_timer_start(scic->timeout_timer, timeout); 3169 isci_timer_start(scic->timeout_timer, timeout);
3190 sci_base_state_machine_change_state(&base_scic->state_machine, 3170 sci_base_state_machine_change_state(&scic->state_machine,
3191 SCI_BASE_CONTROLLER_STATE_STOPPING); 3171 SCI_BASE_CONTROLLER_STATE_STOPPING);
3192
3193 return SCI_SUCCESS; 3172 return SCI_SUCCESS;
3194} 3173}
3195 3174
3196/** 3175/*
3197 *
3198 * @controller: This is struct sci_base_controller object which is cast into a
3199 * struct scic_sds_controller object.
3200 * @remote_device: This is struct sci_base_remote_device which is cast to a
3201 * struct scic_sds_remote_device object.
3202 * @io_request: This is the struct sci_base_request which is cast to a
3203 * SCIC_SDS_IO_REQUEST object.
3204 * @io_tag: This is the IO tag to be assigned to the IO request or
3205 * SCI_CONTROLLER_INVALID_IO_TAG.
3206 *
3207 * This method is called when the struct scic_sds_controller is in the ready state and 3176 * This method is called when the struct scic_sds_controller is in the ready state and
3208 * the start io handler is called. - Start the io request on the remote device 3177 * the start io handler is called. - Start the io request on the remote device
3209 * - if successful - assign the io_request to the io_request_table - post the 3178 * - if successful - assign the io_request to the io_request_table - post the
3210 * request to the hardware enum sci_status SCI_SUCCESS if the start io operation 3179 * request to the hardware enum sci_status SCI_SUCCESS if the start io operation
3211 * succeeds SCI_FAILURE_INSUFFICIENT_RESOURCES if the IO tag could not be 3180 * succeeds SCI_FAILURE_INSUFFICIENT_RESOURCES if the IO tag could not be
3212 * allocated for the io request. SCI_FAILURE_INVALID_STATE if one or more 3181 * allocated for the io request. SCI_FAILURE_INVALID_STATE if one or more
3213 * objects are not in a valid state to accept io requests. How does the io_tag 3182 * objects are not in a valid state to accept io requests.
3214 * parameter get assigned to the io request? 3183 *
3184 * XXX: How does the io_tag parameter get assigned to the io request?
3215 */ 3185 */
3216static enum sci_status scic_sds_controller_ready_state_start_io_handler( 3186static enum sci_status scic_sds_controller_ready_state_start_io_handler(
3217 struct sci_base_controller *controller, 3187 struct scic_sds_controller *controller,
3218 struct sci_base_remote_device *remote_device, 3188 struct sci_base_remote_device *remote_device,
3219 struct sci_base_request *io_request, 3189 struct sci_base_request *io_request,
3220 u16 io_tag) 3190 u16 io_tag)
3221{ 3191{
3222 enum sci_status status; 3192 enum sci_status status;
3223 3193
3224 struct scic_sds_controller *this_controller;
3225 struct scic_sds_request *the_request; 3194 struct scic_sds_request *the_request;
3226 struct scic_sds_remote_device *the_device; 3195 struct scic_sds_remote_device *the_device;
3227 3196
3228 this_controller = (struct scic_sds_controller *)controller;
3229 the_request = (struct scic_sds_request *)io_request; 3197 the_request = (struct scic_sds_request *)io_request;
3230 the_device = (struct scic_sds_remote_device *)remote_device; 3198 the_device = (struct scic_sds_remote_device *)remote_device;
3231 3199
3232 status = scic_sds_remote_device_start_io(this_controller, the_device, the_request); 3200 status = scic_sds_remote_device_start_io(controller, the_device, the_request);
3233
3234 if (status == SCI_SUCCESS) {
3235 this_controller->io_request_table[
3236 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
3237 3201
3238 scic_sds_controller_post_request( 3202 if (status != SCI_SUCCESS)
3239 this_controller, 3203 return status;
3240 scic_sds_request_get_post_context(the_request)
3241 );
3242 }
3243 3204
3244 return status; 3205 controller->io_request_table[
3206 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
3207 scic_sds_controller_post_request(controller,
3208 scic_sds_request_get_post_context(the_request));
3209 return SCI_SUCCESS;
3245} 3210}
3246 3211
3247/** 3212/*
3248 *
3249 * @controller: This is struct sci_base_controller object which is cast into a
3250 * struct scic_sds_controller object.
3251 * @remote_device: This is struct sci_base_remote_device which is cast to a
3252 * struct scic_sds_remote_device object.
3253 * @io_request: This is the struct sci_base_request which is cast to a
3254 * SCIC_SDS_IO_REQUEST object.
3255 *
3256 * This method is called when the struct scic_sds_controller is in the ready state and 3213 * This method is called when the struct scic_sds_controller is in the ready state and
3257 * the complete io handler is called. - Complete the io request on the remote 3214 * the complete io handler is called. - Complete the io request on the remote
3258 * device - if successful - remove the io_request to the io_request_table 3215 * device - if successful - remove the io_request to the io_request_table
@@ -3261,76 +3218,49 @@ static enum sci_status scic_sds_controller_ready_state_start_io_handler(
3261 * accept io requests. 3218 * accept io requests.
3262 */ 3219 */
3263static enum sci_status scic_sds_controller_ready_state_complete_io_handler( 3220static enum sci_status scic_sds_controller_ready_state_complete_io_handler(
3264 struct sci_base_controller *controller, 3221 struct scic_sds_controller *controller,
3265 struct sci_base_remote_device *remote_device, 3222 struct sci_base_remote_device *remote_device,
3266 struct sci_base_request *io_request) 3223 struct sci_base_request *io_request)
3267{ 3224{
3268 u16 index; 3225 u16 index;
3269 enum sci_status status; 3226 enum sci_status status;
3270 struct scic_sds_controller *this_controller;
3271 struct scic_sds_request *the_request; 3227 struct scic_sds_request *the_request;
3272 struct scic_sds_remote_device *the_device; 3228 struct scic_sds_remote_device *the_device;
3273 3229
3274 this_controller = (struct scic_sds_controller *)controller;
3275 the_request = (struct scic_sds_request *)io_request; 3230 the_request = (struct scic_sds_request *)io_request;
3276 the_device = (struct scic_sds_remote_device *)remote_device; 3231 the_device = (struct scic_sds_remote_device *)remote_device;
3277 3232
3278 status = scic_sds_remote_device_complete_io( 3233 status = scic_sds_remote_device_complete_io(controller, the_device,
3279 this_controller, the_device, the_request); 3234 the_request);
3280 3235 if (status != SCI_SUCCESS)
3281 if (status == SCI_SUCCESS) { 3236 return status;
3282 index = scic_sds_io_tag_get_index(the_request->io_tag);
3283 this_controller->io_request_table[index] = NULL;
3284 }
3285 3237
3286 return status; 3238 index = scic_sds_io_tag_get_index(the_request->io_tag);
3239 controller->io_request_table[index] = NULL;
3240 return SCI_SUCCESS;
3287} 3241}
3288 3242
3289/** 3243/*
3290 *
3291 * @controller: This is struct sci_base_controller object which is cast into a
3292 * struct scic_sds_controller object.
3293 * @remote_device: This is struct sci_base_remote_device which is cast to a
3294 * struct scic_sds_remote_device object.
3295 * @io_request: This is the struct sci_base_request which is cast to a
3296 * SCIC_SDS_IO_REQUEST object.
3297 *
3298 * This method is called when the struct scic_sds_controller is in the ready state and 3244 * This method is called when the struct scic_sds_controller is in the ready state and
3299 * the continue io handler is called. enum sci_status 3245 * the continue io handler is called. enum sci_status
3300 */ 3246 */
3301static enum sci_status scic_sds_controller_ready_state_continue_io_handler( 3247static enum sci_status scic_sds_controller_ready_state_continue_io_handler(
3302 struct sci_base_controller *controller, 3248 struct scic_sds_controller *controller,
3303 struct sci_base_remote_device *remote_device, 3249 struct sci_base_remote_device *remote_device,
3304 struct sci_base_request *io_request) 3250 struct sci_base_request *io_request)
3305{ 3251{
3306 struct scic_sds_controller *this_controller;
3307 struct scic_sds_request *the_request; 3252 struct scic_sds_request *the_request;
3308 3253
3309 the_request = (struct scic_sds_request *)io_request; 3254 the_request = (struct scic_sds_request *)io_request;
3310 this_controller = (struct scic_sds_controller *)controller;
3311 3255
3312 this_controller->io_request_table[ 3256 controller->io_request_table[
3313 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3257 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
3314 3258 scic_sds_controller_post_request(controller,
3315 scic_sds_controller_post_request( 3259 scic_sds_request_get_post_context(the_request));
3316 this_controller,
3317 scic_sds_request_get_post_context(the_request)
3318 );
3319
3320 return SCI_SUCCESS; 3260 return SCI_SUCCESS;
3321} 3261}
3322 3262
3323/** 3263/*
3324 *
3325 * @controller: This is struct sci_base_controller object which is cast into a
3326 * struct scic_sds_controller object.
3327 * @remote_device: This is struct sci_base_remote_device which is cast to a
3328 * struct scic_sds_remote_device object.
3329 * @io_request: This is the struct sci_base_request which is cast to a
3330 * SCIC_SDS_IO_REQUEST object.
3331 * @task_tag: This is the task tag to be assigned to the task request or
3332 * SCI_CONTROLLER_INVALID_IO_TAG.
3333 *
3334 * This method is called when the struct scic_sds_controller is in the ready state and 3264 * This method is called when the struct scic_sds_controller is in the ready state and
3335 * the start task handler is called. - The remote device is requested to start 3265 * the start task handler is called. - The remote device is requested to start
3336 * the task request - if successful - assign the task to the io_request_table - 3266 * the task request - if successful - assign the task to the io_request_table -
@@ -3341,33 +3271,28 @@ static enum sci_status scic_sds_controller_ready_state_continue_io_handler(
3341 * tag get assigned in this code path? 3271 * tag get assigned in this code path?
3342 */ 3272 */
3343static enum sci_status scic_sds_controller_ready_state_start_task_handler( 3273static enum sci_status scic_sds_controller_ready_state_start_task_handler(
3344 struct sci_base_controller *controller, 3274 struct scic_sds_controller *controller,
3345 struct sci_base_remote_device *remote_device, 3275 struct sci_base_remote_device *remote_device,
3346 struct sci_base_request *io_request, 3276 struct sci_base_request *io_request,
3347 u16 task_tag) 3277 u16 task_tag)
3348{ 3278{
3349 struct scic_sds_controller *this_controller = (struct scic_sds_controller *)
3350 controller;
3351 struct scic_sds_request *the_request = (struct scic_sds_request *) 3279 struct scic_sds_request *the_request = (struct scic_sds_request *)
3352 io_request; 3280 io_request;
3353 struct scic_sds_remote_device *the_device = (struct scic_sds_remote_device *) 3281 struct scic_sds_remote_device *the_device = (struct scic_sds_remote_device *)
3354 remote_device; 3282 remote_device;
3355 enum sci_status status; 3283 enum sci_status status;
3356 3284
3357 status = scic_sds_remote_device_start_task( 3285 status = scic_sds_remote_device_start_task(controller, the_device,
3358 this_controller, the_device, the_request 3286 the_request);
3359 );
3360 3287
3361 if (status == SCI_SUCCESS) { 3288 if (status == SCI_SUCCESS) {
3362 this_controller->io_request_table[ 3289 controller->io_request_table[
3363 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3290 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
3364 3291
3365 scic_sds_controller_post_request( 3292 scic_sds_controller_post_request(controller,
3366 this_controller, 3293 scic_sds_request_get_post_context(the_request));
3367 scic_sds_request_get_post_context(the_request)
3368 );
3369 } else if (status == SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS) { 3294 } else if (status == SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS) {
3370 this_controller->io_request_table[ 3295 controller->io_request_table[
3371 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request; 3296 scic_sds_io_tag_get_index(the_request->io_tag)] = the_request;
3372 3297
3373 /* 3298 /*
@@ -3379,15 +3304,7 @@ static enum sci_status scic_sds_controller_ready_state_start_task_handler(
3379 return status; 3304 return status;
3380} 3305}
3381 3306
3382/** 3307/*
3383 *
3384 * @controller: This is struct sci_base_controller object which is cast into a
3385 * struct scic_sds_controller object.
3386 * @remote_device: This is struct sci_base_remote_device which is cast to a
3387 * struct scic_sds_remote_device object.
3388 * @io_request: This is the struct sci_base_request which is cast to a
3389 * SCIC_SDS_IO_REQUEST object.
3390 *
3391 * This method is called when the struct scic_sds_controller is in the ready state and 3308 * This method is called when the struct scic_sds_controller is in the ready state and
3392 * the terminate request handler is called. - call the io request terminate 3309 * the terminate request handler is called. - call the io request terminate
3393 * function - if successful - post the terminate request to the SCU hardware 3310 * function - if successful - post the terminate request to the SCU hardware
@@ -3396,29 +3313,26 @@ static enum sci_status scic_sds_controller_ready_state_start_task_handler(
3396 * accept io requests. 3313 * accept io requests.
3397 */ 3314 */
3398static enum sci_status scic_sds_controller_ready_state_terminate_request_handler( 3315static enum sci_status scic_sds_controller_ready_state_terminate_request_handler(
3399 struct sci_base_controller *controller, 3316 struct scic_sds_controller *controller,
3400 struct sci_base_remote_device *remote_device, 3317 struct sci_base_remote_device *remote_device,
3401 struct sci_base_request *io_request) 3318 struct sci_base_request *io_request)
3402{ 3319{
3403 struct scic_sds_controller *this_controller = (struct scic_sds_controller *)
3404 controller;
3405 struct scic_sds_request *the_request = (struct scic_sds_request *) 3320 struct scic_sds_request *the_request = (struct scic_sds_request *)
3406 io_request; 3321 io_request;
3407 enum sci_status status; 3322 enum sci_status status;
3408 3323
3409 status = scic_sds_io_request_terminate(the_request); 3324 status = scic_sds_io_request_terminate(the_request);
3410 if (status == SCI_SUCCESS) { 3325 if (status != SCI_SUCCESS)
3411 /* 3326 return status;
3412 * Utilize the original post context command and or in the POST_TC_ABORT
3413 * request sub-type. */
3414 scic_sds_controller_post_request(
3415 this_controller,
3416 scic_sds_request_get_post_context(the_request)
3417 | SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT
3418 );
3419 }
3420 3327
3421 return status; 3328 /*
3329 * Utilize the original post context command and or in the POST_TC_ABORT
3330 * request sub-type.
3331 */
3332 scic_sds_controller_post_request(controller,
3333 scic_sds_request_get_post_context(the_request) |
3334 SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT);
3335 return SCI_SUCCESS;
3422} 3336}
3423 3337
3424/** 3338/**
@@ -3470,38 +3384,20 @@ static void scic_sds_controller_ready_state_link_down_handler(
3470 * ***************************************************************************** */ 3384 * ***************************************************************************** */
3471 3385
3472/** 3386/**
3473 *
3474 * @controller: This is struct sci_base_controller object which is cast into a
3475 * struct scic_sds_controller object.
3476 * @remote_device: This is struct sci_base_remote_device which is cast to a
3477 * struct scic_sds_remote_device object.
3478 * @io_request: This is the struct sci_base_request which is cast to a
3479 * SCIC_SDS_IO_REQUEST object.
3480 *
3481 * This method is called when the struct scic_sds_controller is in a stopping state 3387 * This method is called when the struct scic_sds_controller is in a stopping state
3482 * and the complete io handler is called. - This function is not yet 3388 * and the complete io handler is called. - This function is not yet
3483 * implemented enum sci_status SCI_FAILURE 3389 * implemented enum sci_status SCI_FAILURE
3484 */ 3390 */
3485static enum sci_status scic_sds_controller_stopping_state_complete_io_handler( 3391static enum sci_status scic_sds_controller_stopping_state_complete_io_handler(
3486 struct sci_base_controller *controller, 3392 struct scic_sds_controller *controller,
3487 struct sci_base_remote_device *remote_device, 3393 struct sci_base_remote_device *remote_device,
3488 struct sci_base_request *io_request) 3394 struct sci_base_request *io_request)
3489{ 3395{
3490 struct scic_sds_controller *this_controller; 3396 /* XXX: Implement this function */
3491
3492 this_controller = (struct scic_sds_controller *)controller;
3493
3494 /* / @todo Implement this function */
3495 return SCI_FAILURE; 3397 return SCI_FAILURE;
3496} 3398}
3497 3399
3498/** 3400/**
3499 *
3500 * @controller: This is struct sci_base_controller object which is cast into a
3501 * struct scic_sds_controller object.
3502 * @remote_device: This is struct sci_base_remote_device which is cast to a
3503 * struct scic_sds_remote_device object.
3504 *
3505 * This method is called when the struct scic_sds_controller is in a stopping state 3401 * This method is called when the struct scic_sds_controller is in a stopping state
3506 * and the remote device has stopped. 3402 * and the remote device has stopped.
3507 **/ 3403 **/
@@ -3511,8 +3407,7 @@ static void scic_sds_controller_stopping_state_device_stopped_handler(
3511) 3407)
3512{ 3408{
3513 if (!scic_sds_controller_has_remote_devices_stopping(controller)) { 3409 if (!scic_sds_controller_has_remote_devices_stopping(controller)) {
3514 sci_base_state_machine_change_state( 3410 sci_base_state_machine_change_state(&controller->state_machine,
3515 &controller->parent.state_machine,
3516 SCI_BASE_CONTROLLER_STATE_STOPPED 3411 SCI_BASE_CONTROLLER_STATE_STOPPED
3517 ); 3412 );
3518 } 3413 }
@@ -3520,77 +3415,77 @@ static void scic_sds_controller_stopping_state_device_stopped_handler(
3520 3415
3521const struct scic_sds_controller_state_handler scic_sds_controller_state_handler_table[] = { 3416const struct scic_sds_controller_state_handler scic_sds_controller_state_handler_table[] = {
3522 [SCI_BASE_CONTROLLER_STATE_INITIAL] = { 3417 [SCI_BASE_CONTROLLER_STATE_INITIAL] = {
3523 .base.start_io = scic_sds_controller_default_start_operation_handler, 3418 .start_io = scic_sds_controller_default_start_operation_handler,
3524 .base.complete_io = scic_sds_controller_default_request_handler, 3419 .complete_io = scic_sds_controller_default_request_handler,
3525 .base.continue_io = scic_sds_controller_default_request_handler, 3420 .continue_io = scic_sds_controller_default_request_handler,
3526 .terminate_request = scic_sds_controller_default_request_handler, 3421 .terminate_request = scic_sds_controller_default_request_handler,
3527 }, 3422 },
3528 [SCI_BASE_CONTROLLER_STATE_RESET] = { 3423 [SCI_BASE_CONTROLLER_STATE_RESET] = {
3529 .base.reset = scic_sds_controller_general_reset_handler, 3424 .reset = scic_sds_controller_general_reset_handler,
3530 .base.initialize = scic_sds_controller_reset_state_initialize_handler, 3425 .initialize = scic_sds_controller_reset_state_initialize_handler,
3531 .base.start_io = scic_sds_controller_default_start_operation_handler, 3426 .start_io = scic_sds_controller_default_start_operation_handler,
3532 .base.complete_io = scic_sds_controller_default_request_handler, 3427 .complete_io = scic_sds_controller_default_request_handler,
3533 .base.continue_io = scic_sds_controller_default_request_handler, 3428 .continue_io = scic_sds_controller_default_request_handler,
3534 .terminate_request = scic_sds_controller_default_request_handler, 3429 .terminate_request = scic_sds_controller_default_request_handler,
3535 }, 3430 },
3536 [SCI_BASE_CONTROLLER_STATE_INITIALIZING] = { 3431 [SCI_BASE_CONTROLLER_STATE_INITIALIZING] = {
3537 .base.start_io = scic_sds_controller_default_start_operation_handler, 3432 .start_io = scic_sds_controller_default_start_operation_handler,
3538 .base.complete_io = scic_sds_controller_default_request_handler, 3433 .complete_io = scic_sds_controller_default_request_handler,
3539 .base.continue_io = scic_sds_controller_default_request_handler, 3434 .continue_io = scic_sds_controller_default_request_handler,
3540 .terminate_request = scic_sds_controller_default_request_handler, 3435 .terminate_request = scic_sds_controller_default_request_handler,
3541 }, 3436 },
3542 [SCI_BASE_CONTROLLER_STATE_INITIALIZED] = { 3437 [SCI_BASE_CONTROLLER_STATE_INITIALIZED] = {
3543 .base.start = scic_sds_controller_initialized_state_start_handler, 3438 .start = scic_sds_controller_initialized_state_start_handler,
3544 .base.start_io = scic_sds_controller_default_start_operation_handler, 3439 .start_io = scic_sds_controller_default_start_operation_handler,
3545 .base.complete_io = scic_sds_controller_default_request_handler, 3440 .complete_io = scic_sds_controller_default_request_handler,
3546 .base.continue_io = scic_sds_controller_default_request_handler, 3441 .continue_io = scic_sds_controller_default_request_handler,
3547 .terminate_request = scic_sds_controller_default_request_handler, 3442 .terminate_request = scic_sds_controller_default_request_handler,
3548 }, 3443 },
3549 [SCI_BASE_CONTROLLER_STATE_STARTING] = { 3444 [SCI_BASE_CONTROLLER_STATE_STARTING] = {
3550 .base.start_io = scic_sds_controller_default_start_operation_handler, 3445 .start_io = scic_sds_controller_default_start_operation_handler,
3551 .base.complete_io = scic_sds_controller_default_request_handler, 3446 .complete_io = scic_sds_controller_default_request_handler,
3552 .base.continue_io = scic_sds_controller_default_request_handler, 3447 .continue_io = scic_sds_controller_default_request_handler,
3553 .terminate_request = scic_sds_controller_default_request_handler, 3448 .terminate_request = scic_sds_controller_default_request_handler,
3554 .link_up = scic_sds_controller_starting_state_link_up_handler, 3449 .link_up = scic_sds_controller_starting_state_link_up_handler,
3555 .link_down = scic_sds_controller_starting_state_link_down_handler 3450 .link_down = scic_sds_controller_starting_state_link_down_handler
3556 }, 3451 },
3557 [SCI_BASE_CONTROLLER_STATE_READY] = { 3452 [SCI_BASE_CONTROLLER_STATE_READY] = {
3558 .base.stop = scic_sds_controller_ready_state_stop_handler, 3453 .stop = scic_sds_controller_ready_state_stop_handler,
3559 .base.reset = scic_sds_controller_general_reset_handler, 3454 .reset = scic_sds_controller_general_reset_handler,
3560 .base.start_io = scic_sds_controller_ready_state_start_io_handler, 3455 .start_io = scic_sds_controller_ready_state_start_io_handler,
3561 .base.complete_io = scic_sds_controller_ready_state_complete_io_handler, 3456 .complete_io = scic_sds_controller_ready_state_complete_io_handler,
3562 .base.continue_io = scic_sds_controller_ready_state_continue_io_handler, 3457 .continue_io = scic_sds_controller_ready_state_continue_io_handler,
3563 .base.start_task = scic_sds_controller_ready_state_start_task_handler, 3458 .start_task = scic_sds_controller_ready_state_start_task_handler,
3564 .base.complete_task = scic_sds_controller_ready_state_complete_io_handler, 3459 .complete_task = scic_sds_controller_ready_state_complete_io_handler,
3565 .terminate_request = scic_sds_controller_ready_state_terminate_request_handler, 3460 .terminate_request = scic_sds_controller_ready_state_terminate_request_handler,
3566 .link_up = scic_sds_controller_ready_state_link_up_handler, 3461 .link_up = scic_sds_controller_ready_state_link_up_handler,
3567 .link_down = scic_sds_controller_ready_state_link_down_handler 3462 .link_down = scic_sds_controller_ready_state_link_down_handler
3568 }, 3463 },
3569 [SCI_BASE_CONTROLLER_STATE_RESETTING] = { 3464 [SCI_BASE_CONTROLLER_STATE_RESETTING] = {
3570 .base.start_io = scic_sds_controller_default_start_operation_handler, 3465 .start_io = scic_sds_controller_default_start_operation_handler,
3571 .base.complete_io = scic_sds_controller_default_request_handler, 3466 .complete_io = scic_sds_controller_default_request_handler,
3572 .base.continue_io = scic_sds_controller_default_request_handler, 3467 .continue_io = scic_sds_controller_default_request_handler,
3573 .terminate_request = scic_sds_controller_default_request_handler, 3468 .terminate_request = scic_sds_controller_default_request_handler,
3574 }, 3469 },
3575 [SCI_BASE_CONTROLLER_STATE_STOPPING] = { 3470 [SCI_BASE_CONTROLLER_STATE_STOPPING] = {
3576 .base.start_io = scic_sds_controller_default_start_operation_handler, 3471 .start_io = scic_sds_controller_default_start_operation_handler,
3577 .base.complete_io = scic_sds_controller_stopping_state_complete_io_handler, 3472 .complete_io = scic_sds_controller_stopping_state_complete_io_handler,
3578 .base.continue_io = scic_sds_controller_default_request_handler, 3473 .continue_io = scic_sds_controller_default_request_handler,
3579 .terminate_request = scic_sds_controller_default_request_handler, 3474 .terminate_request = scic_sds_controller_default_request_handler,
3580 .device_stopped = scic_sds_controller_stopping_state_device_stopped_handler, 3475 .device_stopped = scic_sds_controller_stopping_state_device_stopped_handler,
3581 }, 3476 },
3582 [SCI_BASE_CONTROLLER_STATE_STOPPED] = { 3477 [SCI_BASE_CONTROLLER_STATE_STOPPED] = {
3583 .base.reset = scic_sds_controller_general_reset_handler, 3478 .reset = scic_sds_controller_general_reset_handler,
3584 .base.start_io = scic_sds_controller_default_start_operation_handler, 3479 .start_io = scic_sds_controller_default_start_operation_handler,
3585 .base.complete_io = scic_sds_controller_default_request_handler, 3480 .complete_io = scic_sds_controller_default_request_handler,
3586 .base.continue_io = scic_sds_controller_default_request_handler, 3481 .continue_io = scic_sds_controller_default_request_handler,
3587 .terminate_request = scic_sds_controller_default_request_handler, 3482 .terminate_request = scic_sds_controller_default_request_handler,
3588 }, 3483 },
3589 [SCI_BASE_CONTROLLER_STATE_FAILED] = { 3484 [SCI_BASE_CONTROLLER_STATE_FAILED] = {
3590 .base.reset = scic_sds_controller_general_reset_handler, 3485 .reset = scic_sds_controller_general_reset_handler,
3591 .base.start_io = scic_sds_controller_default_start_operation_handler, 3486 .start_io = scic_sds_controller_default_start_operation_handler,
3592 .base.complete_io = scic_sds_controller_default_request_handler, 3487 .complete_io = scic_sds_controller_default_request_handler,
3593 .base.continue_io = scic_sds_controller_default_request_handler, 3488 .continue_io = scic_sds_controller_default_request_handler,
3594 .terminate_request = scic_sds_controller_default_request_handler, 3489 .terminate_request = scic_sds_controller_default_request_handler,
3595 }, 3490 },
3596}; 3491};
@@ -3612,8 +3507,8 @@ static void scic_sds_controller_initial_state_enter(
3612 3507
3613 this_controller = (struct scic_sds_controller *)object; 3508 this_controller = (struct scic_sds_controller *)object;
3614 3509
3615 sci_base_state_machine_change_state( 3510 sci_base_state_machine_change_state(&this_controller->state_machine,
3616 &this_controller->parent.state_machine, SCI_BASE_CONTROLLER_STATE_RESET); 3511 SCI_BASE_CONTROLLER_STATE_RESET);
3617} 3512}
3618 3513
3619/** 3514/**
@@ -3718,9 +3613,9 @@ static void scic_sds_controller_resetting_state_enter(struct sci_base_object *ob
3718{ 3613{
3719 struct scic_sds_controller *scic; 3614 struct scic_sds_controller *scic;
3720 3615
3721 scic = container_of(object, typeof(*scic), parent.parent); 3616 scic = container_of(object, typeof(*scic), parent);
3722 scic_sds_controller_reset_hardware(scic); 3617 scic_sds_controller_reset_hardware(scic);
3723 sci_base_state_machine_change_state(&scic->parent.state_machine, 3618 sci_base_state_machine_change_state(&scic->state_machine,
3724 SCI_BASE_CONTROLLER_STATE_RESET); 3619 SCI_BASE_CONTROLLER_STATE_RESET);
3725} 3620}
3726 3621
@@ -3771,10 +3666,13 @@ enum sci_status scic_controller_construct(struct scic_sds_controller *scic,
3771{ 3666{
3772 u8 i; 3667 u8 i;
3773 3668
3774 sci_base_controller_construct(&scic->parent, 3669 sci_base_state_machine_construct(&scic->state_machine,
3775 scic_sds_controller_state_table, 3670 &scic->parent, scic_sds_controller_state_table,
3776 scic->memory_descriptors, 3671 SCI_BASE_CONTROLLER_STATE_INITIAL);
3777 ARRAY_SIZE(scic->memory_descriptors), NULL); 3672
3673 sci_base_mdl_construct(&scic->mdl, scic->memory_descriptors,
3674 ARRAY_SIZE(scic->memory_descriptors), NULL);
3675 sci_base_state_machine_start(&scic->state_machine);
3778 3676
3779 scic->scu_registers = scu_base; 3677 scic->scu_registers = scu_base;
3780 scic->smu_registers = smu_base; 3678 scic->smu_registers = smu_base;
diff --git a/drivers/scsi/isci/core/scic_sds_controller.h b/drivers/scsi/isci/core/scic_sds_controller.h
index baf0b9ededec..f2d7e9c05b17 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.h
+++ b/drivers/scsi/isci/core/scic_sds_controller.h
@@ -69,7 +69,9 @@
69#include "sci_pool.h" 69#include "sci_pool.h"
70#include "sci_controller_constants.h" 70#include "sci_controller_constants.h"
71#include "sci_memory_descriptor_list.h" 71#include "sci_memory_descriptor_list.h"
72#include "sci_base_controller.h" 72#include "sci_base_state.h"
73#include "sci_base_state_machine.h"
74#include "sci_base_memory_descriptor_list.h"
73#include "scic_config_parameters.h" 75#include "scic_config_parameters.h"
74#include "scic_sds_port.h" 76#include "scic_sds_port.h"
75#include "scic_sds_phy.h" 77#include "scic_sds_phy.h"
@@ -82,11 +84,12 @@
82#include "scic_sds_unsolicited_frame_control.h" 84#include "scic_sds_unsolicited_frame_control.h"
83#include "scic_sds_port_configuration_agent.h" 85#include "scic_sds_port_configuration_agent.h"
84 86
87struct sci_base_remote_device;
85struct scic_sds_remote_device; 88struct scic_sds_remote_device;
89struct sci_base_request;
86struct scic_sds_request; 90struct scic_sds_request;
87struct scic_sds_controller; 91struct scic_sds_controller;
88 92
89
90#define SCU_COMPLETION_RAM_ALIGNMENT (64) 93#define SCU_COMPLETION_RAM_ALIGNMENT (64)
91 94
92/** 95/**
@@ -166,10 +169,23 @@ struct scic_power_control {
166 */ 169 */
167struct scic_sds_controller { 170struct scic_sds_controller {
168 /** 171 /**
169 * The struct sci_base_controller is the parent object for the struct scic_sds_controller 172 * The field specifies that the parent object for the base controller
170 * object. 173 * is the base object itself.
174 */
175 struct sci_base_object parent;
176
177 /**
178 * This field points to the memory descriptor list associated with this
179 * controller. The MDL indicates the memory requirements necessary for
180 * this controller object.
181 */
182 struct sci_base_memory_descriptor_list mdl;
183
184 /**
185 * This field contains the information for the base controller state
186 * machine.
171 */ 187 */
172 struct sci_base_controller parent; 188 struct sci_base_state_machine state_machine;
173 189
174 /** 190 /**
175 * This field is the driver timer object handler used to time the controller 191 * This field is the driver timer object handler used to time the controller
@@ -376,24 +392,170 @@ struct scic_sds_controller {
376 392
377}; 393};
378 394
379typedef void (*scic_sds_controller_phy_handler_t)(struct scic_sds_controller *, 395/**
380 struct scic_sds_port *, 396 * enum scic_sds_controller_states - This enumeration depicts all the states
381 struct scic_sds_phy *); 397 * for the common controller state machine.
398 */
399enum scic_sds_controller_states {
400 /**
401 * Simply the initial state for the base controller state machine.
402 */
403 SCI_BASE_CONTROLLER_STATE_INITIAL = 0,
382 404
383typedef void (*scic_sds_controller_device_handler_t)(struct scic_sds_controller *, 405 /**
384 struct scic_sds_remote_device *); 406 * This state indicates that the controller is reset. The memory for
407 * the controller is in it's initial state, but the controller requires
408 * initialization.
409 * This state is entered from the INITIAL state.
410 * This state is entered from the RESETTING state.
411 */
412 SCI_BASE_CONTROLLER_STATE_RESET,
385 413
414 /**
415 * This state is typically an action state that indicates the controller
416 * is in the process of initialization. In this state no new IO operations
417 * are permitted.
418 * This state is entered from the RESET state.
419 */
420 SCI_BASE_CONTROLLER_STATE_INITIALIZING,
421
422 /**
423 * This state indicates that the controller has been successfully
424 * initialized. In this state no new IO operations are permitted.
425 * This state is entered from the INITIALIZING state.
426 */
427 SCI_BASE_CONTROLLER_STATE_INITIALIZED,
428
429 /**
430 * This state indicates the the controller is in the process of becoming
431 * ready (i.e. starting). In this state no new IO operations are permitted.
432 * This state is entered from the INITIALIZED state.
433 */
434 SCI_BASE_CONTROLLER_STATE_STARTING,
435
436 /**
437 * This state indicates the controller is now ready. Thus, the user
438 * is able to perform IO operations on the controller.
439 * This state is entered from the STARTING state.
440 */
441 SCI_BASE_CONTROLLER_STATE_READY,
442
443 /**
444 * This state is typically an action state that indicates the controller
445 * is in the process of resetting. Thus, the user is unable to perform
446 * IO operations on the controller. A reset is considered destructive in
447 * most cases.
448 * This state is entered from the READY state.
449 * This state is entered from the FAILED state.
450 * This state is entered from the STOPPED state.
451 */
452 SCI_BASE_CONTROLLER_STATE_RESETTING,
453
454 /**
455 * This state indicates that the controller is in the process of stopping.
456 * In this state no new IO operations are permitted, but existing IO
457 * operations are allowed to complete.
458 * This state is entered from the READY state.
459 */
460 SCI_BASE_CONTROLLER_STATE_STOPPING,
461
462 /**
463 * This state indicates that the controller has successfully been stopped.
464 * In this state no new IO operations are permitted.
465 * This state is entered from the STOPPING state.
466 */
467 SCI_BASE_CONTROLLER_STATE_STOPPED,
468
469 /**
470 * This state indicates that the controller could not successfully be
471 * initialized. In this state no new IO operations are permitted.
472 * This state is entered from the INITIALIZING state.
473 * This state is entered from the STARTING state.
474 * This state is entered from the STOPPING state.
475 * This state is entered from the RESETTING state.
476 */
477 SCI_BASE_CONTROLLER_STATE_FAILED,
478
479 SCI_BASE_CONTROLLER_MAX_STATES
480
481};
482
483typedef enum sci_status (*scic_sds_controller_handler_t)
484 (struct scic_sds_controller *);
485typedef enum sci_status (*scic_sds_controller_timed_handler_t)
486 (struct scic_sds_controller *, u32);
487typedef enum sci_status (*scic_sds_controller_request_handler_t)
488 (struct scic_sds_controller *,
489 struct sci_base_remote_device *,
490 struct sci_base_request *);
491typedef enum sci_status (*scic_sds_controller_start_request_handler_t)
492 (struct scic_sds_controller *,
493 struct sci_base_remote_device *,
494 struct sci_base_request *, u16);
495typedef void (*scic_sds_controller_phy_handler_t)
496 (struct scic_sds_controller *,
497 struct scic_sds_port *,
498 struct scic_sds_phy *);
499typedef void (*scic_sds_controller_device_handler_t)
500 (struct scic_sds_controller *,
501 struct scic_sds_remote_device *);
386 502
387/**
388 * struct scic_sds_controller_state_handler -
389 *
390 * This structure contains the SDS core specific definition for the state
391 * handlers.
392 */
393struct scic_sds_controller_state_handler { 503struct scic_sds_controller_state_handler {
394 struct sci_base_controller_state_handler base; 504 /**
505 * The start_handler specifies the method invoked when a user attempts to
506 * start a controller.
507 */
508 scic_sds_controller_timed_handler_t start;
509
510 /**
511 * The stop_handler specifies the method invoked when a user attempts to
512 * stop a controller.
513 */
514 scic_sds_controller_timed_handler_t stop;
515
516 /**
517 * The reset_handler specifies the method invoked when a user attempts to
518 * reset a controller.
519 */
520 scic_sds_controller_handler_t reset;
521
522 /**
523 * The initialize_handler specifies the method invoked when a user
524 * attempts to initialize a controller.
525 */
526 scic_sds_controller_handler_t initialize;
527
528 /**
529 * The start_io_handler specifies the method invoked when a user
530 * attempts to start an IO request for a controller.
531 */
532 scic_sds_controller_start_request_handler_t start_io;
533
534 /**
535 * The complete_io_handler specifies the method invoked when a user
536 * attempts to complete an IO request for a controller.
537 */
538 scic_sds_controller_request_handler_t complete_io;
539
540 /**
541 * The continue_io_handler specifies the method invoked when a user
542 * attempts to continue an IO request for a controller.
543 */
544 scic_sds_controller_request_handler_t continue_io;
545
546 /**
547 * The start_task_handler specifies the method invoked when a user
548 * attempts to start a task management request for a controller.
549 */
550 scic_sds_controller_start_request_handler_t start_task;
551
552 /**
553 * The complete_task_handler specifies the method invoked when a user
554 * attempts to complete a task management request for a controller.
555 */
556 scic_sds_controller_request_handler_t complete_task;
395 557
396 sci_base_controller_request_handler_t terminate_request; 558 scic_sds_controller_request_handler_t terminate_request;
397 scic_sds_controller_phy_handler_t link_up; 559 scic_sds_controller_phy_handler_t link_up;
398 scic_sds_controller_phy_handler_t link_down; 560 scic_sds_controller_phy_handler_t link_down;
399 scic_sds_controller_device_handler_t device_stopped; 561 scic_sds_controller_device_handler_t device_stopped;
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.c b/drivers/scsi/isci/core/scic_sds_remote_device.c
index a6bcaa15fbf4..b4b6be7cdfb9 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.c
@@ -563,12 +563,11 @@ void scic_sds_remote_device_continue_request(void *dev)
563 /* we need to check if this request is still valid to continue. */ 563 /* we need to check if this request is still valid to continue. */
564 if (sci_req) { 564 if (sci_req) {
565 struct scic_sds_controller *scic = sci_req->owning_controller; 565 struct scic_sds_controller *scic = sci_req->owning_controller;
566 u32 state = scic->parent.state_machine.current_state_id; 566 u32 state = scic->state_machine.current_state_id;
567 sci_base_controller_request_handler_t continue_io; 567 scic_sds_controller_request_handler_t continue_io;
568 568
569 continue_io = scic_sds_controller_state_handler_table[state].base.continue_io; 569 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
570 continue_io(&scic->parent, &sci_req->target_device->parent, 570 continue_io(scic, &sci_req->target_device->parent, &sci_req->parent);
571 &sci_req->parent);
572 } 571 }
573} 572}
574 573
diff --git a/drivers/scsi/isci/core/scic_sds_stp_request.c b/drivers/scsi/isci/core/scic_sds_stp_request.c
index 0e961e9cd6eb..5dd4896576d4 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_request.c
@@ -649,7 +649,7 @@ static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
649 u32 length) 649 u32 length)
650{ 650{
651 struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_request; 651 struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_request;
652 sci_base_controller_request_handler_t continue_io; 652 scic_sds_controller_request_handler_t continue_io;
653 struct scu_sgl_element *current_sgl; 653 struct scu_sgl_element *current_sgl;
654 struct scic_sds_controller *scic; 654 struct scic_sds_controller *scic;
655 u32 state; 655 u32 state;
@@ -675,9 +675,9 @@ static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
675 675
676 /* send the new TC out. */ 676 /* send the new TC out. */
677 scic = this_request->owning_controller; 677 scic = this_request->owning_controller;
678 state = scic->parent.state_machine.current_state_id; 678 state = scic->state_machine.current_state_id;
679 continue_io = scic_sds_controller_state_handler_table[state].base.continue_io; 679 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
680 return continue_io(&scic->parent, &this_request->target_device->parent, 680 return continue_io(scic, &this_request->target_device->parent,
681 &this_request->parent); 681 &this_request->parent);
682} 682}
683 683
@@ -1822,7 +1822,7 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_complet
1822 struct sci_base_object *object) 1822 struct sci_base_object *object)
1823{ 1823{
1824 struct scic_sds_request *this_request = (struct scic_sds_request *)object; 1824 struct scic_sds_request *this_request = (struct scic_sds_request *)object;
1825 sci_base_controller_request_handler_t continue_io; 1825 scic_sds_controller_request_handler_t continue_io;
1826 struct scu_task_context *task_context; 1826 struct scu_task_context *task_context;
1827 struct sata_fis_reg_h2d *h2d_fis; 1827 struct sata_fis_reg_h2d *h2d_fis;
1828 struct scic_sds_controller *scic; 1828 struct scic_sds_controller *scic;
@@ -1839,10 +1839,10 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_complet
1839 task_context->control_frame = 0; 1839 task_context->control_frame = 0;
1840 1840
1841 scic = this_request->owning_controller; 1841 scic = this_request->owning_controller;
1842 state = scic->parent.state_machine.current_state_id; 1842 state = scic->state_machine.current_state_id;
1843 continue_io = scic_sds_controller_state_handler_table[state].base.continue_io; 1843 continue_io = scic_sds_controller_state_handler_table[state].continue_io;
1844 1844
1845 status = continue_io(&scic->parent, &this_request->target_device->parent, 1845 status = continue_io(scic, &this_request->target_device->parent,
1846 &this_request->parent); 1846 &this_request->parent);
1847 1847
1848 if (status == SCI_SUCCESS) { 1848 if (status == SCI_SUCCESS) {
diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index 66449593aa8c..adfc2452d216 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -62,6 +62,7 @@
62#include "request.h" 62#include "request.h"
63#include "host.h" 63#include "host.h"
64#include "probe_roms.h" 64#include "probe_roms.h"
65#include "core/scic_sds_controller.h"
65 66
66irqreturn_t isci_msix_isr(int vec, void *data) 67irqreturn_t isci_msix_isr(int vec, void *data)
67{ 68{
@@ -231,9 +232,8 @@ static int isci_host_mdl_allocate_coherent(
231 struct coherent_memory_info *mdl_struct; 232 struct coherent_memory_info *mdl_struct;
232 u32 size = 0; 233 u32 size = 0;
233 234
234 struct sci_base_memory_descriptor_list *mdl_handle 235 struct sci_base_memory_descriptor_list *mdl_handle =
235 = sci_controller_get_memory_descriptor_list_handle( 236 &isci_host->core_controller->mdl;
236 isci_host->core_controller);
237 237
238 sci_mdl_first_entry(mdl_handle); 238 sci_mdl_first_entry(mdl_handle);
239 239
diff --git a/drivers/scsi/isci/isci.h b/drivers/scsi/isci/isci.h
index 87643857bade..ac292d2a75de 100644
--- a/drivers/scsi/isci/isci.h
+++ b/drivers/scsi/isci/isci.h
@@ -65,7 +65,7 @@
65#include <scsi/libsas.h> 65#include <scsi/libsas.h>
66#include <scsi/scsi.h> 66#include <scsi/scsi.h>
67 67
68#include "sci_base_controller.h" 68#include "core/sci_object.h"
69#include "scic_controller.h" 69#include "scic_controller.h"
70#include "host.h" 70#include "host.h"
71#include "timers.h" 71#include "timers.h"
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-25 00:02:31 -0400