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.
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
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.
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.
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.
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
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
40 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
41 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
42 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
43 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
44 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
46 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
47 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
48 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
49 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
50 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
53 #include <sys/cdefs.h>
54 __FBSDID("$FreeBSD$");
59 * @brief This file contains all of the method implementations pertaining
60 * to the framework remote device READY sub-state handler methods.
63 #include <dev/isci/scil/scic_remote_device.h>
64 #include <dev/isci/scil/scic_io_request.h>
66 #include <dev/isci/scil/scif_sas_logger.h>
67 #include <dev/isci/scil/scif_sas_remote_device.h>
68 #include <dev/isci/scil/scif_sas_domain.h>
69 #include <dev/isci/scil/scif_sas_task_request.h>
70 #include <dev/isci/scil/scif_sas_io_request.h>
71 #include <dev/isci/scil/scif_sas_internal_io_request.h>
72 #include <dev/isci/scil/scif_sas_controller.h>
73 #include <dev/isci/scil/sci_abstract_list.h>
74 #include <dev/isci/scil/intel_sat.h>
75 #include <dev/isci/scil/sci_controller.h>
77 //******************************************************************************
78 //* P R I V A T E M E T H O D S
79 //******************************************************************************
82 * @brief This method implements the behavior common to starting a task mgmt
83 * request. It will change the ready substate to task management.
85 * @param[in] fw_device This parameter specifies the remote device for
86 * which to complete a request.
87 * @param[in] fw_task This parameter specifies the task management
88 * request being started.
90 * @return This method returns a value indicating the status of the
94 SCI_STATUS scif_sas_remote_device_start_task_request(
95 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
96 SCIF_SAS_TASK_REQUEST_T * fw_task
99 // Transition into the TASK MGMT substate if not already in it.
100 if (fw_device->ready_substate_machine.current_state_id
101 != SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT)
103 sci_base_state_machine_change_state(
104 &fw_device->ready_substate_machine,
105 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
109 fw_device->request_count++;
110 fw_device->task_request_count++;
115 //******************************************************************************
116 //* R E A D Y O P E R A T I O N A L H A N D L E R S
117 //******************************************************************************
120 * @brief This method provides OPERATIONAL sub-state specific handling for
121 * when the core remote device object issues a device not ready
124 * @param[in] remote_device This parameter specifies the remote device
125 * object for which the notification occurred.
130 void scif_sas_remote_device_ready_operational_not_ready_handler(
131 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
135 if (reason_code == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
137 sci_base_state_machine_change_state(
138 &fw_device->ready_substate_machine,
139 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
144 // Even though we are in the OPERATIONAL state, the core remote device is not
145 // ready. As a result, we process user requests/events as if we were
146 // stopping the framework remote device.
147 sci_base_state_machine_change_state(
148 &fw_device->ready_substate_machine,
149 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_SUSPENDED
155 * @brief This method provides TASK MGMT sub-state specific handling for when
156 * the core remote device object issues a device not ready notification.
158 * @param[in] remote_device This parameter specifies the remote device
159 * object for which the notification occurred.
164 void scif_sas_remote_device_ready_task_management_not_ready_handler(
165 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
169 //do nothing. Don't need to go to suspended substate.
173 * @brief This method provides OPERATIONAL sub-state specific handling for
174 * when the remote device is being stopped by the framework.
176 * @param[in] remote_device This parameter specifies the remote device
177 * object for which the stop operation is being requested.
179 * @return This method returns an indication as to whether the failure
180 * operation completed successfully.
183 SCI_STATUS scif_sas_remote_device_ready_operational_stop_handler(
184 SCI_BASE_REMOTE_DEVICE_T * remote_device
187 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
190 sci_base_state_machine_change_state(
191 &fw_device->parent.state_machine, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
194 return fw_device->operation_status;
198 * @brief This method provides OPERATIONAL sub-state specific handling for
199 * when the user attempts to destruct the remote device. In
200 * the READY state the framework must first stop the device
201 * before destructing it.
203 * @param[in] remote_device This parameter specifies the remote device
204 * object for which the framework is attempting to start.
206 * @return This method returns an indication as to whether the destruct
207 * operation completed successfully.
210 SCI_STATUS scif_sas_remote_device_ready_operational_destruct_handler(
211 SCI_BASE_REMOTE_DEVICE_T * remote_device
214 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
217 fw_device->destruct_when_stopped = TRUE;
219 return (fw_device->state_handlers->parent.stop_handler(&fw_device->parent));
223 * @brief This method provides OPERATIONAL sub-state specific handling for
224 * when the remote device undergoes a failure condition.
226 * @param[in] remote_device This parameter specifies the remote device
227 * object for which the failure condition occurred.
229 * @return This method returns an indication as to whether the failure
230 * operation completed successfully.
233 SCI_STATUS scif_sas_remote_device_ready_operational_fail_handler(
234 SCI_BASE_REMOTE_DEVICE_T * remote_device
237 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T *)
241 sci_base_object_get_logger(fw_device),
242 SCIF_LOG_OBJECT_REMOTE_DEVICE,
243 "RemoteDevice:0x%x ready device failed\n",
247 sci_base_state_machine_change_state(
248 &fw_device->parent.state_machine, SCI_BASE_REMOTE_DEVICE_STATE_FAILED
251 /// @todo Fix the return code handling.
256 * @brief This method provides OPERATIONAL sub-state specific handling for
257 * when a user attempts to start an IO request on a remote
260 * @param[in] remote_device This parameter specifies the remote device
261 * object on which the user is attempting to perform a start
263 * @param[in] io_request This parameter specifies the IO request to be
266 * @return This method returns an indication as to whether the IO request
267 * started successfully.
270 SCI_STATUS scif_sas_remote_device_ready_operational_start_io_handler(
271 SCI_BASE_REMOTE_DEVICE_T * remote_device,
272 SCI_BASE_REQUEST_T * io_request
275 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
277 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request;
280 status = fw_io->parent.state_handlers->start_handler(&fw_io->parent.parent);
282 if (status == SCI_SUCCESS)
284 fw_device->request_count++;
291 * @brief This method provides OPERATIONAL sub-state specific handling for
292 * when a user attempts to start an IO request on a remote
295 * @param[in] remote_device This parameter specifies the remote device
296 * object on which the user is attempting to perform a complete
298 * @param[in] io_request This parameter specifies the IO request to
301 * @return This method returns an indication as to whether the IO request
302 * completed successfully.
304 SCI_STATUS scif_sas_remote_device_ready_operational_complete_io_handler(
305 SCI_BASE_REMOTE_DEVICE_T * remote_device,
306 SCI_BASE_REQUEST_T * io_request
309 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
311 fw_device->request_count--;
317 * @brief This method provides OPERATIONAL sub-state specific handling for
318 * when a user attempts to start an IO request on a remote
321 * @param[in] remote_device This parameter specifies the remote device
322 * object on which the user is attempting to perform a complete
324 * @param[in] io_request This parameter specifies the IO request to
327 * @return This method returns an indication as to whether the IO request
328 * completed successfully.
331 SCI_STATUS scif_sas_remote_device_ready_operational_complete_high_priority_io_handler(
332 SCI_BASE_REMOTE_DEVICE_T * remote_device,
333 SCI_BASE_REQUEST_T * io_request,
334 void * response_data,
335 SCI_IO_STATUS completion_status
339 sci_base_object_get_logger((SCIF_SAS_REMOTE_DEVICE_T *)remote_device),
340 SCIF_LOG_OBJECT_REMOTE_DEVICE,
341 "RemoteDevice:0x%x State:0x%x invalid state to complete high priority IO\n",
343 sci_base_state_machine_get_state(
344 &((SCIF_SAS_REMOTE_DEVICE_T *)remote_device)->parent.state_machine)
347 return SCI_FAILURE_INVALID_STATE;
352 * @brief This method provides OPERATIONAL sub-state specific handling for when
353 * the framework attempts to continue an IO request on a remote
356 * @param[in] remote_device This parameter specifies the remote device
357 * object on which the user is attempting to perform a continue
359 * @param[in] io_request This parameter specifies the IO request to
362 * @return This method returns an indication as to whether the IO request
363 * completed successfully.
366 SCI_STATUS scif_sas_remote_device_ready_operational_continue_io_handler(
367 SCI_BASE_REMOTE_DEVICE_T * remote_device,
368 SCI_BASE_REQUEST_T * io_request
371 /// @todo Fix the return code handling.
376 * @brief This method provides OPERATIONAL sub-state specific handling for
377 * when a user attempts to start a task management request on
378 * a remote device. This includes terminating all of the affected
379 * ongoing IO requests (i.e. aborting them in the silicon) and then
380 * issuing the task management request to the silicon.
382 * @param[in] remote_device This parameter specifies the remote device
383 * object on which the user is attempting to perform a start
385 * @param[in] task_request This parameter specifies the task management
386 * request to be started.
388 * @return This method returns an indication as to whether the task
389 * management request started successfully.
392 SCI_STATUS scif_sas_remote_device_ready_operational_start_task_handler(
393 SCI_BASE_REMOTE_DEVICE_T * remote_device,
394 SCI_BASE_REQUEST_T * task_request
397 SCI_STATUS status = SCI_FAILURE;
398 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
400 SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T*)
403 scif_sas_task_request_get_function(fw_task);
405 SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols;
407 scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols);
408 if ( dev_protocols.u.bits.attached_ssp_target
409 || dev_protocols.u.bits.attached_stp_target)
411 // //NOTE: For STP/SATA targets we currently terminate all requests for
412 // any type of task management.
413 if ( (task_function == SCI_SAS_ABORT_TASK_SET)
414 || (task_function == SCI_SAS_CLEAR_TASK_SET)
415 || (task_function == SCI_SAS_LOGICAL_UNIT_RESET)
416 || (task_function == SCI_SAS_I_T_NEXUS_RESET)
417 || (task_function == SCI_SAS_HARD_RESET) )
419 // Terminate all of the requests in the silicon for this device.
420 scif_sas_domain_terminate_requests(
421 fw_device->domain, fw_device, NULL, fw_task
424 status = scif_sas_remote_device_start_task_request(fw_device, fw_task);
426 else if ( (task_function == SCI_SAS_CLEAR_ACA)
427 || (task_function == SCI_SAS_QUERY_TASK)
428 || (task_function == SCI_SAS_QUERY_TASK_SET)
429 || (task_function == SCI_SAS_QUERY_ASYNCHRONOUS_EVENT) )
431 ASSERT(!dev_protocols.u.bits.attached_stp_target);
432 status = scif_sas_remote_device_start_task_request(fw_device, fw_task);
434 else if (task_function == SCI_SAS_ABORT_TASK)
436 SCIF_SAS_REQUEST_T * fw_request
437 = scif_sas_domain_get_request_by_io_tag(
438 fw_device->domain, fw_task->io_tag_to_manage
441 // Determine if the request being aborted was found.
442 if (fw_request != NULL)
444 scif_sas_domain_terminate_requests(
445 fw_device->domain, fw_device, fw_request, fw_task
448 status = scif_sas_remote_device_start_task_request(
453 status = SCI_FAILURE_INVALID_IO_TAG;
457 status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
459 if (status != SCI_SUCCESS)
462 sci_base_object_get_logger(fw_device),
463 SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_TASK_MANAGEMENT,
464 "Controller:0x%x TaskRequest:0x%x Status:0x%x start task failure\n",
465 fw_device, fw_task, status
473 * @brief This method provides OPERATIONAL sub-state specific handling for
474 * when a user attempts to complete a task management request on
477 * @param[in] remote_device This parameter specifies the remote device object
478 * on which the user is attempting to perform a complete task
480 * @param[in] task_request This parameter specifies the task management
481 * request to be completed.
483 * @return This method returns an indication as to whether the task
484 * management request succeeded.
486 SCI_STATUS scif_sas_remote_device_ready_operational_complete_task_handler(
487 SCI_BASE_REMOTE_DEVICE_T * remote_device,
488 SCI_BASE_REQUEST_T * task_request
491 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
493 fw_device->request_count--;
494 fw_device->task_request_count--;
500 * @brief This method provides OPERATIONAL sub-state specific handling for
501 * when a user attempts to start a high priority IO request on a remote
504 * @param[in] remote_device This parameter specifies the remote device
505 * object on which the user is attempting to perform a start
507 * @param[in] io_request This parameter specifies the IO request to be
510 * @return This method returns an indication as to whether the IO request
511 * started successfully.
514 SCI_STATUS scif_sas_remote_device_ready_operational_start_high_priority_io_handler(
515 SCI_BASE_REMOTE_DEVICE_T * remote_device,
516 SCI_BASE_REQUEST_T * io_request
519 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
521 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) io_request;
523 SMP_DISCOVER_RESPONSE_PROTOCOLS_T dev_protocols;
525 scic_remote_device_get_protocols(fw_device->core_object, &dev_protocols);
527 if (dev_protocols.u.bits.attached_smp_target)
529 //transit to task management state for smp request phase.
530 if (fw_device->ready_substate_machine.current_state_id
531 != SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT)
533 sci_base_state_machine_change_state(
534 &fw_device->ready_substate_machine,
535 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
540 fw_device->request_count++;
542 return fw_io->parent.state_handlers->start_handler(&fw_io->parent.parent);
547 * @brief This method provides TASK MANAGEMENT sub-state specific handling for
548 * when a user attempts to complete a task management request on
551 * @param[in] remote_device This parameter specifies the remote device object
552 * on which the user is attempting to perform a complete task
554 * @param[in] task_request This parameter specifies the task management
555 * request to be completed.
557 * @return This method returns an indication as to whether the task
558 * management request succeeded.
560 SCI_STATUS scif_sas_remote_device_ready_task_management_complete_task_handler(
561 SCI_BASE_REMOTE_DEVICE_T * remote_device,
562 SCI_BASE_REQUEST_T * task_request
565 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
568 SCIF_SAS_TASK_REQUEST_T * fw_task = (SCIF_SAS_TASK_REQUEST_T *)
571 fw_device->request_count--;
572 fw_device->task_request_count--;
574 // All existing task management requests and all of the IO requests
575 // affectected by the task management request must complete before
576 // the remote device can transition back into the READY / OPERATIONAL
578 if ( (fw_device->task_request_count == 0)
579 && (fw_task->affected_request_count == 0) )
581 sci_base_state_machine_change_state(
582 &fw_device->ready_substate_machine,
583 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
591 * @brief This method provides SUSPENDED sub-state specific handling for
592 * when the core remote device object issues a device ready
593 * notification. This effectively causes the framework remote
594 * device to transition back into the OPERATIONAL state.
596 * @param[in] remote_device This parameter specifies the remote device
597 * object for which the notification occurred.
602 void scif_sas_remote_device_ready_suspended_ready_handler(
603 SCIF_SAS_REMOTE_DEVICE_T * fw_device
606 sci_base_state_machine_change_state(
607 &fw_device->ready_substate_machine,
608 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
614 * @brief This handler is currently solely used by smp remote device for
617 * @param[in] remote_device This parameter specifies the remote device
618 * object on which the user is attempting to perform a complete high
619 * priority IO operation.
620 * @param[in] io_request This parameter specifies the high priority IO request
623 * @return SCI_STATUS indicate whether the io complete successfully.
626 scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler(
627 SCI_BASE_REMOTE_DEVICE_T * remote_device,
628 SCI_BASE_REQUEST_T * io_request,
629 void * response_data,
630 SCI_IO_STATUS completion_status
633 SCIF_SAS_REMOTE_DEVICE_T * fw_device = (SCIF_SAS_REMOTE_DEVICE_T*)
635 SCIF_SAS_REQUEST_T * fw_request = (SCIF_SAS_REQUEST_T*) io_request;
636 SCI_STATUS status = SCI_SUCCESS;
637 SCIC_TRANSPORT_PROTOCOL protocol;
640 sci_base_object_get_logger(remote_device),
641 SCIF_LOG_OBJECT_REMOTE_DEVICE | SCIF_LOG_OBJECT_IO_REQUEST,
642 "scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
643 remote_device, io_request, response_data, completion_status
646 fw_device->request_count--;
648 // we are back to ready operational sub state here.
649 sci_base_state_machine_change_state(
650 &fw_device->ready_substate_machine,
651 SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
654 protocol = scic_io_request_get_protocol(fw_request->core_object);
656 // If this request was an SMP initiator request we created, then
657 // decode the response.
658 if (protocol == SCIC_SMP_PROTOCOL)
660 if (completion_status != SCI_IO_FAILURE_TERMINATED)
662 status = scif_sas_smp_remote_device_decode_smp_response(
663 fw_device, fw_request, response_data, completion_status
667 scif_sas_smp_remote_device_terminated_request_handler(fw_device, fw_request);
671 // Currently, there are only internal SMP requests. So, default work
672 // is simply to clean up the internal request.
673 if (fw_request->is_internal == TRUE)
675 scif_sas_internal_io_request_complete(
676 fw_device->domain->controller,
677 (SCIF_SAS_INTERNAL_IO_REQUEST_T *)fw_request,
687 SCIF_SAS_REMOTE_DEVICE_STATE_HANDLER_T
688 scif_sas_remote_device_ready_substate_handler_table[] =
690 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_OPERATIONAL
693 scif_sas_remote_device_default_start_handler,
694 scif_sas_remote_device_ready_operational_stop_handler,
695 scif_sas_remote_device_ready_operational_fail_handler,
696 scif_sas_remote_device_ready_operational_destruct_handler,
697 scif_sas_remote_device_default_reset_handler,
698 scif_sas_remote_device_default_reset_complete_handler,
699 scif_sas_remote_device_ready_operational_start_io_handler,
700 scif_sas_remote_device_ready_operational_complete_io_handler,
701 scif_sas_remote_device_ready_operational_continue_io_handler,
702 scif_sas_remote_device_ready_operational_start_task_handler,
703 scif_sas_remote_device_ready_operational_complete_task_handler
705 scif_sas_remote_device_default_start_complete_handler,
706 scif_sas_remote_device_default_stop_complete_handler,
707 scif_sas_remote_device_default_ready_handler,
708 scif_sas_remote_device_ready_operational_not_ready_handler,
709 scif_sas_remote_device_ready_operational_start_high_priority_io_handler, //
710 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler
712 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_SUSPENDED
715 scif_sas_remote_device_default_start_handler,
716 scif_sas_remote_device_ready_operational_stop_handler,
717 scif_sas_remote_device_ready_operational_fail_handler,
718 scif_sas_remote_device_ready_operational_destruct_handler,
719 scif_sas_remote_device_default_reset_handler,
720 scif_sas_remote_device_default_reset_complete_handler,
721 scif_sas_remote_device_default_start_io_handler,
722 scif_sas_remote_device_ready_operational_complete_io_handler,
723 scif_sas_remote_device_default_continue_io_handler,
724 scif_sas_remote_device_ready_operational_start_task_handler,
725 scif_sas_remote_device_ready_operational_complete_task_handler
727 scif_sas_remote_device_default_start_complete_handler,
728 scif_sas_remote_device_default_stop_complete_handler,
729 scif_sas_remote_device_ready_suspended_ready_handler,
730 scif_sas_remote_device_default_not_ready_handler,
731 scif_sas_remote_device_default_start_io_handler,
732 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler
734 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_TASK_MGMT
737 scif_sas_remote_device_default_start_handler,
738 scif_sas_remote_device_ready_operational_stop_handler,
739 scif_sas_remote_device_ready_operational_fail_handler,
740 scif_sas_remote_device_ready_operational_destruct_handler,
741 scif_sas_remote_device_default_reset_handler,
742 scif_sas_remote_device_default_reset_complete_handler,
743 scif_sas_remote_device_default_start_io_handler,
744 scif_sas_remote_device_ready_operational_complete_io_handler,
745 scif_sas_remote_device_ready_operational_continue_io_handler,
746 scif_sas_remote_device_ready_operational_start_task_handler,
747 scif_sas_remote_device_ready_task_management_complete_task_handler
749 scif_sas_remote_device_default_start_complete_handler,
750 scif_sas_remote_device_default_stop_complete_handler,
751 scif_sas_remote_device_default_ready_handler,
752 scif_sas_remote_device_ready_task_management_not_ready_handler,
753 scif_sas_remote_device_ready_operational_start_high_priority_io_handler,
754 scif_sas_remote_device_ready_task_management_complete_high_priority_io_handler
756 // SCIF_SAS_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
759 scif_sas_remote_device_default_start_handler,
760 scif_sas_remote_device_ready_operational_stop_handler,
761 scif_sas_remote_device_ready_operational_fail_handler,
762 scif_sas_remote_device_ready_operational_destruct_handler,
763 scif_sas_remote_device_default_reset_handler,
764 scif_sas_remote_device_default_reset_complete_handler,
765 scif_sas_remote_device_default_start_io_handler,
766 scif_sas_remote_device_ready_operational_complete_io_handler,
767 scif_sas_remote_device_default_continue_io_handler,
768 scif_sas_remote_device_ready_operational_start_task_handler,
769 scif_sas_remote_device_ready_operational_complete_task_handler
771 scif_sas_remote_device_default_start_complete_handler,
772 scif_sas_remote_device_default_stop_complete_handler,
773 scif_sas_remote_device_ready_suspended_ready_handler,
774 scif_sas_remote_device_default_not_ready_handler,
775 scif_sas_remote_device_default_start_io_handler,
776 scif_sas_remote_device_ready_operational_complete_high_priority_io_handler