Commit | Line | Data |
---|---|---|
6f231dda DW |
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 | ||
cc9203bf | 56 | #include "host.h" |
3bff9d54 | 57 | #include "state_machine.h" |
88f3b62a DW |
58 | #include "remote_device.h" |
59 | #include "remote_node_context.h" | |
6f231dda DW |
60 | #include "scu_event_codes.h" |
61 | #include "scu_task_context.h" | |
62 | ||
6f231dda DW |
63 | |
64 | /** | |
65 | * | |
e2023b87 | 66 | * @sci_rnc: The RNC for which the is posted request is being made. |
6f231dda DW |
67 | * |
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 | * | |
e2023b87 | 78 | * @sci_rnc: The state of the remote node context object to check. |
6f231dda DW |
79 | * |
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 | */ | |
84 | bool scic_sds_remote_node_context_is_ready( | |
e2023b87 | 85 | struct scic_sds_remote_node_context *sci_rnc) |
6f231dda | 86 | { |
e2023b87 | 87 | u32 current_state = sci_base_state_machine_get_state(&sci_rnc->state_machine); |
6f231dda DW |
88 | |
89 | if (current_state == SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) { | |
90 | return true; | |
91 | } | |
92 | ||
93 | return false; | |
94 | } | |
95 | ||
96 | /** | |
97 | * | |
e2023b87 | 98 | * @sci_dev: The remote device to use to construct the RNC buffer. |
6f231dda DW |
99 | * @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 | */ | |
35173d57 | 103 | static void scic_sds_remote_node_context_construct_buffer( |
e2023b87 | 104 | struct scic_sds_remote_node_context *sci_rnc) |
6f231dda | 105 | { |
9614395e | 106 | struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc); |
a1a113b0 | 107 | struct domain_device *dev = sci_dev_to_domain(sci_dev); |
1f4fa1f9 | 108 | int rni = sci_rnc->remote_node_index; |
a1a113b0 | 109 | union scu_remote_node_context *rnc; |
e2023b87 | 110 | struct scic_sds_controller *scic; |
a3d568f0 | 111 | __le64 sas_addr; |
6f231dda | 112 | |
9614395e | 113 | scic = scic_sds_remote_device_get_controller(sci_dev); |
1f4fa1f9 | 114 | rnc = scic_sds_controller_get_remote_node_context_buffer(scic, rni); |
6f231dda | 115 | |
9614395e DW |
116 | memset(rnc, 0, sizeof(union scu_remote_node_context) |
117 | * scic_sds_remote_device_node_count(sci_dev)); | |
6f231dda | 118 | |
1f4fa1f9 | 119 | rnc->ssp.remote_node_index = rni; |
9614395e | 120 | rnc->ssp.remote_node_port_width = sci_dev->device_port_width; |
1f4fa1f9 | 121 | rnc->ssp.logical_port_index = sci_dev->owning_port->physical_port_index; |
6f231dda | 122 | |
a3d568f0 DW |
123 | /* 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); | |
6f231dda DW |
127 | |
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 | ||
a1a113b0 | 136 | if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) { |
6f231dda | 137 | rnc->ssp.connection_occupancy_timeout = |
e2023b87 | 138 | scic->user_parameters.sds1.stp_max_occupancy_timeout; |
6f231dda | 139 | rnc->ssp.connection_inactivity_timeout = |
e2023b87 | 140 | scic->user_parameters.sds1.stp_inactivity_timeout; |
6f231dda DW |
141 | } else { |
142 | rnc->ssp.connection_occupancy_timeout = | |
e2023b87 | 143 | scic->user_parameters.sds1.ssp_max_occupancy_timeout; |
6f231dda | 144 | rnc->ssp.connection_inactivity_timeout = |
e2023b87 | 145 | scic->user_parameters.sds1.ssp_inactivity_timeout; |
6f231dda DW |
146 | } |
147 | ||
148 | rnc->ssp.initial_arbitration_wait_time = 0; | |
149 | ||
150 | /* Open Address Frame Parameters */ | |
9614395e | 151 | rnc->ssp.oaf_connection_rate = sci_dev->connection_rate; |
6f231dda DW |
152 | 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 | * | |
e2023b87 DJ |
159 | * @sci_rnc: |
160 | * @callback: | |
6f231dda DW |
161 | * @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 | */ | |
167 | static void scic_sds_remote_node_context_setup_to_resume( | |
e2023b87 DJ |
168 | struct scic_sds_remote_node_context *sci_rnc, |
169 | scics_sds_remote_node_context_callback callback, | |
6f231dda DW |
170 | void *callback_parameter) |
171 | { | |
e2023b87 DJ |
172 | 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; | |
6f231dda DW |
176 | } |
177 | } | |
178 | ||
179 | /** | |
180 | * | |
e2023b87 DJ |
181 | * @sci_rnc: |
182 | * @callback: | |
6f231dda DW |
183 | * @callback_parameter: |
184 | * | |
185 | * This method will setup the remote node context object so it will transistion | |
186 | * to its final state. none | |
187 | */ | |
188 | static void scic_sds_remote_node_context_setup_to_destory( | |
e2023b87 DJ |
189 | struct scic_sds_remote_node_context *sci_rnc, |
190 | scics_sds_remote_node_context_callback callback, | |
6f231dda DW |
191 | void *callback_parameter) |
192 | { | |
e2023b87 DJ |
193 | sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL; |
194 | sci_rnc->user_callback = callback; | |
195 | sci_rnc->user_cookie = callback_parameter; | |
6f231dda DW |
196 | } |
197 | ||
6f231dda | 198 | static enum sci_status scic_sds_remote_node_context_default_start_io_handler( |
e2023b87 DJ |
199 | struct scic_sds_remote_node_context *sci_rnc, |
200 | struct scic_sds_request *sci_req) | |
6f231dda | 201 | { |
9614395e | 202 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), |
6f231dda DW |
203 | "%s: SCIC Remote Node Context 0x%p requested to start io " |
204 | "0x%p while in wrong state %d\n", | |
205 | __func__, | |
e2023b87 DJ |
206 | sci_rnc, |
207 | sci_req, | |
208 | sci_base_state_machine_get_state(&sci_rnc->state_machine)); | |
6f231dda DW |
209 | |
210 | return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED; | |
211 | } | |
212 | ||
213 | static enum sci_status scic_sds_remote_node_context_default_start_task_handler( | |
e2023b87 DJ |
214 | struct scic_sds_remote_node_context *sci_rnc, |
215 | struct scic_sds_request *sci_req) | |
6f231dda | 216 | { |
9614395e | 217 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), |
6f231dda DW |
218 | "%s: SCIC Remote Node Context 0x%p requested to start " |
219 | "task 0x%p while in wrong state %d\n", | |
220 | __func__, | |
e2023b87 DJ |
221 | sci_rnc, |
222 | sci_req, | |
223 | sci_base_state_machine_get_state(&sci_rnc->state_machine)); | |
6f231dda DW |
224 | |
225 | return SCI_FAILURE; | |
226 | } | |
227 | ||
6f231dda DW |
228 | /** |
229 | * | |
e2023b87 DJ |
230 | * @sci_rnc: The rnc for which the task request is targeted. |
231 | * @sci_req: The request which is going to be started. | |
6f231dda DW |
232 | * |
233 | * This method determines if the task request can be started by the SCU | |
234 | * hardware. When the RNC is in the ready state any task can be started. | |
235 | * enum sci_status SCI_SUCCESS | |
236 | */ | |
237 | static enum sci_status scic_sds_remote_node_context_success_start_task_handler( | |
e2023b87 DJ |
238 | struct scic_sds_remote_node_context *sci_rnc, |
239 | struct scic_sds_request *sci_req) | |
6f231dda DW |
240 | { |
241 | return SCI_SUCCESS; | |
242 | } | |
243 | ||
6f231dda DW |
244 | /** |
245 | * | |
e2023b87 DJ |
246 | * @sci_rnc: The rnc for which the io request is targeted. |
247 | * @sci_req: The request which is going to be started. | |
6f231dda DW |
248 | * |
249 | * This method determines if the io request can be started by the SCU hardware. | |
250 | * When the RNC is in the ready state any io request can be started. enum sci_status | |
251 | * SCI_SUCCESS | |
252 | */ | |
253 | static enum sci_status scic_sds_remote_node_context_ready_state_start_io_handler( | |
e2023b87 DJ |
254 | struct scic_sds_remote_node_context *sci_rnc, |
255 | struct scic_sds_request *sci_req) | |
6f231dda DW |
256 | { |
257 | return SCI_SUCCESS; | |
258 | } | |
259 | ||
6f231dda DW |
260 | /** |
261 | * | |
e2023b87 DJ |
262 | * @sci_rnc: The remote node context which is to receive the task request. |
263 | * @sci_req: The task request to be transmitted to to the remote target | |
6f231dda DW |
264 | * device. |
265 | * | |
266 | * This method will report a success or failure attempt to start a new task | |
267 | * request to the hardware. Since all task requests are sent on the high | |
268 | * priority queue they can be sent when the RCN is in a TX suspend state. | |
269 | * enum sci_status SCI_SUCCESS | |
270 | */ | |
271 | static enum sci_status scic_sds_remote_node_context_suspended_start_task_handler( | |
e2023b87 DJ |
272 | struct scic_sds_remote_node_context *sci_rnc, |
273 | struct scic_sds_request *sci_req) | |
6f231dda | 274 | { |
e2023b87 | 275 | scic_sds_remote_node_context_resume(sci_rnc, NULL, NULL); |
6f231dda DW |
276 | |
277 | return SCI_SUCCESS; | |
278 | } | |
279 | ||
6f231dda DW |
280 | /** |
281 | * | |
e2023b87 DJ |
282 | * @sci_rnc: The remote node context which is to receive the task request. |
283 | * @sci_req: The task request to be transmitted to to the remote target | |
6f231dda DW |
284 | * device. |
285 | * | |
286 | * This method will report a success or failure attempt to start a new task | |
287 | * request to the hardware. Since all task requests are sent on the high | |
288 | * priority queue they can be sent when the RCN is in a TX suspend state. | |
289 | * enum sci_status SCI_SUCCESS | |
290 | */ | |
291 | static enum sci_status scic_sds_remote_node_context_await_suspension_state_start_task_handler( | |
e2023b87 DJ |
292 | struct scic_sds_remote_node_context *sci_rnc, |
293 | struct scic_sds_request *sci_req) | |
6f231dda DW |
294 | { |
295 | return SCI_SUCCESS; | |
296 | } | |
297 | ||
338e386d | 298 | static struct scic_sds_remote_node_context_handlers scic_sds_remote_node_context_state_handler_table[] = { |
a98a7426 | 299 | [SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE] = { |
a98a7426 JD |
300 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
301 | .start_task_handler = scic_sds_remote_node_context_default_start_task_handler, | |
6f231dda | 302 | }, |
a98a7426 | 303 | [SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE] = { |
a98a7426 JD |
304 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
305 | .start_task_handler = scic_sds_remote_node_context_default_start_task_handler, | |
6f231dda | 306 | }, |
a98a7426 | 307 | [SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE] = { |
a98a7426 JD |
308 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
309 | .start_task_handler = scic_sds_remote_node_context_default_start_task_handler, | |
6f231dda | 310 | }, |
a98a7426 | 311 | [SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE] = { |
a98a7426 JD |
312 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
313 | .start_task_handler = scic_sds_remote_node_context_success_start_task_handler, | |
6f231dda | 314 | }, |
a98a7426 | 315 | [SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE] = { |
a98a7426 JD |
316 | .start_io_handler = scic_sds_remote_node_context_ready_state_start_io_handler, |
317 | .start_task_handler = scic_sds_remote_node_context_success_start_task_handler, | |
6f231dda | 318 | }, |
a98a7426 | 319 | [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE] = { |
a98a7426 JD |
320 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
321 | .start_task_handler = scic_sds_remote_node_context_suspended_start_task_handler, | |
6f231dda | 322 | }, |
a98a7426 | 323 | [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE] = { |
a98a7426 JD |
324 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
325 | .start_task_handler = scic_sds_remote_node_context_suspended_start_task_handler, | |
6f231dda | 326 | }, |
a98a7426 | 327 | [SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE] = { |
a98a7426 JD |
328 | .start_io_handler = scic_sds_remote_node_context_default_start_io_handler, |
329 | .start_task_handler = scic_sds_remote_node_context_await_suspension_state_start_task_handler, | |
6f231dda DW |
330 | } |
331 | }; | |
332 | ||
333 | /* | |
334 | * ***************************************************************************** | |
335 | * * REMOTE NODE CONTEXT PRIVATE METHODS | |
336 | * ***************************************************************************** */ | |
337 | ||
338 | /** | |
339 | * | |
340 | * | |
341 | * This method just calls the user callback function and then resets the | |
342 | * callback. | |
343 | */ | |
344 | static void scic_sds_remote_node_context_notify_user( | |
345 | struct scic_sds_remote_node_context *rnc) | |
346 | { | |
347 | if (rnc->user_callback != NULL) { | |
348 | (*rnc->user_callback)(rnc->user_cookie); | |
349 | ||
350 | rnc->user_callback = NULL; | |
351 | rnc->user_cookie = NULL; | |
352 | } | |
353 | } | |
354 | ||
ed3efb77 | 355 | static void scic_sds_remote_node_context_continue_state_transitions(struct scic_sds_remote_node_context *rnc) |
6f231dda | 356 | { |
ed3efb77 DW |
357 | if (rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) |
358 | scic_sds_remote_node_context_resume(rnc, rnc->user_callback, | |
359 | rnc->user_cookie); | |
6f231dda DW |
360 | } |
361 | ||
362 | /** | |
363 | * | |
e2023b87 | 364 | * @sci_rnc: The remote node context object that is to be validated. |
6f231dda DW |
365 | * |
366 | * This method will mark the rnc buffer as being valid and post the request to | |
367 | * the hardware. none | |
368 | */ | |
369 | static void scic_sds_remote_node_context_validate_context_buffer( | |
e2023b87 | 370 | struct scic_sds_remote_node_context *sci_rnc) |
6f231dda | 371 | { |
9614395e | 372 | struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc); |
a1a113b0 | 373 | struct domain_device *dev = sci_dev_to_domain(sci_dev); |
6f231dda DW |
374 | union scu_remote_node_context *rnc_buffer; |
375 | ||
376 | rnc_buffer = scic_sds_controller_get_remote_node_context_buffer( | |
9614395e | 377 | scic_sds_remote_device_get_controller(sci_dev), |
e2023b87 | 378 | sci_rnc->remote_node_index |
6f231dda DW |
379 | ); |
380 | ||
381 | rnc_buffer->ssp.is_valid = true; | |
382 | ||
9614395e | 383 | if (!sci_dev->is_direct_attached && |
a1a113b0 | 384 | (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))) { |
9614395e DW |
385 | scic_sds_remote_device_post_request(sci_dev, |
386 | SCU_CONTEXT_COMMAND_POST_RNC_96); | |
6f231dda | 387 | } else { |
9614395e | 388 | scic_sds_remote_device_post_request(sci_dev, SCU_CONTEXT_COMMAND_POST_RNC_32); |
6f231dda | 389 | |
9614395e DW |
390 | if (sci_dev->is_direct_attached) { |
391 | scic_sds_port_setup_transports(sci_dev->owning_port, | |
392 | sci_rnc->remote_node_index); | |
6f231dda DW |
393 | } |
394 | } | |
395 | } | |
396 | ||
397 | /** | |
398 | * | |
e2023b87 | 399 | * @sci_rnc: The remote node context object that is to be invalidated. |
6f231dda DW |
400 | * |
401 | * This method will update the RNC buffer and post the invalidate request. none | |
402 | */ | |
403 | static void scic_sds_remote_node_context_invalidate_context_buffer( | |
e2023b87 | 404 | struct scic_sds_remote_node_context *sci_rnc) |
6f231dda DW |
405 | { |
406 | union scu_remote_node_context *rnc_buffer; | |
407 | ||
408 | rnc_buffer = scic_sds_controller_get_remote_node_context_buffer( | |
9614395e DW |
409 | scic_sds_remote_device_get_controller(rnc_to_dev(sci_rnc)), |
410 | sci_rnc->remote_node_index); | |
6f231dda DW |
411 | |
412 | rnc_buffer->ssp.is_valid = false; | |
413 | ||
9614395e DW |
414 | scic_sds_remote_device_post_request(rnc_to_dev(sci_rnc), |
415 | SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE); | |
6f231dda DW |
416 | } |
417 | ||
418 | /* | |
419 | * ***************************************************************************** | |
420 | * * REMOTE NODE CONTEXT STATE ENTER AND EXIT METHODS | |
421 | * ***************************************************************************** */ | |
422 | ||
423 | /** | |
424 | * | |
425 | * | |
426 | * | |
427 | */ | |
9a0fff7b | 428 | static void scic_sds_remote_node_context_initial_state_enter(void *object) |
6f231dda | 429 | { |
af23e857 | 430 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
431 | |
432 | SET_STATE_HANDLER( | |
433 | rnc, | |
434 | scic_sds_remote_node_context_state_handler_table, | |
435 | SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE | |
436 | ); | |
437 | ||
438 | /* | |
439 | * Check to see if we have gotten back to the initial state because someone | |
440 | * requested to destroy the remote node context object. */ | |
441 | if ( | |
442 | rnc->state_machine.previous_state_id | |
443 | == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE | |
444 | ) { | |
445 | rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED; | |
446 | ||
447 | scic_sds_remote_node_context_notify_user(rnc); | |
448 | } | |
449 | } | |
450 | ||
451 | /** | |
452 | * | |
453 | * | |
454 | * | |
455 | */ | |
9a0fff7b | 456 | static void scic_sds_remote_node_context_posting_state_enter(void *object) |
6f231dda | 457 | { |
af23e857 | 458 | struct scic_sds_remote_node_context *sci_rnc = object; |
6f231dda DW |
459 | |
460 | SET_STATE_HANDLER( | |
e2023b87 | 461 | sci_rnc, |
6f231dda DW |
462 | scic_sds_remote_node_context_state_handler_table, |
463 | SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE | |
464 | ); | |
465 | ||
e2023b87 | 466 | scic_sds_remote_node_context_validate_context_buffer(sci_rnc); |
6f231dda DW |
467 | } |
468 | ||
469 | /** | |
470 | * | |
471 | * | |
472 | * | |
473 | */ | |
9a0fff7b | 474 | static void scic_sds_remote_node_context_invalidating_state_enter(void *object) |
6f231dda | 475 | { |
af23e857 | 476 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
477 | |
478 | SET_STATE_HANDLER( | |
479 | rnc, | |
480 | scic_sds_remote_node_context_state_handler_table, | |
481 | SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE | |
482 | ); | |
483 | ||
484 | scic_sds_remote_node_context_invalidate_context_buffer(rnc); | |
485 | } | |
486 | ||
487 | /** | |
488 | * | |
489 | * | |
490 | * | |
491 | */ | |
9a0fff7b | 492 | static void scic_sds_remote_node_context_resuming_state_enter(void *object) |
6f231dda | 493 | { |
af23e857 | 494 | struct scic_sds_remote_node_context *rnc = object; |
9614395e | 495 | struct scic_sds_remote_device *sci_dev; |
a1a113b0 | 496 | struct domain_device *dev; |
6f231dda | 497 | |
9614395e | 498 | sci_dev = rnc_to_dev(rnc); |
a1a113b0 | 499 | dev = sci_dev_to_domain(sci_dev); |
6f231dda DW |
500 | |
501 | SET_STATE_HANDLER( | |
502 | rnc, | |
503 | scic_sds_remote_node_context_state_handler_table, | |
504 | SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE | |
505 | ); | |
506 | ||
24621466 HD |
507 | /* |
508 | * For direct attached SATA devices we need to clear the TLCR | |
509 | * NCQ to TCi tag mapping on the phy and in cases where we | |
510 | * resume because of a target reset we also need to update | |
511 | * the STPTLDARNI register with the RNi of the device | |
512 | */ | |
a1a113b0 DW |
513 | if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) && |
514 | sci_dev->is_direct_attached) | |
9614395e DW |
515 | scic_sds_port_setup_transports(sci_dev->owning_port, |
516 | rnc->remote_node_index); | |
24621466 | 517 | |
9614395e | 518 | scic_sds_remote_device_post_request(sci_dev, SCU_CONTEXT_COMMAND_POST_RNC_RESUME); |
6f231dda DW |
519 | } |
520 | ||
521 | /** | |
522 | * | |
523 | * | |
524 | * | |
525 | */ | |
9a0fff7b | 526 | static void scic_sds_remote_node_context_ready_state_enter(void *object) |
6f231dda | 527 | { |
af23e857 | 528 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
529 | |
530 | SET_STATE_HANDLER( | |
531 | rnc, | |
532 | scic_sds_remote_node_context_state_handler_table, | |
533 | SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE | |
534 | ); | |
535 | ||
536 | rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED; | |
537 | ||
538 | if (rnc->user_callback != NULL) { | |
539 | scic_sds_remote_node_context_notify_user(rnc); | |
540 | } | |
541 | } | |
542 | ||
543 | /** | |
544 | * | |
545 | * | |
546 | * | |
547 | */ | |
9a0fff7b | 548 | static void scic_sds_remote_node_context_tx_suspended_state_enter(void *object) |
6f231dda | 549 | { |
af23e857 | 550 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
551 | |
552 | SET_STATE_HANDLER( | |
553 | rnc, | |
554 | scic_sds_remote_node_context_state_handler_table, | |
555 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE | |
556 | ); | |
557 | ||
558 | scic_sds_remote_node_context_continue_state_transitions(rnc); | |
559 | } | |
560 | ||
561 | /** | |
562 | * | |
563 | * | |
564 | * | |
565 | */ | |
566 | static void scic_sds_remote_node_context_tx_rx_suspended_state_enter( | |
9a0fff7b | 567 | void *object) |
6f231dda | 568 | { |
af23e857 | 569 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
570 | |
571 | SET_STATE_HANDLER( | |
572 | rnc, | |
573 | scic_sds_remote_node_context_state_handler_table, | |
574 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE | |
575 | ); | |
576 | ||
577 | scic_sds_remote_node_context_continue_state_transitions(rnc); | |
578 | } | |
579 | ||
580 | /** | |
581 | * | |
582 | * | |
583 | * | |
584 | */ | |
585 | static void scic_sds_remote_node_context_await_suspension_state_enter( | |
9a0fff7b | 586 | void *object) |
6f231dda | 587 | { |
af23e857 | 588 | struct scic_sds_remote_node_context *rnc = object; |
6f231dda DW |
589 | |
590 | SET_STATE_HANDLER( | |
591 | rnc, | |
592 | scic_sds_remote_node_context_state_handler_table, | |
593 | SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE | |
594 | ); | |
595 | } | |
596 | ||
597 | /* --------------------------------------------------------------------------- */ | |
598 | ||
35173d57 | 599 | static const struct sci_base_state scic_sds_remote_node_context_state_table[] = { |
6f231dda DW |
600 | [SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE] = { |
601 | .enter_state = scic_sds_remote_node_context_initial_state_enter, | |
602 | }, | |
603 | [SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE] = { | |
604 | .enter_state = scic_sds_remote_node_context_posting_state_enter, | |
605 | }, | |
606 | [SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE] = { | |
607 | .enter_state = scic_sds_remote_node_context_invalidating_state_enter, | |
608 | }, | |
609 | [SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE] = { | |
610 | .enter_state = scic_sds_remote_node_context_resuming_state_enter, | |
611 | }, | |
612 | [SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE] = { | |
613 | .enter_state = scic_sds_remote_node_context_ready_state_enter, | |
614 | }, | |
615 | [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE] = { | |
616 | .enter_state = scic_sds_remote_node_context_tx_suspended_state_enter, | |
617 | }, | |
618 | [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE] = { | |
619 | .enter_state = scic_sds_remote_node_context_tx_rx_suspended_state_enter, | |
620 | }, | |
621 | [SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE] = { | |
622 | .enter_state = scic_sds_remote_node_context_await_suspension_state_enter, | |
623 | }, | |
624 | }; | |
625 | ||
9614395e DW |
626 | void scic_sds_remote_node_context_construct(struct scic_sds_remote_node_context *rnc, |
627 | u16 remote_node_index) | |
35173d57 DW |
628 | { |
629 | memset(rnc, 0, sizeof(struct scic_sds_remote_node_context)); | |
630 | ||
631 | rnc->remote_node_index = remote_node_index; | |
35173d57 DW |
632 | rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED; |
633 | ||
634 | sci_base_state_machine_construct( | |
635 | &rnc->state_machine, | |
af23e857 | 636 | rnc, |
35173d57 DW |
637 | scic_sds_remote_node_context_state_table, |
638 | SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE | |
639 | ); | |
640 | ||
641 | sci_base_state_machine_start(&rnc->state_machine); | |
642 | } | |
338e386d DW |
643 | |
644 | enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remote_node_context *sci_rnc, | |
645 | u32 event_code) | |
646 | { | |
647 | enum scis_sds_remote_node_context_states state; | |
648 | ||
649 | state = sci_rnc->state_machine.current_state_id; | |
650 | switch (state) { | |
651 | case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE: | |
652 | switch (scu_get_event_code(event_code)) { | |
653 | case SCU_EVENT_POST_RNC_COMPLETE: | |
654 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
655 | SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE); | |
656 | break; | |
657 | default: | |
658 | goto out; | |
659 | } | |
660 | break; | |
661 | case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE: | |
662 | if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) { | |
663 | if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) | |
664 | state = SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE; | |
665 | else | |
666 | state = SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE; | |
667 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
668 | state); | |
669 | } else { | |
670 | switch (scu_get_event_type(event_code)) { | |
671 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX: | |
672 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX: | |
673 | /* We really dont care if the hardware is going to suspend | |
674 | * the device since it's being invalidated anyway */ | |
675 | dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
676 | "%s: SCIC Remote Node Context 0x%p was " | |
677 | "suspeneded by hardware while being " | |
678 | "invalidated.\n", __func__, sci_rnc); | |
679 | break; | |
680 | default: | |
681 | goto out; | |
682 | } | |
683 | } | |
684 | break; | |
685 | case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE: | |
686 | if (scu_get_event_code(event_code) == SCU_EVENT_POST_RCN_RELEASE) { | |
687 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
688 | SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE); | |
689 | } else { | |
690 | switch (scu_get_event_type(event_code)) { | |
691 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX: | |
692 | case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX: | |
693 | /* We really dont care if the hardware is going to suspend | |
694 | * the device since it's being resumed anyway */ | |
695 | dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
696 | "%s: SCIC Remote Node Context 0x%p was " | |
697 | "suspeneded by hardware while being resumed.\n", | |
698 | __func__, sci_rnc); | |
699 | break; | |
700 | default: | |
701 | goto out; | |
702 | } | |
703 | } | |
704 | break; | |
705 | case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE: | |
706 | switch (scu_get_event_type(event_code)) { | |
707 | case SCU_EVENT_TL_RNC_SUSPEND_TX: | |
708 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
709 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE); | |
710 | sci_rnc->suspension_code = scu_get_event_specifier(event_code); | |
711 | break; | |
712 | case SCU_EVENT_TL_RNC_SUSPEND_TX_RX: | |
713 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
714 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE); | |
715 | sci_rnc->suspension_code = scu_get_event_specifier(event_code); | |
716 | break; | |
717 | default: | |
718 | goto out; | |
719 | } | |
720 | break; | |
721 | case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE: | |
722 | switch (scu_get_event_type(event_code)) { | |
723 | case SCU_EVENT_TL_RNC_SUSPEND_TX: | |
724 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
725 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE); | |
726 | sci_rnc->suspension_code = scu_get_event_specifier(event_code); | |
727 | break; | |
728 | case SCU_EVENT_TL_RNC_SUSPEND_TX_RX: | |
729 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
730 | SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE); | |
731 | sci_rnc->suspension_code = scu_get_event_specifier(event_code); | |
732 | break; | |
733 | default: | |
734 | goto out; | |
735 | } | |
736 | break; | |
737 | default: | |
738 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
739 | "%s: invalid state %d\n", __func__, state); | |
740 | return SCI_FAILURE_INVALID_STATE; | |
741 | } | |
742 | return SCI_SUCCESS; | |
743 | ||
744 | out: | |
745 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
746 | "%s: code: %#x state: %d\n", __func__, event_code, state); | |
747 | return SCI_FAILURE; | |
748 | ||
749 | } | |
c845ae96 DW |
750 | |
751 | enum sci_status scic_sds_remote_node_context_destruct(struct scic_sds_remote_node_context *sci_rnc, | |
752 | scics_sds_remote_node_context_callback cb_fn, | |
753 | void *cb_p) | |
754 | { | |
755 | enum scis_sds_remote_node_context_states state; | |
756 | ||
757 | state = sci_rnc->state_machine.current_state_id; | |
758 | switch (state) { | |
759 | case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE: | |
760 | scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p); | |
761 | return SCI_SUCCESS; | |
762 | case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE: | |
763 | case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE: | |
764 | case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE: | |
765 | case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE: | |
766 | case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE: | |
767 | case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE: | |
768 | scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p); | |
769 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
770 | SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE); | |
771 | return SCI_SUCCESS; | |
772 | case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE: | |
773 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
774 | "%s: invalid state %d\n", __func__, state); | |
775 | /* We have decided that the destruct request on the remote node context | |
776 | * can not fail since it is either in the initial/destroyed state or is | |
777 | * can be destroyed. | |
778 | */ | |
779 | return SCI_SUCCESS; | |
780 | default: | |
781 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
782 | "%s: invalid state %d\n", __func__, state); | |
783 | return SCI_FAILURE_INVALID_STATE; | |
784 | } | |
785 | } | |
ed3efb77 DW |
786 | |
787 | enum sci_status scic_sds_remote_node_context_suspend(struct scic_sds_remote_node_context *sci_rnc, | |
788 | u32 suspend_type, | |
789 | scics_sds_remote_node_context_callback cb_fn, | |
790 | void *cb_p) | |
791 | { | |
792 | enum scis_sds_remote_node_context_states state; | |
793 | ||
794 | state = sci_rnc->state_machine.current_state_id; | |
795 | if (state != SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) { | |
796 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
797 | "%s: invalid state %d\n", __func__, state); | |
798 | return SCI_FAILURE_INVALID_STATE; | |
799 | } | |
800 | ||
801 | sci_rnc->user_callback = cb_fn; | |
802 | sci_rnc->user_cookie = cb_p; | |
803 | sci_rnc->suspension_code = suspend_type; | |
804 | ||
805 | if (suspend_type == SCI_SOFTWARE_SUSPENSION) { | |
806 | scic_sds_remote_device_post_request(rnc_to_dev(sci_rnc), | |
807 | SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX); | |
808 | } | |
809 | ||
810 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
811 | SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE); | |
812 | return SCI_SUCCESS; | |
813 | } | |
814 | ||
815 | enum sci_status scic_sds_remote_node_context_resume(struct scic_sds_remote_node_context *sci_rnc, | |
816 | scics_sds_remote_node_context_callback cb_fn, | |
817 | void *cb_p) | |
818 | { | |
819 | enum scis_sds_remote_node_context_states state; | |
820 | ||
821 | state = sci_rnc->state_machine.current_state_id; | |
822 | switch (state) { | |
823 | case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE: | |
824 | if (sci_rnc->remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) | |
825 | return SCI_FAILURE_INVALID_STATE; | |
826 | ||
827 | scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p); | |
828 | scic_sds_remote_node_context_construct_buffer(sci_rnc); | |
829 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
830 | SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE); | |
831 | return SCI_SUCCESS; | |
832 | case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE: | |
833 | case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE: | |
834 | case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE: | |
835 | if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) | |
836 | return SCI_FAILURE_INVALID_STATE; | |
837 | ||
838 | sci_rnc->user_callback = cb_fn; | |
839 | sci_rnc->user_cookie = cb_p; | |
840 | return SCI_SUCCESS; | |
841 | case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE: { | |
842 | struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc); | |
843 | struct domain_device *dev = sci_dev_to_domain(sci_dev); | |
844 | ||
845 | scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p); | |
846 | ||
847 | /* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */ | |
848 | if (dev->dev_type == SAS_END_DEV || dev_is_expander(dev)) | |
849 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
850 | SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE); | |
851 | else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) { | |
852 | if (sci_dev->is_direct_attached) { | |
853 | /* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */ | |
854 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
855 | SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE); | |
856 | } else { | |
857 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
858 | SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE); | |
859 | } | |
860 | } else | |
861 | return SCI_FAILURE; | |
862 | return SCI_SUCCESS; | |
863 | } | |
864 | case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE: | |
865 | scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p); | |
866 | sci_base_state_machine_change_state(&sci_rnc->state_machine, | |
867 | SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE); | |
868 | return SCI_FAILURE_INVALID_STATE; | |
869 | case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE: | |
870 | scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p); | |
871 | return SCI_SUCCESS; | |
872 | default: | |
873 | dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)), | |
874 | "%s: invalid state %d\n", __func__, state); | |
875 | return SCI_FAILURE_INVALID_STATE; | |
876 | } | |
877 | } |