2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
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.
9 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
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.
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.
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.
28 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
29 * All rights reserved.
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions
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
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.
55 #include <sys/cdefs.h>
56 __FBSDID("$FreeBSD$");
61 * @brief This file contains all of the method implementations pertaining
62 * to the framework remote device READY sub-state handler methods.
65 #include <dev/isci/scil/scic_remote_device.h>
66 #include <dev/isci/scil/scic_io_request.h>
68 #include <dev/isci/scil/scif_sas_logger.h>
69 #include <dev/isci/scil/scif_sas_remote_device.h>
70 #include <dev/isci/scil/scif_sas_domain.h>
71 #include <dev/isci/scil/scif_sas_task_request.h>
72 #include <dev/isci/scil/scif_sas_io_request.h>
73 #include <dev/isci/scil/scif_sas_internal_io_request.h>
74 #include <dev/isci/scil/scif_sas_controller.h>
75 #include <dev/isci/scil/sci_abstract_list.h>
76 #include <dev/isci/scil/intel_sat.h>
77 #include <dev/isci/scil/sci_controller.h>
79 //******************************************************************************
80 //* P R I V A T E M E T H O D S
81 //******************************************************************************
84 * @brief This method implements the behavior common to starting a task mgmt
85 * request. It will change the ready substate to task management.
87 * @param[in] fw_device This parameter specifies the remote device for
88 * which to complete a request.
89 * @param[in] fw_task This parameter specifies the task management
90 * request being started.
92 * @return This method returns a value indicating the status of the
96 SCI_STATUS scif_sas_remote_device_start_task_request(
97 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
98 SCIF_SAS_TASK_REQUEST_T * fw_task
101 // Transition into the TASK MGMT substate if not already in it.
102 if (fw_device->ready_substate_machine.current_state_id
103 != SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT)
105 sci_base_state_machine_change_state(
106 &fw_device->ready_substate_machine,
107 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
111 fw_device->request_count++;
112 fw_device->task_request_count++;
117 //******************************************************************************
118 //* R E A D Y O P E R A T I O N A L H A N D L E R S
119 //******************************************************************************
122 * @brief This method provides OPERATIONAL sub-state specific handling for
123 * when the core remote device object issues a device not ready
126 * @param[in] remote_device This parameter specifies the remote device
127 * object for which the notification occurred.
132 void scif_sas_remote_device_ready_operational_not_ready_handler(
133 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
137 if (reason_code == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
139 sci_base_state_machine_change_state(
140 &fw_device->ready_substate_machine,
141 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
146 // Even though we are in the OPERATIONAL state, the core remote device is not
147 // ready. As a result, we process user requests/events as if we were
148 // stopping the framework remote device.
149 sci_base_state_machine_change_state(
150 &fw_device->ready_substate_machine,
151 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_SUSPENDED
157 * @brief This method provides TASK MGMT sub-state specific handling for when
158 * the core remote device object issues a device not ready notification.
160 * @param[in] remote_device This parameter specifies the remote device
161 * object for which the notification occurred.
166 void scif_sas_remote_device_ready_task_management_not_ready_handler(
167 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
171 //do nothing. Don't need to go to suspended substate.
175 * @brief This method provides OPERATIONAL sub-state specific handling for
176 * when the remote device is being stopped by the framework.
178 * @param[in] remote_device This parameter specifies the remote device
179 * object for which the stop operation is being requested.
181 * @return This method returns an indication as to whether the failure
182 * operation completed successfully.
185 SCI_STATUS scif_sas_remote_device_ready_operational_stop_handler(
186 SCI_BASE_REMOTE_DEVICE_T * remote_device
189 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
192 sci_base_state_machine_change_state(
193 &fw_device->parent.state_machine, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
196 return fw_device->operation_status;
200 * @brief This method provides OPERATIONAL sub-state specific handling for
201 * when the user attempts to destruct the remote device. In
202 * the READY state the framework must first stop the device
203 * before destructing it.
205 * @param[in] remote_device This parameter specifies the remote device
206 * object for which the framework is attempting to start.
208 * @return This method returns an indication as to whether the destruct
209 * operation completed successfully.
212 SCI_STATUS scif_sas_remote_device_ready_operational_destruct_handler(
213 SCI_BASE_REMOTE_DEVICE_T * remote_device
216 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
219 fw_device->destruct_when_stopped = TRUE;
221 return (fw_device->state_handlers->parent.stop_handler(&fw_device->parent));
225 * @brief This method provides OPERATIONAL sub-state specific handling for
226 * when the remote device undergoes a failure condition.
228 * @param[in] remote_device This parameter specifies the remote device
229 * object for which the failure condition occurred.
231 * @return This method returns an indication as to whether the failure
232 * operation completed successfully.
235 SCI_STATUS scif_sas_remote_device_ready_operational_fail_handler(
236 SCI_BASE_REMOTE_DEVICE_T * remote_device
239 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
243 sci_base_object_get_logger(fw_device),
244 SCIF_LOG_OBJECT_REMOTE_DEVICE,
245 "RemoteDevice:0x%x ready device failed\n",
249 sci_base_state_machine_change_state(
250 &fw_device->parent.state_machine, SCI_BASE_REMOTE_DEVICE_STATE_FAILED
253 /// @todo Fix the return code handling.
258 * @brief This method provides OPERATIONAL sub-state specific handling for
259 * when a user attempts to start an IO request on a remote
262 * @param[in] remote_device This parameter specifies the remote device
263 * object on which the user is attempting to perform a start
265 * @param[in] io_request This parameter specifies the IO request to be
268 * @return This method returns an indication as to whether the IO request
269 * started successfully.
272 SCI_STATUS scif_sas_remote_device_ready_operational_start_io_handler(
273 SCI_BASE_REMOTE_DEVICE_T * remote_device,
274 SCI_BASE_REQUEST_T * io_request
277 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
279 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request;
282 status = fw_io->parent.state_handlers->start_handler(&fw_io->parent.parent);
284 if (status == SCI_SUCCESS)
286 fw_device->request_count++;
293 * @brief This method provides OPERATIONAL sub-state specific handling for
294 * when a user attempts to start an IO request on a remote
297 * @param[in] remote_device This parameter specifies the remote device
298 * object on which the user is attempting to perform a complete
300 * @param[in] io_request This parameter specifies the IO request to
303 * @return This method returns an indication as to whether the IO request
304 * completed successfully.
306 SCI_STATUS scif_sas_remote_device_ready_operational_complete_io_handler(
307 SCI_BASE_REMOTE_DEVICE_T * remote_device,
308 SCI_BASE_REQUEST_T * io_request
311 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
313 fw_device->request_count--;
319 * @brief This method provides OPERATIONAL sub-state specific handling for
320 * when a user attempts to start an IO request on a remote
323 * @param[in] remote_device This parameter specifies the remote device
324 * object on which the user is attempting to perform a complete
326 * @param[in] io_request This parameter specifies the IO request to
329 * @return This method returns an indication as to whether the IO request
330 * completed successfully.
333 SCI_STATUS scif_sas_remote_device_ready_operational_complete_high_priority_io_handler(
334 SCI_BASE_REMOTE_DEVICE_T * remote_device,
335 SCI_BASE_REQUEST_T * io_request,
336 void * response_data,
337 SCI_IO_STATUS completion_status
341 sci_base_object_get_logger((SCIF_SAS_REMOTE_DEVICE_T *)remote_device),
342 SCIF_LOG_OBJECT_REMOTE_DEVICE,
343 "RemoteDevice:0x%x State:0x%x invalid state to complete high priority IO\n",
345 sci_base_state_machine_get_state(
346 &((SCIF_SAS_REMOTE_DEVICE_T *)remote_device)->parent.state_machine)
349 return SCI_FAILURE_INVALID_STATE;
354 * @brief This method provides OPERATIONAL sub-state specific handling for when
355 * the framework attempts to continue an IO request on a remote
358 * @param[in] remote_device This parameter specifies the remote device
359 * object on which the user is attempting to perform a continue
361 * @param[in] io_request This parameter specifies the IO request to
364 * @return This method returns an indication as to whether the IO request
365 * completed successfully.
368 SCI_STATUS scif_sas_remote_device_ready_operational_continue_io_handler(
369 SCI_BASE_REMOTE_DEVICE_T * remote_device,
370 SCI_BASE_REQUEST_T * io_request
373 /// @todo Fix the return code handling.
378 * @brief This method provides OPERATIONAL sub-state specific handling for
379 * when a user attempts to start a task management request on
380 * a remote device. This includes terminating all of the affected
381 * ongoing IO requests (i.e. aborting them in the silicon) and then
382 * issuing the task management request to the silicon.
384 * @param[in] remote_device This parameter specifies the remote device
385 * object on which the user is attempting to perform a start
387 * @param[in] task_request This parameter specifies the task management
388 * request to be started.
390 * @return This method returns an indication as to whether the task
391 * management request started successfully.
394 SCI_STATUS scif_sas_remote_device_ready_operational_start_task_handler(
395 SCI_BASE_REMOTE_DEVICE_T * remote_device,
396 SCI_BASE_REQUEST_T * task_request
399 SCI_STATUS status = SCI_FAILURE;
400 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
402 SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T*)
405 scif_sas_task_request_get_function(fw_task);
407 SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols;
409 scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols);
410 if ( dev_protocols.u.bits.attached_ssp_target
411 || dev_protocols.u.bits.attached_stp_target)
413 // //NOTE: For STP/SATA targets we currently terminate all requests for
414 // any type of task management.
415 if ( (task_function == SCI_SAS_ABORT_TASK_SET)
416 || (task_function == SCI_SAS_CLEAR_TASK_SET)
417 || (task_function == SCI_SAS_LOGICAL_UNIT_RESET)
418 || (task_function == SCI_SAS_I_T_NEXUS_RESET)
419 || (task_function == SCI_SAS_HARD_RESET) )
421 // Terminate all of the requests in the silicon for this device.
422 scif_sas_domain_terminate_requests(
423 fw_device->domain, fw_device, NULL, fw_task
426 status = scif_sas_remote_device_start_task_request(fw_device, fw_task);
428 else if ( (task_function == SCI_SAS_CLEAR_ACA)
429 || (task_function == SCI_SAS_QUERY_TASK)
430 || (task_function == SCI_SAS_QUERY_TASK_SET)
431 || (task_function == SCI_SAS_QUERY_ASYNCHRONOUS_EVENT) )
433 ASSERT(!dev_protocols.u.bits.attached_stp_target);
434 status = scif_sas_remote_device_start_task_request(fw_device, fw_task);
436 else if (task_function == SCI_SAS_ABORT_TASK)
438 SCIF_SAS_REQUEST_T * fw_request
439 = scif_sas_domain_get_request_by_io_tag(
440 fw_device->domain, fw_task->io_tag_to_manage
443 // Determine if the request being aborted was found.
444 if (fw_request != NULL)
446 scif_sas_domain_terminate_requests(
447 fw_device->domain, fw_device, fw_request, fw_task
450 status = scif_sas_remote_device_start_task_request(
455 status = SCI_FAILURE_INVALID_IO_TAG;
459 status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
461 if (status != SCI_SUCCESS)
464 sci_base_object_get_logger(fw_device),
465 SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
466 "Controller:0x%x TaskRequest:0x%x Status:0x%x start task failure\n",
467 fw_device, fw_task, status
475 * @brief This method provides OPERATIONAL sub-state specific handling for
476 * when a user attempts to complete a task management request on
479 * @param[in] remote_device This parameter specifies the remote device object
480 * on which the user is attempting to perform a complete task
482 * @param[in] task_request This parameter specifies the task management
483 * request to be completed.
485 * @return This method returns an indication as to whether the task
486 * management request succeeded.
488 SCI_STATUS scif_sas_remote_device_ready_operational_complete_task_handler(
489 SCI_BASE_REMOTE_DEVICE_T * remote_device,
490 SCI_BASE_REQUEST_T * task_request
493 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
495 fw_device->request_count--;
496 fw_device->task_request_count--;
502 * @brief This method provides OPERATIONAL sub-state specific handling for
503 * when a user attempts to start a high priority IO request on a remote
506 * @param[in] remote_device This parameter specifies the remote device
507 * object on which the user is attempting to perform a start
509 * @param[in] io_request This parameter specifies the IO request to be
512 * @return This method returns an indication as to whether the IO request
513 * started successfully.
516 SCI_STATUS scif_sas_remote_device_ready_operational_start_high_priority_io_handler(
517 SCI_BASE_REMOTE_DEVICE_T * remote_device,
518 SCI_BASE_REQUEST_T * io_request
521 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
523 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request;
525 SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols;
527 scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols);
529 if (dev_protocols.u.bits.attached_smp_target)
531 //transit to task management state for smp request phase.
532 if (fw_device->ready_substate_machine.current_state_id
533 != SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT)
535 sci_base_state_machine_change_state(
536 &fw_device->ready_substate_machine,
537 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
542 fw_device->request_count++;
544 return fw_io->parent.state_handlers->start_handler(&fw_io->parent.parent);
549 * @brief This method provides TASK MANAGEMENT sub-state specific handling for
550 * when a user attempts to complete a task management request on
553 * @param[in] remote_device This parameter specifies the remote device object
554 * on which the user is attempting to perform a complete task
556 * @param[in] task_request This parameter specifies the task management
557 * request to be completed.
559 * @return This method returns an indication as to whether the task
560 * management request succeeded.
562 SCI_STATUS scif_sas_remote_device_ready_task_management_complete_task_handler(
563 SCI_BASE_REMOTE_DEVICE_T * remote_device,
564 SCI_BASE_REQUEST_T * task_request
567 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
570 SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T *)
573 fw_device->request_count--;
574 fw_device->task_request_count--;
576 // All existing task management requests and all of the IO requests
577 // affectected by the task management request must complete before
578 // the remote device can transition back into the READY / OPERATIONAL
580 if ( (fw_device->task_request_count == 0)
581 && (fw_task->affected_request_count == 0) )
583 sci_base_state_machine_change_state(
584 &fw_device->ready_substate_machine,
585 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
593 * @brief This method provides SUSPENDED sub-state specific handling for
594 * when the core remote device object issues a device ready
595 * notification. This effectively causes the framework remote
596 * device to transition back into the OPERATIONAL state.
598 * @param[in] remote_device This parameter specifies the remote device
599 * object for which the notification occurred.
604 void scif_sas_remote_device_ready_suspended_ready_handler(
605 SCIF_SAS_REMOTE_DEVICE_T * fw_device
608 sci_base_state_machine_change_state(
609 &fw_device->ready_substate_machine,
610 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
616 * @brief This handler is currently solely used by smp remote device for
619 * @param[in] remote_device This parameter specifies the remote device
620 * object on which the user is attempting to perform a complete high
621 * priority IO operation.
622 * @param[in] io_request This parameter specifies the high priority IO request
625 * @return SCI_STATUS indicate whether the io complete successfully.
628 scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler(
629 SCI_BASE_REMOTE_DEVICE_T * remote_device,
630 SCI_BASE_REQUEST_T * io_request,
631 void * response_data,
632 SCI_IO_STATUS completion_status
635 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
637 SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) io_request;
638 SCI_STATUS status = SCI_SUCCESS;
639 SCIC_TRANSPORT_PROTOCOL protocol;
642 sci_base_object_get_logger(remote_device),
643 SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_IO_REQUEST,
644 "scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
645 remote_device, io_request, response_data, completion_status
648 fw_device->request_count--;
650 // we are back to ready operational sub state here.
651 sci_base_state_machine_change_state(
652 &fw_device->ready_substate_machine,
653 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
656 protocol = scic_io_request_get_protocol(fw_request->core_object);
658 // If this request was an SMP initiator request we created, then
659 // decode the response.
660 if (protocol == SCIC_SMP_PROTOCOL)
662 if (completion_status != SCI_IO_FAILURE_TERMINATED)
664 status = scif_sas_smp_remote_device_decode_smp_response(
665 fw_device, fw_request, response_data, completion_status
669 scif_sas_smp_remote_device_terminated_request_handler(fw_device, fw_request);
673 // Currently, there are only internal SMP requests. So, default work
674 // is simply to clean up the internal request.
675 if (fw_request->is_internal == TRUE)
677 scif_sas_internal_io_request_complete(
678 fw_device->domain->controller,
679 (SCIF_SAS_INTERNAL_IO_REQUEST_T *)fw_request,
689 SCIF_SAS_REMOTE_DEVICE_STATE_HANDLER_T
690 scif_sas_remote_device_ready_substate_handler_table[] =
692 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
695 scif_sas_remote_device_default_start_handler,
696 scif_sas_remote_device_ready_operational_stop_handler,
697 scif_sas_remote_device_ready_operational_fail_handler,
698 scif_sas_remote_device_ready_operational_destruct_handler,
699 scif_sas_remote_device_default_reset_handler,
700 scif_sas_remote_device_default_reset_complete_handler,
701 scif_sas_remote_device_ready_operational_start_io_handler,
702 scif_sas_remote_device_ready_operational_complete_io_handler,
703 scif_sas_remote_device_ready_operational_continue_io_handler,
704 scif_sas_remote_device_ready_operational_start_task_handler,
705 scif_sas_remote_device_ready_operational_complete_task_handler
707 scif_sas_remote_device_default_start_complete_handler,
708 scif_sas_remote_device_default_stop_complete_handler,
709 scif_sas_remote_device_default_ready_handler,
710 scif_sas_remote_device_ready_operational_not_ready_handler,
711 scif_sas_remote_device_ready_operational_start_high_priority_io_handler, //
712 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler
714 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_SUSPENDED
717 scif_sas_remote_device_default_start_handler,
718 scif_sas_remote_device_ready_operational_stop_handler,
719 scif_sas_remote_device_ready_operational_fail_handler,
720 scif_sas_remote_device_ready_operational_destruct_handler,
721 scif_sas_remote_device_default_reset_handler,
722 scif_sas_remote_device_default_reset_complete_handler,
723 scif_sas_remote_device_default_start_io_handler,
724 scif_sas_remote_device_ready_operational_complete_io_handler,
725 scif_sas_remote_device_default_continue_io_handler,
726 scif_sas_remote_device_ready_operational_start_task_handler,
727 scif_sas_remote_device_ready_operational_complete_task_handler
729 scif_sas_remote_device_default_start_complete_handler,
730 scif_sas_remote_device_default_stop_complete_handler,
731 scif_sas_remote_device_ready_suspended_ready_handler,
732 scif_sas_remote_device_default_not_ready_handler,
733 scif_sas_remote_device_default_start_io_handler,
734 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler
736 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
739 scif_sas_remote_device_default_start_handler,
740 scif_sas_remote_device_ready_operational_stop_handler,
741 scif_sas_remote_device_ready_operational_fail_handler,
742 scif_sas_remote_device_ready_operational_destruct_handler,
743 scif_sas_remote_device_default_reset_handler,
744 scif_sas_remote_device_default_reset_complete_handler,
745 scif_sas_remote_device_default_start_io_handler,
746 scif_sas_remote_device_ready_operational_complete_io_handler,
747 scif_sas_remote_device_ready_operational_continue_io_handler,
748 scif_sas_remote_device_ready_operational_start_task_handler,
749 scif_sas_remote_device_ready_task_management_complete_task_handler
751 scif_sas_remote_device_default_start_complete_handler,
752 scif_sas_remote_device_default_stop_complete_handler,
753 scif_sas_remote_device_default_ready_handler,
754 scif_sas_remote_device_ready_task_management_not_ready_handler,
755 scif_sas_remote_device_ready_operational_start_high_priority_io_handler,
756 scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler
758 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
761 scif_sas_remote_device_default_start_handler,
762 scif_sas_remote_device_ready_operational_stop_handler,
763 scif_sas_remote_device_ready_operational_fail_handler,
764 scif_sas_remote_device_ready_operational_destruct_handler,
765 scif_sas_remote_device_default_reset_handler,
766 scif_sas_remote_device_default_reset_complete_handler,
767 scif_sas_remote_device_default_start_io_handler,
768 scif_sas_remote_device_ready_operational_complete_io_handler,
769 scif_sas_remote_device_default_continue_io_handler,
770 scif_sas_remote_device_ready_operational_start_task_handler,
771 scif_sas_remote_device_ready_operational_complete_task_handler
773 scif_sas_remote_device_default_start_complete_handler,
774 scif_sas_remote_device_default_stop_complete_handler,
775 scif_sas_remote_device_ready_suspended_ready_handler,
776 scif_sas_remote_device_default_not_ready_handler,
777 scif_sas_remote_device_default_start_io_handler,
778 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler