1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0 3 * 4 * This file is provided under a dual BSD/GPLv2 license. When using or 5 * redistributing this file, you may do so under either license. 6 * 7 * GPL LICENSE SUMMARY 8 * 9 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of version 2 of the GNU General Public License as 13 * published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 23 * The full GNU General Public License is included in this distribution 24 * in the file called LICENSE.GPL. 25 * 26 * BSD LICENSE 27 * 28 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 29 * All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions 33 * are met: 34 * 35 * * Redistributions of source code must retain the above copyright 36 * notice, this list of conditions and the following disclaimer. 37 * * Redistributions in binary form must reproduce the above copyright 38 * notice, this list of conditions and the following disclaimer in 39 * the documentation and/or other materials provided with the 40 * distribution. 41 * 42 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 43 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 44 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 45 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 46 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 47 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 48 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 49 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 50 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 51 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 52 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 53 */ 54 55 #include <sys/cdefs.h> 56 /** 57 * @file 58 * 59 * @brief This file contains This file contains the SMP remote device 60 * object methods and it's state machines. 61 */ 62 63 #include <dev/isci/scil/scic_user_callback.h> 64 #include <dev/isci/scil/scic_sds_logger.h> 65 #include <dev/isci/scil/scic_sds_remote_device.h> 66 #include <dev/isci/scil/scic_sds_controller.h> 67 #include <dev/isci/scil/scic_sds_port.h> 68 #include <dev/isci/scil/scic_sds_request.h> 69 #include <dev/isci/scil/scu_event_codes.h> 70 #include <dev/isci/scil/scu_task_context.h> 71 #include <dev/isci/scil/scic_remote_device.h> 72 73 //***************************************************************************** 74 //* SMP REMOTE DEVICE READY IDLE SUBSTATE HANDLERS 75 //***************************************************************************** 76 77 /** 78 * This method will handle the start io operation for a SMP device that is in 79 * the idle state. 80 * 81 * @param [in] device The device the io is sent to. 82 * @param [in] request The io to start. 83 * 84 * @return SCI_STATUS 85 */ 86 static 87 SCI_STATUS scic_sds_smp_remote_device_ready_idle_substate_start_io_handler( 88 SCI_BASE_REMOTE_DEVICE_T * device, 89 SCI_BASE_REQUEST_T * request 90 ) 91 { 92 SCI_STATUS status; 93 SCIC_SDS_REMOTE_DEVICE_T * this_device = (SCIC_SDS_REMOTE_DEVICE_T *)device; 94 SCIC_SDS_REQUEST_T * io_request = (SCIC_SDS_REQUEST_T *)request; 95 96 // Will the port allow the io request to start? 97 status = this_device->owning_port->state_handlers->start_io_handler( 98 this_device->owning_port, 99 this_device, 100 io_request 101 ); 102 103 if (status == SCI_SUCCESS) 104 { 105 status = 106 scic_sds_remote_node_context_start_io(this_device->rnc, io_request); 107 108 if (status == SCI_SUCCESS) 109 { 110 status = scic_sds_request_start(io_request); 111 } 112 113 if (status == SCI_SUCCESS) 114 { 115 this_device->working_request = io_request; 116 117 sci_base_state_machine_change_state( 118 &this_device->ready_substate_machine, 119 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD 120 ); 121 } 122 123 scic_sds_remote_device_start_request(this_device, io_request, status); 124 } 125 126 return status; 127 } 128 129 130 //****************************************************************************** 131 //* SMP REMOTE DEVICE READY SUBSTATE CMD HANDLERS 132 //****************************************************************************** 133 /** 134 * This device is already handling a command it can not accept new commands 135 * until this one is complete. 136 * 137 * @param[in] device This is the device object that is receiving the IO. 138 * 139 * @param[in] request The io to start. 140 * 141 * @return SCI_STATUS 142 */ 143 static 144 SCI_STATUS scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler( 145 SCI_BASE_REMOTE_DEVICE_T * device, 146 SCI_BASE_REQUEST_T * request 147 ) 148 { 149 return SCI_FAILURE_INVALID_STATE; 150 } 151 152 153 /** 154 * @brief this is the complete_io_handler for smp device at ready cmd substate. 155 * 156 * @param[in] device This is the device object that is receiving the IO. 157 * @param[in] request The io to start. 158 * 159 * @return SCI_STATUS 160 */ 161 static 162 SCI_STATUS scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler( 163 SCI_BASE_REMOTE_DEVICE_T * device, 164 SCI_BASE_REQUEST_T * request 165 ) 166 { 167 SCI_STATUS status; 168 SCIC_SDS_REMOTE_DEVICE_T * this_device; 169 SCIC_SDS_REQUEST_T * the_request; 170 171 this_device = (SCIC_SDS_REMOTE_DEVICE_T *)device; 172 the_request = (SCIC_SDS_REQUEST_T *)request; 173 174 status = scic_sds_io_request_complete(the_request); 175 176 if (status == SCI_SUCCESS) 177 { 178 status = scic_sds_port_complete_io( 179 this_device->owning_port, this_device, the_request); 180 181 if (status == SCI_SUCCESS) 182 { 183 scic_sds_remote_device_decrement_request_count(this_device); 184 sci_base_state_machine_change_state( 185 &this_device->ready_substate_machine, 186 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE 187 ); 188 } 189 else 190 { 191 SCIC_LOG_ERROR(( 192 sci_base_object_get_logger(this_device), 193 SCIC_LOG_OBJECT_SMP_REMOTE_TARGET, 194 "SCIC SDS Remote Device 0x%x io request 0x%x could not be completd on the port 0x%x failed with status %d.\n", 195 this_device, the_request, this_device->owning_port, status 196 )); 197 } 198 } 199 200 return status; 201 } 202 203 /** 204 * @brief This is frame handler for smp device ready cmd substate. 205 * 206 * @param[in] this_device This is the device object that is receiving the frame. 207 * @param[in] frame_index The index for the frame received. 208 * 209 * @return SCI_STATUS 210 */ 211 static 212 SCI_STATUS scic_sds_smp_remote_device_ready_cmd_substate_frame_handler( 213 SCIC_SDS_REMOTE_DEVICE_T * this_device, 214 U32 frame_index 215 ) 216 { 217 SCI_STATUS status; 218 219 /// The device does not process any UF received from the hardware while 220 /// in this state. All unsolicited frames are forwarded to the io request 221 /// object. 222 status = scic_sds_io_request_frame_handler( 223 this_device->working_request, 224 frame_index 225 ); 226 227 return status; 228 } 229 230 // --------------------------------------------------------------------------- 231 232 SCIC_SDS_REMOTE_DEVICE_STATE_HANDLER_T 233 scic_sds_smp_remote_device_ready_substate_handler_table[ 234 SCIC_SDS_SMP_REMOTE_DEVICE_READY_MAX_SUBSTATES] = 235 { 236 // SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE 237 { 238 { 239 scic_sds_remote_device_default_start_handler, 240 scic_sds_remote_device_ready_state_stop_handler, 241 scic_sds_remote_device_default_fail_handler, 242 scic_sds_remote_device_default_destruct_handler, 243 scic_sds_remote_device_default_reset_handler, 244 scic_sds_remote_device_default_reset_complete_handler, 245 scic_sds_smp_remote_device_ready_idle_substate_start_io_handler, 246 scic_sds_remote_device_default_complete_request_handler, 247 scic_sds_remote_device_default_continue_request_handler, 248 scic_sds_remote_device_default_start_request_handler, 249 scic_sds_remote_device_default_complete_request_handler 250 }, 251 scic_sds_remote_device_default_suspend_handler, 252 scic_sds_remote_device_default_resume_handler, 253 scic_sds_remote_device_general_event_handler, 254 scic_sds_remote_device_default_frame_handler 255 }, 256 // SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD 257 { 258 { 259 scic_sds_remote_device_default_start_handler, 260 scic_sds_remote_device_ready_state_stop_handler, 261 scic_sds_remote_device_default_fail_handler, 262 scic_sds_remote_device_default_destruct_handler, 263 scic_sds_remote_device_default_reset_handler, 264 scic_sds_remote_device_default_reset_complete_handler, 265 scic_sds_smp_remote_device_ready_cmd_substate_start_io_handler, 266 scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler, 267 scic_sds_remote_device_default_continue_request_handler, 268 scic_sds_remote_device_default_start_request_handler, 269 scic_sds_remote_device_default_complete_request_handler 270 }, 271 scic_sds_remote_device_default_suspend_handler, 272 scic_sds_remote_device_default_resume_handler, 273 scic_sds_remote_device_general_event_handler, 274 scic_sds_smp_remote_device_ready_cmd_substate_frame_handler 275 } 276 }; 277 278 /** 279 * This is the SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE enter method. This 280 * method sets the ready cmd substate handlers and reports the device as ready. 281 * 282 * @param[in] object This is the SCI_BASE_OBJECT which is cast into a 283 * SCIC_SDS_REMOTE_DEVICE. 284 * 285 * @return none 286 */ 287 static 288 void scic_sds_smp_remote_device_ready_idle_substate_enter( 289 SCI_BASE_OBJECT_T *object 290 ) 291 { 292 SCIC_SDS_REMOTE_DEVICE_T *this_device = (SCIC_SDS_REMOTE_DEVICE_T *)object; 293 294 SET_STATE_HANDLER( 295 this_device, 296 scic_sds_smp_remote_device_ready_substate_handler_table, 297 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE 298 ); 299 300 scic_cb_remote_device_ready( 301 scic_sds_remote_device_get_controller(this_device), this_device); 302 } 303 304 /** 305 * This is the SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD enter method. This 306 * method sets the remote device objects ready cmd substate handlers, and notify 307 * core user that the device is not ready. 308 * 309 * @param[in] object This is the SCI_BASE_OBJECT which is cast into a 310 * SCIC_SDS_REMOTE_DEVICE. 311 * 312 * @return none 313 */ 314 static 315 void scic_sds_smp_remote_device_ready_cmd_substate_enter( 316 SCI_BASE_OBJECT_T *object 317 ) 318 { 319 SCIC_SDS_REMOTE_DEVICE_T *this_device = (SCIC_SDS_REMOTE_DEVICE_T *)object; 320 321 ASSERT(this_device->working_request != NULL); 322 323 SET_STATE_HANDLER( 324 this_device, 325 scic_sds_smp_remote_device_ready_substate_handler_table, 326 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD 327 ); 328 329 scic_cb_remote_device_not_ready( 330 scic_sds_remote_device_get_controller(this_device), 331 this_device, 332 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED 333 ); 334 } 335 336 /** 337 * This is the SCIC_SDS_SSP_REMOTE_DEVICE_READY_SUBSTATE_CMD exit method. 338 * 339 * @param[in] object This is the SCI_BASE_OBJECT which is cast into a 340 * SCIC_SDS_REMOTE_DEVICE. 341 * 342 * @return none 343 */ 344 static 345 void scic_sds_smp_remote_device_ready_cmd_substate_exit( 346 SCI_BASE_OBJECT_T *object 347 ) 348 { 349 SCIC_SDS_REMOTE_DEVICE_T * this_device = (SCIC_SDS_REMOTE_DEVICE_T *)object; 350 351 this_device->working_request = NULL; 352 } 353 354 // --------------------------------------------------------------------------- 355 356 SCI_BASE_STATE_T 357 scic_sds_smp_remote_device_ready_substate_table[ 358 SCIC_SDS_SMP_REMOTE_DEVICE_READY_MAX_SUBSTATES] = 359 { 360 { 361 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE, 362 scic_sds_smp_remote_device_ready_idle_substate_enter, 363 NULL 364 }, 365 { 366 SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD, 367 scic_sds_smp_remote_device_ready_cmd_substate_enter, 368 scic_sds_smp_remote_device_ready_cmd_substate_exit 369 } 370 }; 371 372