blob: 82507bd228d44919ae91006cfb98393806417fbc [file] [log] [blame]
Dan Williams6f231dd2011-07-02 22:56:22 -07001/*
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
Dan Williamscc9203b2011-05-08 17:34:44 -070056#include "host.h"
Dan Williams3bff9d52011-05-08 22:15:10 -070057#include "state_machine.h"
Dan Williams88f3b622011-04-22 19:18:03 -070058#include "remote_device.h"
59#include "remote_node_context.h"
Dan Williams6f231dd2011-07-02 22:56:22 -070060#include "scu_event_codes.h"
61#include "scu_task_context.h"
62
Dan Williams6f231dd2011-07-02 22:56:22 -070063
64/**
65 *
Dave Jiange2023b82011-04-21 05:34:49 +000066 * @sci_rnc: The RNC for which the is posted request is being made.
Dan Williams6f231dd2011-07-02 22:56:22 -070067 *
68 * This method will return true if the RNC is not in the initial state. In all
69 * other states the RNC is considered active and this will return true. The
70 * destroy request of the state machine drives the RNC back to the initial
71 * state. If the state machine changes then this routine will also have to be
72 * changed. bool true if the state machine is not in the initial state false if
73 * the state machine is in the initial state
74 */
75
76/**
77 *
Dave Jiange2023b82011-04-21 05:34:49 +000078 * @sci_rnc: The state of the remote node context object to check.
Dan Williams6f231dd2011-07-02 22:56:22 -070079 *
80 * This method will return true if the remote node context is in a READY state
81 * otherwise it will return false bool true if the remote node context is in
82 * the ready state. false if the remote node context is not in the ready state.
83 */
84bool scic_sds_remote_node_context_is_ready(
Dave Jiange2023b82011-04-21 05:34:49 +000085 struct scic_sds_remote_node_context *sci_rnc)
Dan Williams6f231dd2011-07-02 22:56:22 -070086{
Dave Jiange2023b82011-04-21 05:34:49 +000087 u32 current_state = sci_base_state_machine_get_state(&sci_rnc->state_machine);
Dan Williams6f231dd2011-07-02 22:56:22 -070088
89 if (current_state == SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
90 return true;
91 }
92
93 return false;
94}
95
96/**
97 *
Dave Jiange2023b82011-04-21 05:34:49 +000098 * @sci_dev: The remote device to use to construct the RNC buffer.
Dan Williams6f231dd2011-07-02 22:56:22 -070099 * @rnc: The buffer into which the remote device data will be copied.
100 *
101 * This method will construct the RNC buffer for this remote device object. none
102 */
Dan Williams35173d52011-03-26 16:43:01 -0700103static void scic_sds_remote_node_context_construct_buffer(
Dave Jiange2023b82011-04-21 05:34:49 +0000104 struct scic_sds_remote_node_context *sci_rnc)
Dan Williams6f231dd2011-07-02 22:56:22 -0700105{
Dan Williams96143952011-04-19 18:35:58 -0700106 struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc);
Dan Williamsa1a113b2011-04-21 18:44:45 -0700107 struct domain_device *dev = sci_dev_to_domain(sci_dev);
Dan Williams1f4fa1f2011-04-26 11:44:06 -0700108 int rni = sci_rnc->remote_node_index;
Dan Williamsa1a113b2011-04-21 18:44:45 -0700109 union scu_remote_node_context *rnc;
Dave Jiange2023b82011-04-21 05:34:49 +0000110 struct scic_sds_controller *scic;
Dan Williamsa3d568f02011-04-26 09:41:52 -0700111 __le64 sas_addr;
Dan Williams6f231dd2011-07-02 22:56:22 -0700112
Dan Williams96143952011-04-19 18:35:58 -0700113 scic = scic_sds_remote_device_get_controller(sci_dev);
Dan Williams1f4fa1f2011-04-26 11:44:06 -0700114 rnc = scic_sds_controller_get_remote_node_context_buffer(scic, rni);
Dan Williams6f231dd2011-07-02 22:56:22 -0700115
Dan Williams96143952011-04-19 18:35:58 -0700116 memset(rnc, 0, sizeof(union scu_remote_node_context)
117 * scic_sds_remote_device_node_count(sci_dev));
Dan Williams6f231dd2011-07-02 22:56:22 -0700118
Dan Williams1f4fa1f2011-04-26 11:44:06 -0700119 rnc->ssp.remote_node_index = rni;
Dan Williams96143952011-04-19 18:35:58 -0700120 rnc->ssp.remote_node_port_width = sci_dev->device_port_width;
Dan Williams1f4fa1f2011-04-26 11:44:06 -0700121 rnc->ssp.logical_port_index = sci_dev->owning_port->physical_port_index;
Dan Williams6f231dd2011-07-02 22:56:22 -0700122
Dan Williamsa3d568f02011-04-26 09:41:52 -0700123 /* sas address is __be64, context ram format is __le64 */
124 sas_addr = cpu_to_le64(SAS_ADDR(dev->sas_addr));
125 rnc->ssp.remote_sas_address_hi = upper_32_bits(sas_addr);
126 rnc->ssp.remote_sas_address_lo = lower_32_bits(sas_addr);
Dan Williams6f231dd2011-07-02 22:56:22 -0700127
128 rnc->ssp.nexus_loss_timer_enable = true;
129 rnc->ssp.check_bit = false;
130 rnc->ssp.is_valid = false;
131 rnc->ssp.is_remote_node_context = true;
132 rnc->ssp.function_number = 0;
133
134 rnc->ssp.arbitration_wait_time = 0;
135
Dan Williamsa1a113b2011-04-21 18:44:45 -0700136 if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
Dan Williams6f231dd2011-07-02 22:56:22 -0700137 rnc->ssp.connection_occupancy_timeout =
Dave Jiange2023b82011-04-21 05:34:49 +0000138 scic->user_parameters.sds1.stp_max_occupancy_timeout;
Dan Williams6f231dd2011-07-02 22:56:22 -0700139 rnc->ssp.connection_inactivity_timeout =
Dave Jiange2023b82011-04-21 05:34:49 +0000140 scic->user_parameters.sds1.stp_inactivity_timeout;
Dan Williams6f231dd2011-07-02 22:56:22 -0700141 } else {
142 rnc->ssp.connection_occupancy_timeout =
Dave Jiange2023b82011-04-21 05:34:49 +0000143 scic->user_parameters.sds1.ssp_max_occupancy_timeout;
Dan Williams6f231dd2011-07-02 22:56:22 -0700144 rnc->ssp.connection_inactivity_timeout =
Dave Jiange2023b82011-04-21 05:34:49 +0000145 scic->user_parameters.sds1.ssp_inactivity_timeout;
Dan Williams6f231dd2011-07-02 22:56:22 -0700146 }
147
148 rnc->ssp.initial_arbitration_wait_time = 0;
149
150 /* Open Address Frame Parameters */
Dan Williams96143952011-04-19 18:35:58 -0700151 rnc->ssp.oaf_connection_rate = sci_dev->connection_rate;
Dan Williams6f231dd2011-07-02 22:56:22 -0700152 rnc->ssp.oaf_features = 0;
153 rnc->ssp.oaf_source_zone_group = 0;
154 rnc->ssp.oaf_more_compatibility_features = 0;
155}
156
157/**
158 *
Dave Jiange2023b82011-04-21 05:34:49 +0000159 * @sci_rnc:
160 * @callback:
Dan Williams6f231dd2011-07-02 22:56:22 -0700161 * @callback_parameter:
162 *
163 * This method will setup the remote node context object so it will transition
164 * to its ready state. If the remote node context is already setup to
165 * transition to its final state then this function does nothing. none
166 */
167static void scic_sds_remote_node_context_setup_to_resume(
Dave Jiange2023b82011-04-21 05:34:49 +0000168 struct scic_sds_remote_node_context *sci_rnc,
169 scics_sds_remote_node_context_callback callback,
Dan Williams6f231dd2011-07-02 22:56:22 -0700170 void *callback_parameter)
171{
Dave Jiange2023b82011-04-21 05:34:49 +0000172 if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
173 sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
174 sci_rnc->user_callback = callback;
175 sci_rnc->user_cookie = callback_parameter;
Dan Williams6f231dd2011-07-02 22:56:22 -0700176 }
177}
178
Dan Williams6f231dd2011-07-02 22:56:22 -0700179static void scic_sds_remote_node_context_setup_to_destory(
Dave Jiange2023b82011-04-21 05:34:49 +0000180 struct scic_sds_remote_node_context *sci_rnc,
181 scics_sds_remote_node_context_callback callback,
Dan Williams6f231dd2011-07-02 22:56:22 -0700182 void *callback_parameter)
183{
Dave Jiange2023b82011-04-21 05:34:49 +0000184 sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
185 sci_rnc->user_callback = callback;
186 sci_rnc->user_cookie = callback_parameter;
Dan Williams6f231dd2011-07-02 22:56:22 -0700187}
188
Dan Williams6f231dd2011-07-02 22:56:22 -0700189/**
190 *
191 *
192 * This method just calls the user callback function and then resets the
193 * callback.
194 */
195static void scic_sds_remote_node_context_notify_user(
196 struct scic_sds_remote_node_context *rnc)
197{
198 if (rnc->user_callback != NULL) {
199 (*rnc->user_callback)(rnc->user_cookie);
200
201 rnc->user_callback = NULL;
202 rnc->user_cookie = NULL;
203 }
204}
205
Dan Williamsed3efb72011-05-12 08:50:23 -0700206static void scic_sds_remote_node_context_continue_state_transitions(struct scic_sds_remote_node_context *rnc)
Dan Williams6f231dd2011-07-02 22:56:22 -0700207{
Dan Williamsed3efb72011-05-12 08:50:23 -0700208 if (rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
209 scic_sds_remote_node_context_resume(rnc, rnc->user_callback,
210 rnc->user_cookie);
Dan Williams6f231dd2011-07-02 22:56:22 -0700211}
212
213/**
214 *
Dave Jiange2023b82011-04-21 05:34:49 +0000215 * @sci_rnc: The remote node context object that is to be validated.
Dan Williams6f231dd2011-07-02 22:56:22 -0700216 *
217 * This method will mark the rnc buffer as being valid and post the request to
218 * the hardware. none
219 */
220static void scic_sds_remote_node_context_validate_context_buffer(
Dave Jiange2023b82011-04-21 05:34:49 +0000221 struct scic_sds_remote_node_context *sci_rnc)
Dan Williams6f231dd2011-07-02 22:56:22 -0700222{
Dan Williams96143952011-04-19 18:35:58 -0700223 struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc);
Dan Williamsa1a113b2011-04-21 18:44:45 -0700224 struct domain_device *dev = sci_dev_to_domain(sci_dev);
Dan Williams6f231dd2011-07-02 22:56:22 -0700225 union scu_remote_node_context *rnc_buffer;
226
227 rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
Dan Williams96143952011-04-19 18:35:58 -0700228 scic_sds_remote_device_get_controller(sci_dev),
Dave Jiange2023b82011-04-21 05:34:49 +0000229 sci_rnc->remote_node_index
Dan Williams6f231dd2011-07-02 22:56:22 -0700230 );
231
232 rnc_buffer->ssp.is_valid = true;
233
Dan Williams96143952011-04-19 18:35:58 -0700234 if (!sci_dev->is_direct_attached &&
Dan Williamsa1a113b2011-04-21 18:44:45 -0700235 (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))) {
Dan Williams96143952011-04-19 18:35:58 -0700236 scic_sds_remote_device_post_request(sci_dev,
237 SCU_CONTEXT_COMMAND_POST_RNC_96);
Dan Williams6f231dd2011-07-02 22:56:22 -0700238 } else {
Dan Williams96143952011-04-19 18:35:58 -0700239 scic_sds_remote_device_post_request(sci_dev, SCU_CONTEXT_COMMAND_POST_RNC_32);
Dan Williams6f231dd2011-07-02 22:56:22 -0700240
Dan Williams96143952011-04-19 18:35:58 -0700241 if (sci_dev->is_direct_attached) {
242 scic_sds_port_setup_transports(sci_dev->owning_port,
243 sci_rnc->remote_node_index);
Dan Williams6f231dd2011-07-02 22:56:22 -0700244 }
245 }
246}
247
248/**
249 *
Dave Jiange2023b82011-04-21 05:34:49 +0000250 * @sci_rnc: The remote node context object that is to be invalidated.
Dan Williams6f231dd2011-07-02 22:56:22 -0700251 *
252 * This method will update the RNC buffer and post the invalidate request. none
253 */
254static void scic_sds_remote_node_context_invalidate_context_buffer(
Dave Jiange2023b82011-04-21 05:34:49 +0000255 struct scic_sds_remote_node_context *sci_rnc)
Dan Williams6f231dd2011-07-02 22:56:22 -0700256{
257 union scu_remote_node_context *rnc_buffer;
258
259 rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
Dan Williams96143952011-04-19 18:35:58 -0700260 scic_sds_remote_device_get_controller(rnc_to_dev(sci_rnc)),
261 sci_rnc->remote_node_index);
Dan Williams6f231dd2011-07-02 22:56:22 -0700262
263 rnc_buffer->ssp.is_valid = false;
264
Dan Williams96143952011-04-19 18:35:58 -0700265 scic_sds_remote_device_post_request(rnc_to_dev(sci_rnc),
266 SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE);
Dan Williams6f231dd2011-07-02 22:56:22 -0700267}
268
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000269static void scic_sds_remote_node_context_initial_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700270{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000271 struct scic_sds_remote_node_context *rnc = object;
Dan Williamsf34d9e52011-05-12 09:27:52 -0700272 struct sci_base_state_machine *sm = &rnc->state_machine;
Dan Williams6f231dd2011-07-02 22:56:22 -0700273
Dan Williamsf34d9e52011-05-12 09:27:52 -0700274 /* Check to see if we have gotten back to the initial state because
275 * someone requested to destroy the remote node context object.
276 */
277 if (sm->previous_state_id == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE) {
Dan Williams6f231dd2011-07-02 22:56:22 -0700278 rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
Dan Williams6f231dd2011-07-02 22:56:22 -0700279 scic_sds_remote_node_context_notify_user(rnc);
280 }
281}
282
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000283static void scic_sds_remote_node_context_posting_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700284{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000285 struct scic_sds_remote_node_context *sci_rnc = object;
Dan Williams6f231dd2011-07-02 22:56:22 -0700286
Dave Jiange2023b82011-04-21 05:34:49 +0000287 scic_sds_remote_node_context_validate_context_buffer(sci_rnc);
Dan Williams6f231dd2011-07-02 22:56:22 -0700288}
289
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000290static void scic_sds_remote_node_context_invalidating_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700291{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000292 struct scic_sds_remote_node_context *rnc = object;
Dan Williams6f231dd2011-07-02 22:56:22 -0700293
Dan Williams6f231dd2011-07-02 22:56:22 -0700294 scic_sds_remote_node_context_invalidate_context_buffer(rnc);
295}
296
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000297static void scic_sds_remote_node_context_resuming_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700298{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000299 struct scic_sds_remote_node_context *rnc = object;
Dan Williams96143952011-04-19 18:35:58 -0700300 struct scic_sds_remote_device *sci_dev;
Dan Williamsa1a113b2011-04-21 18:44:45 -0700301 struct domain_device *dev;
Dan Williams6f231dd2011-07-02 22:56:22 -0700302
Dan Williams96143952011-04-19 18:35:58 -0700303 sci_dev = rnc_to_dev(rnc);
Dan Williamsa1a113b2011-04-21 18:44:45 -0700304 dev = sci_dev_to_domain(sci_dev);
Dan Williams6f231dd2011-07-02 22:56:22 -0700305
Henryk Dembkowski24621462011-02-23 00:08:52 -0800306 /*
307 * For direct attached SATA devices we need to clear the TLCR
308 * NCQ to TCi tag mapping on the phy and in cases where we
309 * resume because of a target reset we also need to update
310 * the STPTLDARNI register with the RNi of the device
311 */
Dan Williamsa1a113b2011-04-21 18:44:45 -0700312 if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) &&
313 sci_dev->is_direct_attached)
Dan Williams96143952011-04-19 18:35:58 -0700314 scic_sds_port_setup_transports(sci_dev->owning_port,
315 rnc->remote_node_index);
Henryk Dembkowski24621462011-02-23 00:08:52 -0800316
Dan Williams96143952011-04-19 18:35:58 -0700317 scic_sds_remote_device_post_request(sci_dev, SCU_CONTEXT_COMMAND_POST_RNC_RESUME);
Dan Williams6f231dd2011-07-02 22:56:22 -0700318}
319
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000320static void scic_sds_remote_node_context_ready_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700321{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000322 struct scic_sds_remote_node_context *rnc = object;
Dan Williams6f231dd2011-07-02 22:56:22 -0700323
Dan Williams6f231dd2011-07-02 22:56:22 -0700324 rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
325
Dan Williamsf34d9e52011-05-12 09:27:52 -0700326 if (rnc->user_callback)
Dan Williams6f231dd2011-07-02 22:56:22 -0700327 scic_sds_remote_node_context_notify_user(rnc);
Dan Williams6f231dd2011-07-02 22:56:22 -0700328}
329
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000330static void scic_sds_remote_node_context_tx_suspended_state_enter(void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700331{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000332 struct scic_sds_remote_node_context *rnc = object;
Dan Williams6f231dd2011-07-02 22:56:22 -0700333
Dan Williams6f231dd2011-07-02 22:56:22 -0700334 scic_sds_remote_node_context_continue_state_transitions(rnc);
335}
336
Dan Williams6f231dd2011-07-02 22:56:22 -0700337static void scic_sds_remote_node_context_tx_rx_suspended_state_enter(
Maciej Patelczyk9a0fff72011-04-28 22:06:01 +0000338 void *object)
Dan Williams6f231dd2011-07-02 22:56:22 -0700339{
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000340 struct scic_sds_remote_node_context *rnc = object;
Dan Williams6f231dd2011-07-02 22:56:22 -0700341
Dan Williams6f231dd2011-07-02 22:56:22 -0700342 scic_sds_remote_node_context_continue_state_transitions(rnc);
343}
344
Dan Williams35173d52011-03-26 16:43:01 -0700345static const struct sci_base_state scic_sds_remote_node_context_state_table[] = {
Dan Williams6f231dd2011-07-02 22:56:22 -0700346 [SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE] = {
347 .enter_state = scic_sds_remote_node_context_initial_state_enter,
348 },
349 [SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE] = {
350 .enter_state = scic_sds_remote_node_context_posting_state_enter,
351 },
352 [SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE] = {
353 .enter_state = scic_sds_remote_node_context_invalidating_state_enter,
354 },
355 [SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE] = {
356 .enter_state = scic_sds_remote_node_context_resuming_state_enter,
357 },
358 [SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE] = {
359 .enter_state = scic_sds_remote_node_context_ready_state_enter,
360 },
361 [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE] = {
362 .enter_state = scic_sds_remote_node_context_tx_suspended_state_enter,
363 },
364 [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE] = {
365 .enter_state = scic_sds_remote_node_context_tx_rx_suspended_state_enter,
366 },
Dan Williamsf34d9e52011-05-12 09:27:52 -0700367 [SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE] = { },
Dan Williams6f231dd2011-07-02 22:56:22 -0700368};
369
Dan Williams96143952011-04-19 18:35:58 -0700370void scic_sds_remote_node_context_construct(struct scic_sds_remote_node_context *rnc,
371 u16 remote_node_index)
Dan Williams35173d52011-03-26 16:43:01 -0700372{
373 memset(rnc, 0, sizeof(struct scic_sds_remote_node_context));
374
375 rnc->remote_node_index = remote_node_index;
Dan Williams35173d52011-03-26 16:43:01 -0700376 rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
377
378 sci_base_state_machine_construct(
379 &rnc->state_machine,
Maciej Patelczykaf23e852011-04-28 22:06:26 +0000380 rnc,
Dan Williams35173d52011-03-26 16:43:01 -0700381 scic_sds_remote_node_context_state_table,
382 SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE
383 );
384
385 sci_base_state_machine_start(&rnc->state_machine);
386}
Dan Williams338e3862011-05-12 07:46:59 -0700387
388enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remote_node_context *sci_rnc,
389 u32 event_code)
390{
391 enum scis_sds_remote_node_context_states state;
392
393 state = sci_rnc->state_machine.current_state_id;
394 switch (state) {
395 case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
396 switch (scu_get_event_code(event_code)) {
397 case SCU_EVENT_POST_RNC_COMPLETE:
398 sci_base_state_machine_change_state(&sci_rnc->state_machine,
399 SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE);
400 break;
401 default:
402 goto out;
403 }
404 break;
405 case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
406 if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
407 if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL)
408 state = SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE;
409 else
410 state = SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE;
411 sci_base_state_machine_change_state(&sci_rnc->state_machine,
412 state);
413 } else {
414 switch (scu_get_event_type(event_code)) {
415 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
416 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
417 /* We really dont care if the hardware is going to suspend
418 * the device since it's being invalidated anyway */
419 dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
420 "%s: SCIC Remote Node Context 0x%p was "
421 "suspeneded by hardware while being "
422 "invalidated.\n", __func__, sci_rnc);
423 break;
424 default:
425 goto out;
426 }
427 }
428 break;
429 case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
430 if (scu_get_event_code(event_code) == SCU_EVENT_POST_RCN_RELEASE) {
431 sci_base_state_machine_change_state(&sci_rnc->state_machine,
432 SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE);
433 } else {
434 switch (scu_get_event_type(event_code)) {
435 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
436 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
437 /* We really dont care if the hardware is going to suspend
438 * the device since it's being resumed anyway */
439 dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
440 "%s: SCIC Remote Node Context 0x%p was "
441 "suspeneded by hardware while being resumed.\n",
442 __func__, sci_rnc);
443 break;
444 default:
445 goto out;
446 }
447 }
448 break;
449 case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
450 switch (scu_get_event_type(event_code)) {
451 case SCU_EVENT_TL_RNC_SUSPEND_TX:
452 sci_base_state_machine_change_state(&sci_rnc->state_machine,
453 SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE);
454 sci_rnc->suspension_code = scu_get_event_specifier(event_code);
455 break;
456 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
457 sci_base_state_machine_change_state(&sci_rnc->state_machine,
458 SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE);
459 sci_rnc->suspension_code = scu_get_event_specifier(event_code);
460 break;
461 default:
462 goto out;
463 }
464 break;
465 case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
466 switch (scu_get_event_type(event_code)) {
467 case SCU_EVENT_TL_RNC_SUSPEND_TX:
468 sci_base_state_machine_change_state(&sci_rnc->state_machine,
469 SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE);
470 sci_rnc->suspension_code = scu_get_event_specifier(event_code);
471 break;
472 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
473 sci_base_state_machine_change_state(&sci_rnc->state_machine,
474 SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE);
475 sci_rnc->suspension_code = scu_get_event_specifier(event_code);
476 break;
477 default:
478 goto out;
479 }
480 break;
481 default:
482 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
483 "%s: invalid state %d\n", __func__, state);
484 return SCI_FAILURE_INVALID_STATE;
485 }
486 return SCI_SUCCESS;
487
488 out:
489 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
490 "%s: code: %#x state: %d\n", __func__, event_code, state);
491 return SCI_FAILURE;
492
493}
Dan Williamsc845ae92011-05-12 08:26:56 -0700494
495enum sci_status scic_sds_remote_node_context_destruct(struct scic_sds_remote_node_context *sci_rnc,
496 scics_sds_remote_node_context_callback cb_fn,
497 void *cb_p)
498{
499 enum scis_sds_remote_node_context_states state;
500
501 state = sci_rnc->state_machine.current_state_id;
502 switch (state) {
503 case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
504 scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
505 return SCI_SUCCESS;
506 case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
507 case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
508 case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
509 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE:
510 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
511 case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
512 scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
513 sci_base_state_machine_change_state(&sci_rnc->state_machine,
514 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE);
515 return SCI_SUCCESS;
516 case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE:
517 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
518 "%s: invalid state %d\n", __func__, state);
519 /* We have decided that the destruct request on the remote node context
520 * can not fail since it is either in the initial/destroyed state or is
521 * can be destroyed.
522 */
523 return SCI_SUCCESS;
524 default:
525 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
526 "%s: invalid state %d\n", __func__, state);
527 return SCI_FAILURE_INVALID_STATE;
528 }
529}
Dan Williamsed3efb72011-05-12 08:50:23 -0700530
531enum sci_status scic_sds_remote_node_context_suspend(struct scic_sds_remote_node_context *sci_rnc,
532 u32 suspend_type,
533 scics_sds_remote_node_context_callback cb_fn,
534 void *cb_p)
535{
536 enum scis_sds_remote_node_context_states state;
537
538 state = sci_rnc->state_machine.current_state_id;
539 if (state != SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
540 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
541 "%s: invalid state %d\n", __func__, state);
542 return SCI_FAILURE_INVALID_STATE;
543 }
544
545 sci_rnc->user_callback = cb_fn;
546 sci_rnc->user_cookie = cb_p;
547 sci_rnc->suspension_code = suspend_type;
548
549 if (suspend_type == SCI_SOFTWARE_SUSPENSION) {
550 scic_sds_remote_device_post_request(rnc_to_dev(sci_rnc),
551 SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX);
552 }
553
554 sci_base_state_machine_change_state(&sci_rnc->state_machine,
555 SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE);
556 return SCI_SUCCESS;
557}
558
559enum sci_status scic_sds_remote_node_context_resume(struct scic_sds_remote_node_context *sci_rnc,
560 scics_sds_remote_node_context_callback cb_fn,
561 void *cb_p)
562{
563 enum scis_sds_remote_node_context_states state;
564
565 state = sci_rnc->state_machine.current_state_id;
566 switch (state) {
567 case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE:
568 if (sci_rnc->remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
569 return SCI_FAILURE_INVALID_STATE;
570
571 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
572 scic_sds_remote_node_context_construct_buffer(sci_rnc);
573 sci_base_state_machine_change_state(&sci_rnc->state_machine,
574 SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE);
575 return SCI_SUCCESS;
576 case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
577 case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
578 case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
579 if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
580 return SCI_FAILURE_INVALID_STATE;
581
582 sci_rnc->user_callback = cb_fn;
583 sci_rnc->user_cookie = cb_p;
584 return SCI_SUCCESS;
585 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE: {
586 struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc);
587 struct domain_device *dev = sci_dev_to_domain(sci_dev);
588
589 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
590
591 /* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */
592 if (dev->dev_type == SAS_END_DEV || dev_is_expander(dev))
593 sci_base_state_machine_change_state(&sci_rnc->state_machine,
594 SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
595 else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
596 if (sci_dev->is_direct_attached) {
597 /* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */
598 sci_base_state_machine_change_state(&sci_rnc->state_machine,
599 SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
600 } else {
601 sci_base_state_machine_change_state(&sci_rnc->state_machine,
602 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE);
603 }
604 } else
605 return SCI_FAILURE;
606 return SCI_SUCCESS;
607 }
608 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
609 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
610 sci_base_state_machine_change_state(&sci_rnc->state_machine,
611 SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
612 return SCI_FAILURE_INVALID_STATE;
613 case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
614 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
615 return SCI_SUCCESS;
616 default:
617 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
618 "%s: invalid state %d\n", __func__, state);
619 return SCI_FAILURE_INVALID_STATE;
620 }
621}
Dan Williamsf34d9e52011-05-12 09:27:52 -0700622
623enum sci_status scic_sds_remote_node_context_start_io(struct scic_sds_remote_node_context *sci_rnc,
624 struct scic_sds_request *sci_req)
625{
626 enum scis_sds_remote_node_context_states state;
627
628 state = sci_rnc->state_machine.current_state_id;
629 if (state != SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
630 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
631 "%s: invalid state %d\n", __func__, state);
632 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
633 }
634 return SCI_SUCCESS;
635}
636
637enum sci_status scic_sds_remote_node_context_start_task(struct scic_sds_remote_node_context *sci_rnc,
638 struct scic_sds_request *sci_req)
639{
640 enum scis_sds_remote_node_context_states state;
641
642 state = sci_rnc->state_machine.current_state_id;
643 switch (state) {
644 case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
645 case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
646 case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
647 return SCI_SUCCESS;
648 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE:
649 case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
650 scic_sds_remote_node_context_resume(sci_rnc, NULL, NULL);
651 return SCI_SUCCESS;
652 default:
653 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
654 "%s: invalid state %d\n", __func__, state);
655 return SCI_FAILURE_INVALID_STATE;
656 }
657}