xref: /freebsd/sys/dev/isci/scil/scic_sds_stp_request.c (revision 8d20be1e22095c27faf8fe8b2f0d089739cc742e)
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  *
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.
51  */
52 
53 #include <sys/cdefs.h>
54 __FBSDID("$FreeBSD$");
55 
56 #include <dev/isci/scil/intel_sat.h>
57 #include <dev/isci/scil/intel_sata.h>
58 #include <dev/isci/scil/sci_types.h>
59 #include <dev/isci/scil/scic_remote_device.h>
60 #include <dev/isci/scil/scic_user_callback.h>
61 #include <dev/isci/scil/scic_sds_controller.h>
62 #include <dev/isci/scil/scic_sds_remote_device.h>
63 #include <dev/isci/scil/scic_sds_stp_request.h>
64 #include <dev/isci/scil/scic_sds_stp_pio_request.h>
65 #include <dev/isci/scil/scic_sds_logger.h>
66 #include <dev/isci/sci_environment.h>
67 #include <dev/isci/scil/sci_base_state_machine.h>
68 #include <dev/isci/scil/scu_task_context.h>
69 #include <dev/isci/scil/intel_ata.h>
70 #include <dev/isci/scil/sci_util.h>
71 #include <dev/isci/scil/scic_sds_logger.h>
72 #include <dev/isci/scil/scic_sds_request.h>
73 #include <dev/isci/scil/scic_sds_stp_request.h>
74 #include <dev/isci/scil/scu_completion_codes.h>
75 #include <dev/isci/scil/scu_event_codes.h>
76 #include <dev/isci/scil/sci_base_state.h>
77 #include <dev/isci/scil/scic_sds_unsolicited_frame_control.h>
78 #include <dev/isci/scil/scic_io_request.h>
79 
80 #if !defined(DISABLE_ATAPI)
81 #include <dev/isci/scil/scic_sds_stp_packet_request.h>
82 #endif
83 
84 /**
85  * This macro returns the address of the stp h2d reg fis buffer in the io
86  * request memory
87  */
88 #define scic_sds_stp_request_get_h2d_reg_buffer_unaligned(memory) \
89    ((SATA_FIS_REG_H2D_T *)( \
90       ((char *)(memory)) + sizeof(SCIC_SDS_STP_REQUEST_T) \
91    ))
92 
93 /**
94  * This macro aligns the stp command buffer in DWORD alignment
95 */
96 #define scic_sds_stp_request_align_h2d_reg_buffer(address) \
97    ((SATA_FIS_REG_H2D_T *)( \
98       (((POINTER_UINT)(address)) + (sizeof(U32) - 1)) \
99          & ~(sizeof(U32)- 1) \
100       ))
101 
102 /**
103  * This macro returns the DWORD-aligned stp command buffer
104 */
105 #define scic_sds_stp_request_get_h2d_reg_buffer(memory) \
106    ((SATA_FIS_REG_H2D_T *)  \
107        ((char *)scic_sds_stp_request_align_h2d_reg_buffer( \
108        (char *) scic_sds_stp_request_get_h2d_reg_buffer_unaligned(memory) \
109    )))
110 
111 /**
112  * This macro returns the address of the stp response buffer in the io
113  * request memory
114  */
115 #define scic_sds_stp_request_get_response_buffer_unaligned(memory) \
116    ((SATA_FIS_REG_D2H_T *)( \
117          ((char *)(scic_sds_stp_request_get_h2d_reg_buffer(memory))) \
118        + sizeof(SATA_FIS_REG_H2D_T) \
119    ))
120 
121 
122 /**
123  * This macro aligns the stp response buffer in DWORD alignment
124 */
125 #define scic_sds_stp_request_align_response_buffer(address) \
126    ((SATA_FIS_REG_D2H_T *)( \
127       (((POINTER_UINT)(address)) + (sizeof(U32) - 1)) \
128          & ~(sizeof(U32)- 1) \
129    ))
130 
131 /**
132  * This macro returns the DWORD-aligned stp response buffer
133 */
134 #define scic_sds_stp_request_get_response_buffer(memory) \
135    ((SATA_FIS_REG_D2H_T *)  \
136       ((char *)scic_sds_stp_request_align_response_buffer( \
137          (char *)scic_sds_stp_request_get_response_buffer_unaligned(memory) \
138    )))
139 
140 
141 /**
142  * This macro returns the address of the task context buffer in the io
143  * request memory
144  */
145 #define scic_sds_stp_request_get_task_context_buffer_unaligned(memory) \
146    ((SCU_TASK_CONTEXT_T *)( \
147         ((char *)(scic_sds_stp_request_get_response_buffer(memory))) \
148       + sizeof(SCI_SSP_RESPONSE_IU_T) \
149    ))
150 
151 /**
152  * This macro returns the aligned task context buffer
153  */
154 #define scic_sds_stp_request_get_task_context_buffer(memory) \
155    ((SCU_TASK_CONTEXT_T *)( \
156       ((char *)scic_sds_request_align_task_context_buffer( \
157          (char *)scic_sds_stp_request_get_task_context_buffer_unaligned(memory)) \
158     )))
159 
160 /**
161  * This macro returns the address of the sgl elment pairs in the io request
162  * memory buffer
163  */
164 #define scic_sds_stp_request_get_sgl_element_buffer(memory) \
165    ((SCU_SGL_ELEMENT_PAIR_T *)( \
166         ((char *)(scic_sds_stp_request_get_task_context_buffer(memory))) \
167       + sizeof(SCU_TASK_CONTEXT_T) \
168     ))
169 
170 
171 /**
172  * This method return the memory space commonly required for STP IO and
173  * task requests.
174  *
175  * @return U32
176  */
177 static
178 U32 scic_sds_stp_common_request_get_object_size(void)
179 {
180    return   sizeof(SCIC_SDS_STP_REQUEST_T)
181           + sizeof(SATA_FIS_REG_H2D_T)
182           + sizeof(U32)
183           + sizeof(SATA_FIS_REG_D2H_T)
184           + sizeof(U32)
185           + sizeof(SCU_TASK_CONTEXT_T)
186           + CACHE_LINE_SIZE;
187 }
188 
189 
190 /**
191  * This method return the memory space required for STP PIO requests.
192  *
193  * @return U32
194  */
195 U32 scic_sds_stp_request_get_object_size(void)
196 {
197    return   scic_sds_stp_common_request_get_object_size()
198           + sizeof(SCU_SGL_ELEMENT_PAIR_T) * SCU_MAX_SGL_ELEMENT_PAIRS;
199 }
200 
201 
202 /**
203  * This method return the memory space required for STP task requests.
204  *
205  * @return U32
206  */
207 U32 scic_sds_stp_task_request_get_object_size(void)
208 {
209    return scic_sds_stp_common_request_get_object_size();
210 }
211 
212 
213 /**
214  *
215  *
216  * @param[in] this_request
217  */
218 void scic_sds_stp_request_assign_buffers(
219    SCIC_SDS_REQUEST_T * request
220 )
221 {
222    SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
223 
224    this_request->parent.command_buffer =
225       scic_sds_stp_request_get_h2d_reg_buffer(this_request);
226    this_request->parent.response_buffer =
227       scic_sds_stp_request_get_response_buffer(this_request);
228    this_request->parent.sgl_element_pair_buffer =
229       scic_sds_stp_request_get_sgl_element_buffer(this_request);
230    this_request->parent.sgl_element_pair_buffer =
231       scic_sds_request_align_sgl_element_buffer(this_request->parent.sgl_element_pair_buffer);
232 
233    if (this_request->parent.was_tag_assigned_by_user == FALSE)
234    {
235       this_request->parent.task_context_buffer =
236          scic_sds_stp_request_get_task_context_buffer(this_request);
237    }
238 }
239 
240 /**
241  * @brief This method is will fill in the SCU Task Context for any type of
242  *        SATA request.  This is called from the various SATA constructors.
243  *
244  * @pre The general io request construction is complete.
245  * @pre The buffer assignment for the command buffer is complete.
246  *
247  * @param[in] this_request The general IO request object which is to be used
248  *       in constructing the SCU task context.
249  * @param[in] task_context The buffer pointer for the SCU task context which
250  *       is being constructed.
251  *
252  * @return none
253  *
254  * @todo Revisit task context construction to determine what is common for
255  *       SSP/SMP/STP task context structures.
256  */
257 void scu_sata_reqeust_construct_task_context(
258    SCIC_SDS_REQUEST_T * this_request,
259    SCU_TASK_CONTEXT_T * task_context
260 )
261 {
262    SCI_PHYSICAL_ADDRESS      physical_address;
263    SCIC_SDS_CONTROLLER_T    *owning_controller;
264    SCIC_SDS_REMOTE_DEVICE_T *target_device;
265    SCIC_SDS_PORT_T          *target_port;
266 
267    owning_controller = scic_sds_request_get_controller(this_request);
268    target_device = scic_sds_request_get_device(this_request);
269    target_port = scic_sds_request_get_port(this_request);
270 
271    // Fill in the TC with the its required data
272    task_context->abort = 0;
273    task_context->priority = SCU_TASK_PRIORITY_NORMAL;
274    task_context->initiator_request = 1;
275    task_context->connection_rate =
276       scic_remote_device_get_connection_rate(target_device);
277    task_context->protocol_engine_index =
278       scic_sds_controller_get_protocol_engine_group(owning_controller);
279    task_context->logical_port_index =
280       scic_sds_port_get_index(target_port);
281    task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_STP;
282    task_context->valid = SCU_TASK_CONTEXT_VALID;
283    task_context->context_type = SCU_TASK_CONTEXT_TYPE;
284 
285    task_context->remote_node_index =
286       scic_sds_remote_device_get_index(this_request->target_device);
287    task_context->command_code = 0;
288 
289    task_context->link_layer_control = 0;
290    task_context->do_not_dma_ssp_good_response = 1;
291    task_context->strict_ordering = 0;
292    task_context->control_frame = 0;
293    task_context->timeout_enable = 0;
294    task_context->block_guard_enable = 0;
295 
296    task_context->address_modifier = 0;
297    task_context->task_phase = 0x01;
298 
299    task_context->ssp_command_iu_length =
300       (sizeof(SATA_FIS_REG_H2D_T) - sizeof(U32)) / sizeof(U32);
301 
302    // Set the first word of the H2D REG FIS
303    task_context->type.words[0] = *(U32 *)this_request->command_buffer;
304 
305    if (this_request->was_tag_assigned_by_user)
306    {
307       // Build the task context now since we have already read the data
308       this_request->post_context = (
309            SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC
310          | (
311                 scic_sds_controller_get_protocol_engine_group(owning_controller)
312              << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT
313            )
314          | (
315                  scic_sds_port_get_index(target_port)
316               << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT
317            )
318          | scic_sds_io_tag_get_index(this_request->io_tag)
319       );
320    }
321    else
322    {
323       // Build the task context now since we have already read the data
324       this_request->post_context = (
325            SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC
326          | (
327                scic_sds_controller_get_protocol_engine_group(owning_controller)
328             << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT
329            )
330          | (
331                 scic_sds_port_get_index(target_port)
332              << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT
333            )
334          // This is not assigned because we have to wait until we get a TCi
335       );
336    }
337 
338    // Copy the physical address for the command buffer to the SCU Task Context
339    // We must offset the command buffer by 4 bytes because the first 4 bytes are
340    // transfered in the body of the TC
341    scic_cb_io_request_get_physical_address(
342       scic_sds_request_get_controller(this_request),
343       this_request,
344       ((char *)this_request->command_buffer) + sizeof(U32),
345       &physical_address
346    );
347 
348    task_context->command_iu_upper =
349       sci_cb_physical_address_upper(physical_address);
350    task_context->command_iu_lower =
351       sci_cb_physical_address_lower(physical_address);
352 
353    // SATA Requests do not have a response buffer
354    task_context->response_iu_upper = 0;
355    task_context->response_iu_lower = 0;
356 }
357 
358 /**
359  * This method will perform any general sata request construction.
360  *
361  * @todo What part of SATA IO request construction is general?
362  *
363  * @param[in] this_request
364  *
365  * @return none
366  */
367 void scic_sds_stp_non_ncq_request_construct(
368    SCIC_SDS_REQUEST_T * this_request
369 )
370 {
371    this_request->has_started_substate_machine = TRUE;
372 }
373 
374 /**
375  * This method will perform request construction common to all types of
376  * STP requests that are optimized by the silicon (i.e. UDMA, NCQ).
377  *
378  * @param[in,out] this_request This parameter specifies the request to be
379  *                constructed as an optimized request.
380  * @param[in] optimized_task_type This parameter specifies whether the
381  *            request is to be an UDMA request or a NCQ request.
382  *            - A value of 0 indicates UDMA.
383  *            - A value of 1 indicates NCQ.
384  *
385  * @return This method returns an indication as to whether the construction
386  *         was successful.
387  */
388 static
389 void scic_sds_stp_optimized_request_construct(
390    SCIC_SDS_REQUEST_T * this_request,
391    U8                   optimized_task_type,
392    U32                  transfer_length,
393    SCI_IO_REQUEST_DATA_DIRECTION data_direction
394 )
395 {
396    SCU_TASK_CONTEXT_T * task_context = this_request->task_context_buffer;
397 
398    // Build the STP task context structure
399    scu_sata_reqeust_construct_task_context(this_request, task_context);
400 
401    // Copy over the number of bytes to be transfered
402    task_context->transfer_length_bytes = transfer_length;
403 
404    if ( data_direction == SCI_IO_REQUEST_DATA_OUT )
405    {
406       // The difference between the DMA IN and DMA OUT request task type
407       // values are consistent with the difference between FPDMA READ
408       // and FPDMA WRITE values.  Add the supplied task type parameter
409       // to this difference to set the task type properly for this
410       // DATA OUT (WRITE) case.
411       task_context->task_type = optimized_task_type + (SCU_TASK_TYPE_DMA_OUT
412                                                      - SCU_TASK_TYPE_DMA_IN);
413    }
414    else
415    {
416       // For the DATA IN (READ) case, simply save the supplied
417       // optimized task type.
418       task_context->task_type = optimized_task_type;
419    }
420 }
421 
422 /**
423  * This method performs the operations common to all SATA/STP requests
424  * utilizing the raw frame method.
425  *
426  * @param[in] this_request This parameter specifies the STP request object
427  *            for which to construct a RAW command frame task context.
428  * @param[in] task_context This parameter specifies the SCU specific
429  *            task context buffer to construct.
430  *
431  * @return none
432  */
433 void scu_stp_raw_request_construct_task_context(
434    SCIC_SDS_STP_REQUEST_T * this_request,
435    SCU_TASK_CONTEXT_T     * task_context
436 )
437 {
438    scu_sata_reqeust_construct_task_context(&this_request->parent, task_context);
439 
440    task_context->control_frame         = 0;
441    task_context->priority              = SCU_TASK_PRIORITY_NORMAL;
442    task_context->task_type             = SCU_TASK_TYPE_SATA_RAW_FRAME;
443    task_context->type.stp.fis_type     = SATA_FIS_TYPE_REGH2D;
444    task_context->transfer_length_bytes = sizeof(SATA_FIS_REG_H2D_T) - sizeof(U32);
445 }
446 
447 /**
448  * This method will construct the STP Non-data request and its associated
449  * TC data.  A non-data request essentially behaves like a 0 length read
450  * request in the SCU.
451  *
452  * @param[in] this_request This parameter specifies the core request
453  *            object to construction into an STP/SATA non-data request.
454  *
455  * @return This method currently always returns SCI_SUCCESS
456  */
457 SCI_STATUS scic_sds_stp_non_data_request_construct(
458    SCIC_SDS_REQUEST_T * this_request
459 )
460 {
461    scic_sds_stp_non_ncq_request_construct(this_request);
462 
463    // Build the STP task context structure
464    scu_stp_raw_request_construct_task_context(
465       (SCIC_SDS_STP_REQUEST_T*) this_request,
466       this_request->task_context_buffer
467    );
468 
469    sci_base_state_machine_construct(
470       &this_request->started_substate_machine,
471       &this_request->parent.parent,
472       scic_sds_stp_request_started_non_data_substate_table,
473       SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
474    );
475 
476    return SCI_SUCCESS;
477 }
478 
479 
480 SCI_STATUS scic_sds_stp_soft_reset_request_construct(
481    SCIC_SDS_REQUEST_T * this_request
482 )
483 {
484    scic_sds_stp_non_ncq_request_construct(this_request);
485 
486    // Build the STP task context structure
487    scu_stp_raw_request_construct_task_context(
488       (SCIC_SDS_STP_REQUEST_T*) this_request,
489       this_request->task_context_buffer
490    );
491 
492    sci_base_state_machine_construct(
493       &this_request->started_substate_machine,
494       &this_request->parent.parent,
495       scic_sds_stp_request_started_soft_reset_substate_table,
496       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
497    );
498 
499    return SCI_SUCCESS;
500 }
501 
502 /**
503  * @brief This method constructs the SATA request object.
504  *
505  * @param[in] this_request
506  * @param[in] sat_protocol
507  * @param[in] transfer_length
508  * @param[in] data_direction
509  * @param[in] copy_rx_frame
510  * @param[in] do_translate_sgl This parameter specifies whether SGL
511  *            translation should be performed or if the user is handling
512  *            it.
513  *
514  * @return SCI_STATUS
515  */
516 SCI_STATUS scic_sds_io_request_construct_sata(
517    SCIC_SDS_REQUEST_T          * this_request,
518    U8                            sat_protocol,
519    U32                           transfer_length,
520    SCI_IO_REQUEST_DATA_DIRECTION data_direction,
521    BOOL                          copy_rx_frame,
522    BOOL                          do_translate_sgl
523 )
524 {
525    SCI_STATUS  status = SCI_SUCCESS;
526 
527    this_request->protocol = SCIC_STP_PROTOCOL;
528 
529    this_request->sat_protocol = sat_protocol;
530 
531    switch (sat_protocol)
532    {
533    case SAT_PROTOCOL_FPDMA:
534       scic_sds_stp_optimized_request_construct(
535          this_request,
536          SCU_TASK_TYPE_FPDMAQ_READ,
537          transfer_length,
538          data_direction
539       );
540 
541       // Copy over the SGL elements
542       if (do_translate_sgl == TRUE)
543          scic_sds_request_build_sgl(this_request);
544    break;
545 
546    case SAT_PROTOCOL_UDMA_DATA_IN:
547    case SAT_PROTOCOL_UDMA_DATA_OUT:
548       scic_sds_stp_non_ncq_request_construct(this_request);
549 
550       scic_sds_stp_optimized_request_construct(
551          this_request, SCU_TASK_TYPE_DMA_IN, transfer_length, data_direction
552       );
553 
554       // Copy over the SGL elements
555       if (do_translate_sgl == TRUE)
556          scic_sds_request_build_sgl(this_request);
557 
558       sci_base_state_machine_construct(
559          &this_request->started_substate_machine,
560          &this_request->parent.parent,
561          scic_sds_stp_request_started_udma_substate_table,
562          SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
563       );
564    break;
565 
566    case SAT_PROTOCOL_PIO_DATA_IN:
567    case SAT_PROTOCOL_PIO_DATA_OUT:
568       status = scic_sds_stp_pio_request_construct(
569                   this_request, sat_protocol, copy_rx_frame);
570    break;
571 
572    case SAT_PROTOCOL_ATA_HARD_RESET:
573    case SAT_PROTOCOL_SOFT_RESET:
574       status = scic_sds_stp_soft_reset_request_construct(this_request);
575    break;
576 
577    case SAT_PROTOCOL_NON_DATA:
578       status = scic_sds_stp_non_data_request_construct(this_request);
579    break;
580 
581 #if !defined(DISABLE_ATAPI)
582    case SAT_PROTOCOL_PACKET_NON_DATA:
583    case SAT_PROTOCOL_PACKET_DMA_DATA_IN:
584    case SAT_PROTOCOL_PACKET_DMA_DATA_OUT:
585    case SAT_PROTOCOL_PACKET_PIO_DATA_IN:
586    case SAT_PROTOCOL_PACKET_PIO_DATA_OUT:
587       status = scic_sds_stp_packet_request_construct(this_request);
588       if (do_translate_sgl == TRUE)
589          scic_sds_request_build_sgl(this_request);
590    break;
591 #endif
592 
593    case SAT_PROTOCOL_DMA_QUEUED:
594    case SAT_PROTOCOL_DMA:
595    case SAT_PROTOCOL_DEVICE_DIAGNOSTIC:
596    case SAT_PROTOCOL_DEVICE_RESET:
597    case SAT_PROTOCOL_RETURN_RESPONSE_INFO:
598    default:
599       SCIC_LOG_ERROR((
600          sci_base_object_get_logger(this_request),
601          SCIC_LOG_OBJECT_STP_IO_REQUEST,
602          "SCIC IO Request 0x%x received un-handled SAT Protocol %d.\n",
603          this_request, sat_protocol
604       ));
605 
606       status = SCI_FAILURE;
607    break;
608    }
609 
610    if (status == SCI_SUCCESS)
611    {
612       scic_sds_request_initialize_state_logging(this_request);
613 
614       sci_base_state_machine_change_state(
615          &this_request->parent.state_machine,
616          SCI_BASE_REQUEST_STATE_CONSTRUCTED
617       );
618    }
619 
620    return status;
621 }
622 
623 //****************************************************************************
624 //* SCIC Interface Implementation
625 //****************************************************************************
626 
627 void scic_stp_io_request_set_ncq_tag(
628    SCI_IO_REQUEST_HANDLE_T  scic_io_request,
629    U16                      ncq_tag
630 )
631 {
632    /**
633     * @note This could be made to return an error to the user if the user
634     *       attempts to set the NCQ tag in the wrong state.
635     */
636    SCIC_SDS_REQUEST_T * this_request = (SCIC_SDS_REQUEST_T *)scic_io_request;
637    this_request->task_context_buffer->type.stp.ncq_tag = ncq_tag;
638 }
639 
640 // ---------------------------------------------------------------------------
641 
642 void * scic_stp_io_request_get_h2d_reg_address(
643    SCI_IO_REQUEST_HANDLE_T  scic_io_request
644 )
645 {
646    SCIC_SDS_REQUEST_T * this_request = (SCIC_SDS_REQUEST_T *)scic_io_request;
647 
648    return this_request->command_buffer;
649 }
650 
651 // ---------------------------------------------------------------------------
652 
653 void * scic_stp_io_request_get_d2h_reg_address(
654    SCI_IO_REQUEST_HANDLE_T  scic_io_request
655 )
656 {
657    SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)scic_io_request;
658 
659    return &this_request->d2h_reg_fis;
660 }
661 
662 /**
663  * Get the next SGL element from the request.
664  *    - Check on which SGL element pair we are working
665  *    - if working on SLG pair element A
666  *       - advance to element B
667  *    - else
668  *       - check to see if there are more SGL element pairs
669  *           for this IO request
670  *       - if there are more SGL element pairs
671  *          - advance to the next pair and return element A
672  *
673  * @param[in] this_request
674  *
675  * @return SCU_SGL_ELEMENT_T*
676  */
677 SCU_SGL_ELEMENT_T * scic_sds_stp_request_pio_get_next_sgl(
678    SCIC_SDS_STP_REQUEST_T * this_request
679 )
680 {
681    SCU_SGL_ELEMENT_T * current_sgl;
682 
683    if (this_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
684    {
685       if (
686             (this_request->type.pio.request_current.sgl_pair->B.address_lower == 0)
687          && (this_request->type.pio.request_current.sgl_pair->B.address_upper == 0)
688          )
689       {
690          current_sgl = NULL;
691       }
692       else
693       {
694          this_request->type.pio.request_current.sgl_set = SCU_SGL_ELEMENT_PAIR_B;
695          current_sgl = &(this_request->type.pio.request_current.sgl_pair->B);
696       }
697    }
698    else
699    {
700       if (
701             (this_request->type.pio.request_current.sgl_pair->next_pair_lower == 0)
702          && (this_request->type.pio.request_current.sgl_pair->next_pair_upper == 0)
703          )
704       {
705          current_sgl = NULL;
706       }
707       else
708       {
709          this_request->type.pio.request_current.sgl_pair =
710             scic_sds_request_get_sgl_element_pair(
711                &(this_request->parent),
712                ++this_request->type.pio.sgl_pair_index
713             );
714 
715          this_request->type.pio.request_current.sgl_set = SCU_SGL_ELEMENT_PAIR_A;
716 
717          current_sgl = &(this_request->type.pio.request_current.sgl_pair->A);
718       }
719    }
720 
721    return current_sgl;
722 }
723 
724 /**
725  * This method will construct the SATA PIO request.
726  *
727  * @param[in] scic_io_request The core request object which is cast to a SATA
728  *            PIO request object.
729  *
730  * @return This method returns an indication as to whether the construction
731  *         was successful.
732  * @retval SCI_SUCCESS Currently this method always returns this value.
733  */
734 SCI_STATUS scic_sds_stp_pio_request_construct(
735    SCIC_SDS_REQUEST_T  * scic_io_request,
736    U8                    sat_protocol,
737    BOOL                  copy_rx_frame
738 )
739 {
740    SCIC_SDS_STP_REQUEST_T * this_request;
741 
742    this_request = (SCIC_SDS_STP_REQUEST_T *)scic_io_request;
743 
744    scic_sds_stp_non_ncq_request_construct(&this_request->parent);
745 
746    scu_stp_raw_request_construct_task_context(
747       this_request, this_request->parent.task_context_buffer
748    );
749 
750    this_request->type.pio.current_transfer_bytes = 0;
751    this_request->type.pio.ending_error = 0;
752    this_request->type.pio.ending_status = 0;
753 
754    this_request->type.pio.request_current.sgl_offset = 0;
755    this_request->type.pio.request_current.sgl_set = SCU_SGL_ELEMENT_PAIR_A;
756    this_request->type.pio.sat_protocol = sat_protocol;
757    this_request->type.pio.sgl_pair_index = 0;
758 
759    if ((copy_rx_frame) || (sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT))
760    {
761       scic_sds_request_build_sgl(&this_request->parent);
762       // Since the IO request copy of the TC contains the same data as
763       // the actual TC this pointer is vaild for either.
764       this_request->type.pio.request_current.sgl_pair =
765          &this_request->parent.task_context_buffer->sgl_pair_ab;
766    }
767    else
768    {
769       // The user does not want the data copied to the SGL buffer location
770       this_request->type.pio.request_current.sgl_pair = NULL;
771    }
772 
773    sci_base_state_machine_construct(
774       &this_request->parent.started_substate_machine,
775       &this_request->parent.parent.parent,
776       scic_sds_stp_request_started_pio_substate_table,
777       SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
778    );
779 
780    return SCI_SUCCESS;
781 }
782 
783 //******************************************************************************
784 //* STP NON-DATA STATE MACHINE
785 //******************************************************************************
786 
787 /**
788  * This method processes a TC completion.  The expected TC completion is
789  * for the transmission of the H2D register FIS containing the SATA/STP
790  * non-data request.
791  *
792  * @param[in] this_request
793  * @param[in] completion_code
794  *
795  * @return This method always successfully processes the TC completion.
796  * @retval SCI_SUCCESS This value is always returned.
797  */
798 static
799 SCI_STATUS scic_sds_stp_request_non_data_await_h2d_tc_completion_handler(
800    SCIC_SDS_REQUEST_T * this_request,
801    U32                  completion_code
802 )
803 {
804    SCIC_LOG_TRACE((
805       sci_base_object_get_logger(this_request),
806       SCIC_LOG_OBJECT_STP_IO_REQUEST,
807       "scic_sds_stp_request_non_data_await_h2d_tc_completion_handler(0x%x, 0x%x) enter\n",
808       this_request, completion_code
809    ));
810 
811    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
812    {
813    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
814       scic_sds_request_set_status(
815          this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
816       );
817 
818       sci_base_state_machine_change_state(
819          &this_request->started_substate_machine,
820          SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
821       );
822       break;
823 
824    default:
825       // All other completion status cause the IO to be complete.  If a NAK
826       // was received, then it is up to the user to retry the request.
827       scic_sds_request_set_status(
828          this_request,
829          SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
830          SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
831       );
832 
833       sci_base_state_machine_change_state(
834          &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED
835       );
836       break;
837    }
838 
839    return SCI_SUCCESS;
840 }
841 
842 /**
843  * This method processes frames received from the target while waiting
844  * for a device to host register FIS.  If a non-register FIS is received
845  * during this time, it is treated as a protocol violation from an
846  * IO perspective.
847  *
848  * @param[in] request This parameter specifies the request for which a
849  *            frame has been received.
850  * @param[in] frame_index This parameter specifies the index of the frame
851  *            that has been received.
852  *
853  * @return Indicate if the received frame was processed successfully.
854  */
855 static
856 SCI_STATUS scic_sds_stp_request_non_data_await_d2h_frame_handler(
857    SCIC_SDS_REQUEST_T * request,
858    U32                  frame_index
859 )
860 {
861    SCI_STATUS               status;
862    SATA_FIS_HEADER_T      * frame_header;
863    U32                    * frame_buffer;
864    SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
865 
866    // Save off the controller, so that we do not touch the request after it
867    //  is completed.
868    SCIC_SDS_CONTROLLER_T  * owning_controller = this_request->parent.owning_controller;
869 
870    SCIC_LOG_TRACE((
871       sci_base_object_get_logger(this_request),
872       SCIC_LOG_OBJECT_STP_IO_REQUEST,
873       "scic_sds_stp_request_non_data_await_d2h_frame_handler(0x%x, 0x%x) enter\n",
874       this_request, frame_index
875    ));
876 
877    status = scic_sds_unsolicited_frame_control_get_header(
878                &(owning_controller->uf_control),
879                frame_index,
880                (void**) &frame_header
881             );
882 
883    if (status == SCI_SUCCESS)
884    {
885       switch (frame_header->fis_type)
886       {
887       case SATA_FIS_TYPE_REGD2H:
888          scic_sds_unsolicited_frame_control_get_buffer(
889             &(owning_controller->uf_control),
890             frame_index,
891             (void**) &frame_buffer
892          );
893 
894          scic_sds_controller_copy_sata_response(
895             &this_request->d2h_reg_fis, (U32 *)frame_header, frame_buffer
896          );
897 
898          // The command has completed with error
899          scic_sds_request_set_status(
900             &this_request->parent,
901             SCU_TASK_DONE_CHECK_RESPONSE,
902             SCI_FAILURE_IO_RESPONSE_VALID
903          );
904          break;
905 
906       default:
907          SCIC_LOG_WARNING((
908             sci_base_object_get_logger(this_request),
909             SCIC_LOG_OBJECT_STP_IO_REQUEST,
910             "IO Request:0x%x Frame Id:%d protocol violation occurred\n",
911             this_request, frame_index
912          ));
913 
914          scic_sds_request_set_status(
915             &this_request->parent,
916             SCU_TASK_DONE_UNEXP_FIS,
917             SCI_FAILURE_PROTOCOL_VIOLATION
918          );
919          break;
920       }
921 
922       sci_base_state_machine_change_state(
923          &this_request->parent.parent.state_machine,
924          SCI_BASE_REQUEST_STATE_COMPLETED
925       );
926 
927       // Frame has been decoded return it to the controller
928       scic_sds_controller_release_frame(
929          owning_controller, frame_index
930       );
931    }
932    else
933    {
934       SCIC_LOG_ERROR((
935          sci_base_object_get_logger(this_request),
936          SCIC_LOG_OBJECT_STP_IO_REQUEST,
937          "SCIC IO Request 0x%x could not get frame header for frame index %d, status %x\n",
938          this_request, frame_index, status
939       ));
940    }
941 
942    return status;
943 }
944 
945 // ---------------------------------------------------------------------------
946 
947 SCIC_SDS_IO_REQUEST_STATE_HANDLER_T
948    scic_sds_stp_request_started_non_data_substate_handler_table
949       [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_MAX_SUBSTATES] =
950 {
951    // SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
952    {
953       {
954          scic_sds_request_default_start_handler,
955          scic_sds_request_started_state_abort_handler,
956          scic_sds_request_default_complete_handler,
957          scic_sds_request_default_destruct_handler
958       },
959       scic_sds_stp_request_non_data_await_h2d_tc_completion_handler,
960       scic_sds_request_default_event_handler,
961       scic_sds_request_default_frame_handler
962    },
963    // SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
964    {
965       {
966          scic_sds_request_default_start_handler,
967          scic_sds_request_started_state_abort_handler,
968          scic_sds_request_default_complete_handler,
969          scic_sds_request_default_destruct_handler
970       },
971       scic_sds_request_default_tc_completion_handler,
972       scic_sds_request_default_event_handler,
973       scic_sds_stp_request_non_data_await_d2h_frame_handler
974    }
975 };
976 
977 static
978 void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(
979    SCI_BASE_OBJECT_T *object
980 )
981 {
982    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
983 
984    SET_STATE_HANDLER(
985       this_request,
986       scic_sds_stp_request_started_non_data_substate_handler_table,
987       SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
988    );
989 
990    scic_sds_remote_device_set_working_request(
991       this_request->target_device, this_request
992    );
993 }
994 
995 static
996 void scic_sds_stp_request_started_non_data_await_d2h_enter(
997    SCI_BASE_OBJECT_T *object
998 )
999 {
1000    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
1001 
1002    SET_STATE_HANDLER(
1003       this_request,
1004       scic_sds_stp_request_started_non_data_substate_handler_table,
1005       SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
1006    );
1007 }
1008 
1009 // ---------------------------------------------------------------------------
1010 
1011 SCI_BASE_STATE_T scic_sds_stp_request_started_non_data_substate_table
1012 [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_MAX_SUBSTATES] =
1013 {
1014    {
1015       SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE,
1016       scic_sds_stp_request_started_non_data_await_h2d_completion_enter,
1017       NULL
1018    },
1019    {
1020       SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE,
1021       scic_sds_stp_request_started_non_data_await_d2h_enter,
1022       NULL
1023    }
1024 };
1025 
1026 //******************************************************************************
1027 //* STP PIO STATE MACHINE
1028 //******************************************************************************
1029 
1030 #define SCU_MAX_FRAME_BUFFER_SIZE  0x400  // 1K is the maximum SCU frame data payload
1031 
1032 /**
1033  * This function will transmit DATA_FIS from (current sgl + offset) for input parameter length.
1034  * current sgl and offset is alreay stored in the IO request
1035  *
1036  * @param[in] this_request
1037  * @param[in] length
1038  *
1039  * @return SCI_STATUS
1040  */
1041 static
1042 SCI_STATUS scic_sds_stp_request_pio_data_out_trasmit_data_frame (
1043    SCIC_SDS_REQUEST_T * this_request,
1044    U32                  length
1045 )
1046 {
1047    SCI_STATUS status = SCI_SUCCESS;
1048    SCU_SGL_ELEMENT_T *  current_sgl;
1049    SCIC_SDS_STP_REQUEST_T * this_sds_stp_request = (SCIC_SDS_STP_REQUEST_T *)this_request;
1050 
1051    // Recycle the TC and reconstruct it for sending out DATA FIS containing
1052    // for the data from current_sgl+offset for the input length
1053    SCU_TASK_CONTEXT_T * task_context = scic_sds_controller_get_task_context_buffer(
1054                                           this_request->owning_controller,
1055                                           this_request->io_tag
1056                                        );
1057 
1058    if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
1059    {
1060       current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
1061    }
1062    else
1063    {
1064       current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
1065    }
1066 
1067    //update the TC
1068    task_context->command_iu_upper = current_sgl->address_upper;
1069    task_context->command_iu_lower = current_sgl->address_lower;
1070    task_context->transfer_length_bytes = length;
1071    task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
1072 
1073    // send the new TC out.
1074    status = this_request->owning_controller->state_handlers->parent.continue_io_handler(
1075       &this_request->owning_controller->parent,
1076       &this_request->target_device->parent,
1077       &this_request->parent
1078    );
1079 
1080    return status;
1081 
1082 }
1083 
1084 /**
1085  *
1086  *
1087  * @param[in] this_request
1088  *
1089  * @return SCI_STATUS
1090  */
1091 static
1092 SCI_STATUS scic_sds_stp_request_pio_data_out_transmit_data(
1093    SCIC_SDS_REQUEST_T * this_sds_request
1094 )
1095 {
1096 
1097    SCU_SGL_ELEMENT_T *  current_sgl;
1098    U32                  sgl_offset;
1099    U32                  remaining_bytes_in_current_sgl = 0;
1100    SCI_STATUS           status = SCI_SUCCESS;
1101 
1102    SCIC_SDS_STP_REQUEST_T * this_sds_stp_request = (SCIC_SDS_STP_REQUEST_T *)this_sds_request;
1103 
1104    sgl_offset = this_sds_stp_request->type.pio.request_current.sgl_offset;
1105 
1106    if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
1107    {
1108       current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
1109       remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->A.length - sgl_offset;
1110    }
1111    else
1112    {
1113       current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
1114       remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->B.length - sgl_offset;
1115    }
1116 
1117 
1118    if (this_sds_stp_request->type.pio.pio_transfer_bytes > 0)
1119    {
1120       if (this_sds_stp_request->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl )
1121       {
1122          //recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = remaining_bytes_in_current_sgl
1123          status = scic_sds_stp_request_pio_data_out_trasmit_data_frame (this_sds_request, remaining_bytes_in_current_sgl);
1124          if (status == SCI_SUCCESS)
1125          {
1126             this_sds_stp_request->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
1127             sgl_offset = 0;
1128          }
1129       }
1130       else if (this_sds_stp_request->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl )
1131       {
1132          //recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = type.pio.pio_transfer_bytes
1133          scic_sds_stp_request_pio_data_out_trasmit_data_frame (this_sds_request, this_sds_stp_request->type.pio.pio_transfer_bytes);
1134 
1135          if (status == SCI_SUCCESS)
1136          {
1137             //Sgl offset will be adjusted and saved for future
1138             sgl_offset += this_sds_stp_request->type.pio.pio_transfer_bytes;
1139             current_sgl->address_lower += this_sds_stp_request->type.pio.pio_transfer_bytes;
1140             this_sds_stp_request->type.pio.pio_transfer_bytes = 0;
1141          }
1142       }
1143    }
1144 
1145    if (status == SCI_SUCCESS)
1146    {
1147       this_sds_stp_request->type.pio.request_current.sgl_offset = sgl_offset;
1148    }
1149 
1150    return status;
1151 }
1152 
1153 /**
1154  * Copy the data from the buffer for the length specified to the IO reqeust
1155  * SGL specified data region.
1156  *
1157  * @param[in] this_request The request that is used for the SGL processing.
1158  * @param[in] data_buffer The buffer of data to be copied.
1159  * @param[in] length  The length of the data transfer.
1160  *
1161  * @return SCI_STATUS
1162  */
1163 static
1164 SCI_STATUS scic_sds_stp_request_pio_data_in_copy_data_buffer(
1165    SCIC_SDS_STP_REQUEST_T * this_request,
1166    U8                     * data_buffer,
1167    U32                      length
1168 )
1169 {
1170    SCI_STATUS          status;
1171    SCU_SGL_ELEMENT_T * current_sgl;
1172    U32                 sgl_offset;
1173    U32                 data_offset;
1174    U8                * source_address;
1175 
1176    // Initial setup to get the current working SGL and the offset within the buffer
1177    current_sgl =
1178       (this_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) ?
1179          &(this_request->type.pio.request_current.sgl_pair->A) :
1180          &(this_request->type.pio.request_current.sgl_pair->B) ;
1181 
1182    sgl_offset = this_request->type.pio.request_current.sgl_offset;
1183 
1184    source_address = data_buffer;
1185    data_offset = this_request->type.pio.current_transfer_bytes;
1186    status = SCI_SUCCESS;
1187 
1188    // While we are still doing Ok and there is more data to transfer
1189    while (
1190             (length > 0)
1191          && (status == SCI_SUCCESS)
1192          )
1193    {
1194       if (current_sgl->length == sgl_offset)
1195       {
1196          // This SGL has been exauhasted so we need to get the next SGL
1197          current_sgl = scic_sds_stp_request_pio_get_next_sgl(this_request);
1198 
1199          if (current_sgl == NULL)
1200             status = SCI_FAILURE;
1201          else
1202             sgl_offset = 0;
1203       }
1204       else
1205       {
1206 #ifdef ENABLE_OSSL_COPY_BUFFER
1207          scic_cb_io_request_copy_buffer(this_request, data_buffer, data_offset, length);
1208          length = 0;
1209 #else
1210          U8 * destination_address;
1211          U32  copy_length;
1212 
1213          destination_address = (U8 *)scic_cb_io_request_get_virtual_address_from_sgl(
1214             this_request,
1215             data_offset
1216          );
1217 
1218          copy_length = MIN(length, current_sgl->length - sgl_offset);
1219 
1220          memcpy(destination_address, source_address, copy_length);
1221 
1222          length -= copy_length;
1223          sgl_offset += copy_length;
1224          data_offset += copy_length;
1225 #endif
1226       }
1227    }
1228 
1229    this_request->type.pio.request_current.sgl_offset = sgl_offset;
1230 
1231    return status;
1232 }
1233 
1234 /**
1235  * Copy the data buffer to the io request data region.
1236  *
1237  * @param[in] this_request The PIO DATA IN request that is to receive the
1238  *       data.
1239  * @param[in] data_buffer The buffer to copy from.
1240  *
1241  * @return SCI_STATUS
1242  */
1243 static
1244 SCI_STATUS scic_sds_stp_request_pio_data_in_copy_data(
1245    SCIC_SDS_STP_REQUEST_T * this_request,
1246    U8                     * data_buffer
1247 )
1248 {
1249    SCI_STATUS status;
1250 
1251    // If there is less than 1K remaining in the transfer request
1252    // copy just the data for the transfer
1253    if (this_request->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE)
1254    {
1255       status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
1256          this_request,data_buffer,this_request->type.pio.pio_transfer_bytes);
1257 
1258       if (status == SCI_SUCCESS)
1259       {
1260          // All data for this PIO request has now been copied, so we don't
1261          //  technically need to update current_transfer_bytes here - just
1262          //  doing it for completeness.
1263          this_request->type.pio.current_transfer_bytes += this_request->type.pio.pio_transfer_bytes;
1264          this_request->type.pio.pio_transfer_bytes = 0;
1265       }
1266    }
1267    else
1268    {
1269       // We are transfering the whole frame so copy
1270       status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
1271          this_request, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
1272 
1273       if (status == SCI_SUCCESS)
1274       {
1275          this_request->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
1276          this_request->type.pio.current_transfer_bytes += SCU_MAX_FRAME_BUFFER_SIZE;
1277       }
1278    }
1279 
1280    return status;
1281 }
1282 
1283 /**
1284  *
1285  *
1286  * @param[in] this_request
1287  * @param[in] completion_code
1288  *
1289  * @return SCI_STATUS
1290  */
1291 static
1292 SCI_STATUS scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler(
1293    SCIC_SDS_REQUEST_T * this_request,
1294    U32                  completion_code
1295 )
1296 {
1297    SCI_STATUS status = SCI_SUCCESS;
1298 
1299    SCIC_LOG_TRACE((
1300       sci_base_object_get_logger(this_request),
1301       SCIC_LOG_OBJECT_STP_IO_REQUEST,
1302       "scic_sds_stp_request_pio_data_in_await_h2d_completion_tc_completion_handler(0x%x, 0x%x) enter\n",
1303       this_request, completion_code
1304    ));
1305 
1306    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
1307    {
1308    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1309       scic_sds_request_set_status(
1310          this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
1311       );
1312 
1313       sci_base_state_machine_change_state(
1314          &this_request->started_substate_machine,
1315          SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1316       );
1317       break;
1318 
1319    default:
1320       // All other completion status cause the IO to be complete.  If a NAK
1321       // was received, then it is up to the user to retry the request.
1322       scic_sds_request_set_status(
1323          this_request,
1324          SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1325          SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
1326       );
1327 
1328       sci_base_state_machine_change_state(
1329          &this_request->parent.state_machine,
1330          SCI_BASE_REQUEST_STATE_COMPLETED
1331       );
1332       break;
1333    }
1334 
1335    return status;
1336 }
1337 
1338 /**
1339  *
1340  *
1341  * @param[in] this_request
1342  * @param[in] frame_index
1343  *
1344  * @return SCI_STATUS
1345  */
1346 static
1347 SCI_STATUS scic_sds_stp_request_pio_await_frame_frame_handler(
1348    SCIC_SDS_REQUEST_T * request,
1349    U32                  frame_index
1350 )
1351 {
1352    SCI_STATUS               status;
1353    SATA_FIS_HEADER_T      * frame_header;
1354    U32                    * frame_buffer;
1355    SCIC_SDS_STP_REQUEST_T * this_request;
1356    SCIC_SDS_CONTROLLER_T  * owning_controller;
1357 
1358    this_request = (SCIC_SDS_STP_REQUEST_T *)request;
1359 
1360    // Save off the controller, so that we do not touch the request after it
1361    //  is completed.
1362    owning_controller = this_request->parent.owning_controller;
1363 
1364    SCIC_LOG_TRACE((
1365       sci_base_object_get_logger(this_request),
1366       SCIC_LOG_OBJECT_STP_IO_REQUEST,
1367       "scic_sds_stp_request_pio_data_in_await_frame_frame_handler(0x%x, 0x%x) enter\n",
1368       this_request, frame_index
1369    ));
1370 
1371    status = scic_sds_unsolicited_frame_control_get_header(
1372       &(owning_controller->uf_control),
1373       frame_index,
1374       (void**) &frame_header
1375    );
1376 
1377    if (status == SCI_SUCCESS)
1378    {
1379       switch (frame_header->fis_type)
1380       {
1381       case SATA_FIS_TYPE_PIO_SETUP:
1382          // Get from the frame buffer the PIO Setup Data
1383          scic_sds_unsolicited_frame_control_get_buffer(
1384             &(owning_controller->uf_control),
1385             frame_index,
1386             (void**) &frame_buffer
1387          );
1388 
1389          // Get the data from the PIO Setup
1390          // The SCU Hardware returns first word in the frame_header and the rest
1391          // of the data is in the frame buffer so we need to back up one dword
1392          this_request->type.pio.pio_transfer_bytes =
1393             (U16)((SATA_FIS_PIO_SETUP_T *)(&frame_buffer[-1]))->transfter_count;
1394          this_request->type.pio.ending_status =
1395             (U8)((SATA_FIS_PIO_SETUP_T *)(&frame_buffer[-1]))->ending_status;
1396 
1397          scic_sds_controller_copy_sata_response(
1398             &this_request->d2h_reg_fis, (U32 *)frame_header, frame_buffer
1399          );
1400 
1401          this_request->d2h_reg_fis.status =
1402             this_request->type.pio.ending_status;
1403 
1404          //The next state is dependent on whether the request was PIO Data-in or Data out
1405          if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_IN)
1406          {
1407          sci_base_state_machine_change_state(
1408             &this_request->parent.started_substate_machine,
1409             SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
1410             );
1411          }
1412          else if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT)
1413          {
1414             //Transmit data
1415             status = scic_sds_stp_request_pio_data_out_transmit_data ( request);
1416             if (status == SCI_SUCCESS)
1417             {
1418                sci_base_state_machine_change_state(
1419                   &this_request->parent.started_substate_machine,
1420                   SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
1421                );
1422             }
1423          }
1424       break;
1425 
1426       case SATA_FIS_TYPE_SETDEVBITS:
1427          sci_base_state_machine_change_state(
1428             &this_request->parent.started_substate_machine,
1429             SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1430             );
1431       break;
1432 
1433       case SATA_FIS_TYPE_REGD2H:
1434          if ( (frame_header->status & ATA_STATUS_REG_BSY_BIT) == 0)
1435          {
1436             scic_sds_unsolicited_frame_control_get_buffer(
1437                &(owning_controller->uf_control),
1438                frame_index,
1439                (void**) &frame_buffer
1440             );
1441 
1442             scic_sds_controller_copy_sata_response(
1443                &this_request->d2h_reg_fis, (U32 *)frame_header, frame_buffer);
1444 
1445             scic_sds_request_set_status(
1446                &this_request->parent,
1447                SCU_TASK_DONE_CHECK_RESPONSE,
1448                SCI_FAILURE_IO_RESPONSE_VALID
1449             );
1450 
1451             sci_base_state_machine_change_state(
1452                &this_request->parent.parent.state_machine,
1453                SCI_BASE_REQUEST_STATE_COMPLETED
1454             );
1455          }
1456          else
1457          {
1458             // Now why is the drive sending a D2H Register FIS when it is still busy?
1459             // Do nothing since we are still in the right state.
1460             SCIC_LOG_INFO((
1461                sci_base_object_get_logger(this_request),
1462                SCIC_LOG_OBJECT_STP_IO_REQUEST,
1463                "SCIC PIO Request 0x%x received D2H Register FIS with BSY status 0x%x\n",
1464                this_request, frame_header->status
1465             ));
1466          }
1467          break;
1468 
1469          default:
1470          break;
1471          }
1472 
1473       // Frame is decoded return it to the controller
1474       scic_sds_controller_release_frame(
1475          owning_controller,
1476          frame_index
1477       );
1478    }
1479    else
1480    {
1481       SCIC_LOG_ERROR((
1482          sci_base_object_get_logger(this_request),
1483          SCIC_LOG_OBJECT_STP_IO_REQUEST,
1484          "SCIC IO Request 0x%x could not get frame header for frame index %d, status %x\n",
1485          this_request, frame_index, status
1486       ));
1487    }
1488 
1489    return status;
1490 }
1491 
1492 /**
1493  *
1494  *
1495  * @param[in] this_request
1496  * @param[in] frame_index
1497  *
1498  * @return SCI_STATUS
1499  */
1500 static
1501 SCI_STATUS scic_sds_stp_request_pio_data_in_await_data_frame_handler(
1502    SCIC_SDS_REQUEST_T * request,
1503    U32                  frame_index
1504 )
1505 {
1506    SCI_STATUS               status;
1507    SATA_FIS_HEADER_T      * frame_header;
1508    SATA_FIS_DATA_T        * frame_buffer;
1509    SCIC_SDS_STP_REQUEST_T * this_request;
1510    SCIC_SDS_CONTROLLER_T  * owning_controller;
1511 
1512    this_request = (SCIC_SDS_STP_REQUEST_T *)request;
1513 
1514    // Save off the controller, so that we do not touch the request after it
1515    //  is completed.
1516    owning_controller = this_request->parent.owning_controller;
1517 
1518    SCIC_LOG_TRACE((
1519       sci_base_object_get_logger(this_request),
1520       SCIC_LOG_OBJECT_STP_IO_REQUEST,
1521       "scic_sds_stp_request_pio_data_in_await_data_frame_handler(0x%x, 0x%x) enter\n",
1522       this_request, frame_index
1523    ));
1524 
1525    status = scic_sds_unsolicited_frame_control_get_header(
1526       &(owning_controller->uf_control),
1527       frame_index,
1528       (void**) &frame_header
1529    );
1530 
1531    if (status == SCI_SUCCESS)
1532    {
1533       if (frame_header->fis_type == SATA_FIS_TYPE_DATA)
1534       {
1535          if (this_request->type.pio.request_current.sgl_pair == NULL)
1536          {
1537             this_request->parent.saved_rx_frame_index = frame_index;
1538             this_request->type.pio.pio_transfer_bytes = 0;
1539          }
1540          else
1541          {
1542             status = scic_sds_unsolicited_frame_control_get_buffer(
1543                &(owning_controller->uf_control),
1544                frame_index,
1545                (void**) &frame_buffer
1546             );
1547 
1548             status = scic_sds_stp_request_pio_data_in_copy_data(this_request, (U8 *)frame_buffer);
1549 
1550             // Frame is decoded return it to the controller
1551             scic_sds_controller_release_frame(
1552                owning_controller,
1553                frame_index
1554             );
1555          }
1556 
1557          // Check for the end of the transfer, are there more bytes remaining
1558          // for this data transfer
1559          if (
1560                (status == SCI_SUCCESS)
1561             && (this_request->type.pio.pio_transfer_bytes == 0)
1562             )
1563          {
1564             if ((this_request->type.pio.ending_status & ATA_STATUS_REG_BSY_BIT) == 0)
1565             {
1566                scic_sds_request_set_status(
1567                   &this_request->parent,
1568                   SCU_TASK_DONE_CHECK_RESPONSE,
1569                   SCI_FAILURE_IO_RESPONSE_VALID
1570                );
1571 
1572                sci_base_state_machine_change_state(
1573                   &this_request->parent.parent.state_machine,
1574                   SCI_BASE_REQUEST_STATE_COMPLETED
1575                );
1576             }
1577             else
1578             {
1579                sci_base_state_machine_change_state(
1580                   &this_request->parent.started_substate_machine,
1581                   SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1582                );
1583             }
1584          }
1585       }
1586       else
1587       {
1588          SCIC_LOG_ERROR((
1589             sci_base_object_get_logger(this_request),
1590             SCIC_LOG_OBJECT_STP_IO_REQUEST,
1591             "SCIC PIO Request 0x%x received frame %d with fis type 0x%02x when expecting a data fis.\n",
1592             this_request, frame_index, frame_header->fis_type
1593          ));
1594 
1595          scic_sds_request_set_status(
1596             &this_request->parent,
1597             SCU_TASK_DONE_GOOD,
1598             SCI_FAILURE_IO_REQUIRES_SCSI_ABORT
1599          );
1600 
1601          sci_base_state_machine_change_state(
1602             &this_request->parent.parent.state_machine,
1603             SCI_BASE_REQUEST_STATE_COMPLETED
1604          );
1605 
1606          // Frame is decoded return it to the controller
1607          scic_sds_controller_release_frame(
1608             owning_controller,
1609             frame_index
1610          );
1611       }
1612    }
1613    else
1614    {
1615       SCIC_LOG_ERROR((
1616          sci_base_object_get_logger(this_request),
1617          SCIC_LOG_OBJECT_STP_IO_REQUEST,
1618          "SCIC IO Request 0x%x could not get frame header for frame index %d, status %x\n",
1619          this_request, frame_index, status
1620       ));
1621    }
1622 
1623    return status;
1624 }
1625 
1626 
1627 /**
1628  *
1629  *
1630  * @param[in] this_request
1631  * @param[in] completion_code
1632  *
1633  * @return SCI_STATUS
1634  */
1635 static
1636 SCI_STATUS scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler(
1637 
1638    SCIC_SDS_REQUEST_T * this_request,
1639    U32                  completion_code
1640 )
1641 {
1642    SCI_STATUS  status                     = SCI_SUCCESS;
1643    BOOL        all_frames_transferred     = FALSE;
1644 
1645    SCIC_SDS_STP_REQUEST_T *this_scic_sds_stp_request = (SCIC_SDS_STP_REQUEST_T *) this_request;
1646 
1647    SCIC_LOG_TRACE((
1648       sci_base_object_get_logger(this_request),
1649       SCIC_LOG_OBJECT_STP_IO_REQUEST,
1650       "scic_sds_stp_request_pio_data_in_await_h2d_completion_tc_completion_handler(0x%x, 0x%x) enter\n",
1651       this_request, completion_code
1652    ));
1653 
1654    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
1655    {
1656       case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1657          //Transmit data
1658          if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes != 0)
1659          {
1660             status = scic_sds_stp_request_pio_data_out_transmit_data ( this_request);
1661             if (status == SCI_SUCCESS)
1662             {
1663                if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0)
1664                all_frames_transferred = TRUE;
1665             }
1666          }
1667          else if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0)
1668          {
1669             //this will happen if the all data is written at the first time after the pio setup fis is recieved
1670             all_frames_transferred  = TRUE;
1671          }
1672 
1673          //all data transferred.
1674          if (all_frames_transferred)
1675          {
1676             //Change the state to SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_FRAME_SUBSTATE
1677             //and wait for PIO_SETUP fis / or D2H REg fis.
1678             sci_base_state_machine_change_state(
1679                &this_request->started_substate_machine,
1680                SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1681             );
1682          }
1683          break;
1684 
1685       default:
1686          // All other completion status cause the IO to be complete.  If a NAK
1687          // was received, then it is up to the user to retry the request.
1688          scic_sds_request_set_status(
1689             this_request,
1690             SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1691             SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
1692          );
1693 
1694          sci_base_state_machine_change_state(
1695             &this_request->parent.state_machine,
1696             SCI_BASE_REQUEST_STATE_COMPLETED
1697          );
1698          break;
1699    }
1700 
1701    return status;
1702 }
1703 
1704 /**
1705  * This method will handle any link layer events while waiting for the data
1706  * frame.
1707  *
1708  * @param[in] request This is the request which is receiving the event.
1709  * @param[in] event_code This is the event code that the request on which the
1710  *       request is expected to take action.
1711  *
1712  * @return SCI_STATUS
1713  * @retval SCI_SUCCESS
1714  * @retval SCI_FAILURE
1715  */
1716 static
1717 SCI_STATUS scic_sds_stp_request_pio_data_in_await_data_event_handler(
1718    SCIC_SDS_REQUEST_T * request,
1719    U32                  event_code
1720 )
1721 {
1722    SCI_STATUS status;
1723 
1724    switch (scu_get_event_specifier(event_code))
1725    {
1726    case SCU_TASK_DONE_CRC_ERR << SCU_EVENT_SPECIFIC_CODE_SHIFT:
1727       // We are waiting for data and the SCU has R_ERR the data frame.
1728       // Go back to waiting for the D2H Register FIS
1729       sci_base_state_machine_change_state(
1730          &request->started_substate_machine,
1731          SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1732       );
1733 
1734       status = SCI_SUCCESS;
1735       break;
1736 
1737    default:
1738       SCIC_LOG_ERROR((
1739          sci_base_object_get_logger(request),
1740          SCIC_LOG_OBJECT_STP_IO_REQUEST,
1741          "SCIC PIO Request 0x%x received unexpected event 0x%08x\n",
1742          request, event_code
1743       ));
1744 
1745       /// @todo Should we fail the PIO request when we get an unexpected event?
1746       status = SCI_FAILURE;
1747       break;
1748    }
1749 
1750    return status;
1751 }
1752 
1753 // ---------------------------------------------------------------------------
1754 
1755 SCIC_SDS_IO_REQUEST_STATE_HANDLER_T
1756    scic_sds_stp_request_started_pio_substate_handler_table
1757       [SCIC_SDS_STP_REQUEST_STARTED_PIO_MAX_SUBSTATES] =
1758 {
1759    // SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
1760    {
1761       {
1762          scic_sds_request_default_start_handler,
1763          scic_sds_request_started_state_abort_handler,
1764          scic_sds_request_default_complete_handler,
1765          scic_sds_request_default_destruct_handler
1766       },
1767       scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler,
1768       scic_sds_request_default_event_handler,
1769       scic_sds_request_default_frame_handler
1770    },
1771    // SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1772    {
1773       {
1774          scic_sds_request_default_start_handler,
1775          //scic_sds_stp_pio_request_data_in_await_frame_abort_handler,
1776          scic_sds_request_started_state_abort_handler,
1777          scic_sds_request_default_complete_handler,
1778          scic_sds_request_default_destruct_handler
1779       },
1780       scic_sds_request_default_tc_completion_handler,
1781       scic_sds_request_default_event_handler,
1782       scic_sds_stp_request_pio_await_frame_frame_handler
1783    },
1784    // SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
1785    {
1786       {
1787          scic_sds_request_default_start_handler,
1788          //scic_sds_stp_pio_request_data_in_await_data_abort_handler,
1789          scic_sds_request_started_state_abort_handler,
1790          scic_sds_request_default_complete_handler,
1791          scic_sds_request_default_destruct_handler
1792       },
1793       scic_sds_request_default_tc_completion_handler,
1794       scic_sds_stp_request_pio_data_in_await_data_event_handler,
1795       scic_sds_stp_request_pio_data_in_await_data_frame_handler
1796    },
1797    //SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
1798    {
1799       {
1800          scic_sds_request_default_start_handler,
1801          scic_sds_request_started_state_abort_handler,
1802          scic_sds_request_default_complete_handler,
1803          scic_sds_request_default_destruct_handler
1804       },
1805       scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler,
1806       scic_sds_request_default_event_handler,
1807       scic_sds_request_default_frame_handler
1808    }
1809 };
1810 
1811 static
1812 void scic_sds_stp_request_started_pio_await_h2d_completion_enter(
1813    SCI_BASE_OBJECT_T *object
1814 )
1815 {
1816    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
1817 
1818    SET_STATE_HANDLER(
1819       this_request,
1820       scic_sds_stp_request_started_pio_substate_handler_table,
1821       SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
1822    );
1823 
1824    scic_sds_remote_device_set_working_request(
1825       this_request->target_device, this_request);
1826 }
1827 
1828 static
1829 void scic_sds_stp_request_started_pio_await_frame_enter(
1830    SCI_BASE_OBJECT_T *object
1831 )
1832 {
1833    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
1834 
1835    SET_STATE_HANDLER(
1836       this_request,
1837       scic_sds_stp_request_started_pio_substate_handler_table,
1838       SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
1839    );
1840 }
1841 
1842 static
1843 void scic_sds_stp_request_started_pio_data_in_await_data_enter(
1844    SCI_BASE_OBJECT_T *object
1845 )
1846 {
1847    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
1848 
1849    SET_STATE_HANDLER(
1850       this_request,
1851       scic_sds_stp_request_started_pio_substate_handler_table,
1852       SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
1853    );
1854 }
1855 
1856 static
1857 void scic_sds_stp_request_started_pio_data_out_transmit_data_enter(
1858    SCI_BASE_OBJECT_T *object
1859 )
1860 {
1861    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
1862 
1863    SET_STATE_HANDLER(
1864       this_request,
1865       scic_sds_stp_request_started_pio_substate_handler_table,
1866       SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
1867    );
1868 }
1869 
1870 // ---------------------------------------------------------------------------
1871 
1872 SCI_BASE_STATE_T
1873    scic_sds_stp_request_started_pio_substate_table
1874       [SCIC_SDS_STP_REQUEST_STARTED_PIO_MAX_SUBSTATES] =
1875 {
1876    {
1877       SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE,
1878       scic_sds_stp_request_started_pio_await_h2d_completion_enter,
1879       NULL
1880    },
1881    {
1882       SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE,
1883       scic_sds_stp_request_started_pio_await_frame_enter,
1884       NULL
1885    },
1886    {
1887       SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE,
1888       scic_sds_stp_request_started_pio_data_in_await_data_enter,
1889       NULL
1890    },
1891    {
1892       SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE,
1893       scic_sds_stp_request_started_pio_data_out_transmit_data_enter,
1894       NULL
1895    }
1896 };
1897 
1898 //******************************************************************************
1899 //* UDMA REQUEST STATE MACHINE
1900 //******************************************************************************
1901 
1902 static
1903 void scic_sds_stp_request_udma_complete_request(
1904    SCIC_SDS_REQUEST_T * this_request,
1905    U32                  scu_status,
1906    SCI_STATUS           sci_status
1907 )
1908 {
1909    scic_sds_request_set_status(
1910       this_request, scu_status, sci_status
1911    );
1912 
1913    sci_base_state_machine_change_state(
1914       &this_request->parent.state_machine,
1915       SCI_BASE_REQUEST_STATE_COMPLETED
1916    );
1917 }
1918 
1919 /**
1920  *
1921  *
1922  * @param[in] this_request
1923  * @param[in] frame_index
1924  *
1925  * @return SCI_STATUS
1926  */
1927 static
1928 SCI_STATUS scic_sds_stp_request_udma_general_frame_handler(
1929    SCIC_SDS_REQUEST_T * this_request,
1930    U32                  frame_index
1931 )
1932 {
1933    SCI_STATUS          status;
1934    SATA_FIS_HEADER_T * frame_header;
1935    U32               * frame_buffer;
1936 
1937    SCIC_LOG_TRACE((
1938       sci_base_object_get_logger(this_request),
1939       SCIC_LOG_OBJECT_STP_IO_REQUEST,
1940       "scic_sds_stp_pio_request_data_in_await_frame_frame_handler(0x%x, 0x%x) enter\n",
1941       this_request, frame_index
1942    ));
1943 
1944    status = scic_sds_unsolicited_frame_control_get_header(
1945       &this_request->owning_controller->uf_control,
1946       frame_index,
1947       (void**) &frame_header
1948    );
1949 
1950    if (
1951          (status == SCI_SUCCESS)
1952       && (frame_header->fis_type == SATA_FIS_TYPE_REGD2H)
1953       )
1954    {
1955       scic_sds_unsolicited_frame_control_get_buffer(
1956          &this_request->owning_controller->uf_control,
1957          frame_index,
1958          (void**) &frame_buffer
1959       );
1960 
1961       scic_sds_controller_copy_sata_response(
1962          &((SCIC_SDS_STP_REQUEST_T *)this_request)->d2h_reg_fis,
1963          (U32 *)frame_header,
1964          frame_buffer
1965       );
1966    }
1967 
1968    scic_sds_controller_release_frame(
1969       this_request->owning_controller, frame_index);
1970 
1971    return status;
1972 }
1973 
1974 /**
1975  * @brief This method process TC completions while in the state where
1976  *        we are waiting for TC completions.
1977  *
1978  * @param[in] this_request
1979  * @param[in] completion_code
1980  *
1981  * @return SCI_STATUS
1982  */
1983 static
1984 SCI_STATUS scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler(
1985    SCIC_SDS_REQUEST_T * request,
1986    U32                  completion_code
1987 )
1988 {
1989    SCI_STATUS               status = SCI_SUCCESS;
1990    SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
1991 
1992    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
1993    {
1994    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1995       scic_sds_stp_request_udma_complete_request(
1996          &this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
1997       );
1998    break;
1999 
2000    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS):
2001    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
2002       // We must check ther response buffer to see if the D2H Register FIS was
2003       // received before we got the TC completion.
2004       if (this_request->d2h_reg_fis.fis_type == SATA_FIS_TYPE_REGD2H)
2005       {
2006          scic_sds_remote_device_suspend(
2007             this_request->parent.target_device,
2008             SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
2009          );
2010 
2011          scic_sds_stp_request_udma_complete_request(
2012             &this_request->parent,
2013             SCU_TASK_DONE_CHECK_RESPONSE,
2014             SCI_FAILURE_IO_RESPONSE_VALID
2015          );
2016       }
2017       else
2018       {
2019          // If we have an error completion status for the TC then we can expect a
2020          // D2H register FIS from the device so we must change state to wait for it
2021          sci_base_state_machine_change_state(
2022             &this_request->parent.started_substate_machine,
2023             SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
2024          );
2025       }
2026    break;
2027 
2028    /// @todo Check to see if any of these completion status need to wait for
2029    ///       the device to host register fis.
2030    /// @todo We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR - this comes only for B0
2031    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_INV_FIS_LEN):
2032    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
2033    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_R_ERR):
2034    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
2035    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
2036       scic_sds_remote_device_suspend(
2037          this_request->parent.target_device,
2038          SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
2039       );
2040       // Fall through to the default case
2041    default:
2042       // All other completion status cause the IO to be complete.
2043       SCIC_LOG_ERROR((
2044          sci_base_object_get_logger(&this_request->parent),
2045          SCIC_LOG_OBJECT_STP_IO_REQUEST,
2046          "SCIC IO Request 0x%x returning CONTROLLER_SPECIFIC_IO_ERR for completion code 0x%x\n",
2047          &this_request->parent, completion_code
2048       ));
2049       scic_sds_stp_request_udma_complete_request(
2050          &this_request->parent,
2051          SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
2052          SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
2053       );
2054       break;
2055    }
2056 
2057    return status;
2058 }
2059 
2060 static
2061 SCI_STATUS scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler(
2062    SCIC_SDS_REQUEST_T * this_request,
2063    U32                  frame_index
2064 )
2065 {
2066    SCI_STATUS status;
2067 
2068    // Use the general frame handler to copy the resposne data
2069    status = scic_sds_stp_request_udma_general_frame_handler(this_request, frame_index);
2070 
2071    if (status == SCI_SUCCESS)
2072    {
2073       scic_sds_stp_request_udma_complete_request(
2074          this_request,
2075          SCU_TASK_DONE_CHECK_RESPONSE,
2076          SCI_FAILURE_IO_RESPONSE_VALID
2077       );
2078    }
2079 
2080    return status;
2081 }
2082 
2083 // ---------------------------------------------------------------------------
2084 
2085 SCIC_SDS_IO_REQUEST_STATE_HANDLER_T
2086    scic_sds_stp_request_started_udma_substate_handler_table
2087       [SCIC_SDS_STP_REQUEST_STARTED_UDMA_MAX_SUBSTATES] =
2088 {
2089    // SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
2090    {
2091       {
2092          scic_sds_request_default_start_handler,
2093          scic_sds_request_started_state_abort_handler,
2094          scic_sds_request_default_complete_handler,
2095          scic_sds_request_default_destruct_handler
2096       },
2097       scic_sds_stp_request_udma_await_tc_completion_tc_completion_handler,
2098       scic_sds_request_default_event_handler,
2099       scic_sds_stp_request_udma_general_frame_handler
2100    },
2101    // SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
2102    {
2103       {
2104          scic_sds_request_default_start_handler,
2105          scic_sds_request_started_state_abort_handler,
2106          scic_sds_request_default_complete_handler,
2107          scic_sds_request_default_destruct_handler
2108       },
2109       scic_sds_request_default_tc_completion_handler,
2110       scic_sds_request_default_event_handler,
2111       scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler
2112    }
2113 };
2114 
2115 /**
2116  *
2117  *
2118  * @param[in] object
2119  */
2120 static
2121 void scic_sds_stp_request_started_udma_await_tc_completion_enter(
2122    SCI_BASE_OBJECT_T *object
2123 )
2124 {
2125    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
2126 
2127    SET_STATE_HANDLER(
2128       this_request,
2129       scic_sds_stp_request_started_udma_substate_handler_table,
2130       SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
2131    );
2132 }
2133 
2134 /**
2135  * This state is entered when there is an TC completion failure.  The hardware
2136  * received an unexpected condition while processing the IO request and now
2137  * will UF the D2H register FIS to complete the IO.
2138  *
2139  * @param[in] object
2140  */
2141 static
2142 void scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter(
2143    SCI_BASE_OBJECT_T *object
2144 )
2145 {
2146    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
2147 
2148    SET_STATE_HANDLER(
2149       this_request,
2150       scic_sds_stp_request_started_udma_substate_handler_table,
2151       SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
2152    );
2153 }
2154 
2155 // ---------------------------------------------------------------------------
2156 
2157 SCI_BASE_STATE_T
2158    scic_sds_stp_request_started_udma_substate_table
2159       [SCIC_SDS_STP_REQUEST_STARTED_UDMA_MAX_SUBSTATES] =
2160 {
2161    {
2162       SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE,
2163       scic_sds_stp_request_started_udma_await_tc_completion_enter,
2164       NULL
2165    },
2166    {
2167       SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE,
2168       scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter,
2169       NULL
2170    }
2171 };
2172 
2173 //******************************************************************************
2174 //* STP SOFT RESET STATE MACHINE
2175 //******************************************************************************
2176 
2177 /**
2178  * This method processes a TC completion.  The expected TC completion is
2179  * for the transmission of the H2D register FIS containing the SATA/STP
2180  * non-data request.
2181  *
2182  * @param[in] this_request
2183  * @param[in] completion_code
2184  *
2185  * @return This method always successfully processes the TC completion.
2186  * @retval SCI_SUCCESS This value is always returned.
2187  */
2188 static
2189 SCI_STATUS scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler(
2190    SCIC_SDS_REQUEST_T * this_request,
2191    U32                  completion_code
2192 )
2193 {
2194    SCIC_LOG_TRACE((
2195       sci_base_object_get_logger(this_request),
2196       SCIC_LOG_OBJECT_STP_IO_REQUEST,
2197       "scic_sds_stp_request_soft_reset_await_h2d_tc_completion_handler(0x%x, 0x%x) enter\n",
2198       this_request, completion_code
2199    ));
2200 
2201    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
2202    {
2203    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
2204       scic_sds_request_set_status(
2205          this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
2206       );
2207 
2208       sci_base_state_machine_change_state(
2209          &this_request->started_substate_machine,
2210          SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
2211       );
2212       break;
2213 
2214    default:
2215       // All other completion status cause the IO to be complete.  If a NAK
2216       // was received, then it is up to the user to retry the request.
2217       scic_sds_request_set_status(
2218          this_request,
2219          SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
2220          SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
2221       );
2222 
2223       sci_base_state_machine_change_state(
2224          &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED
2225       );
2226       break;
2227    }
2228 
2229    return SCI_SUCCESS;
2230 }
2231 
2232 /**
2233  * This method processes a TC completion.  The expected TC completion is
2234  * for the transmission of the H2D register FIS containing the SATA/STP
2235  * non-data request.
2236  *
2237  * @param[in] this_request
2238  * @param[in] completion_code
2239  *
2240  * @return This method always successfully processes the TC completion.
2241  * @retval SCI_SUCCESS This value is always returned.
2242  */
2243 static
2244 SCI_STATUS scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler(
2245    SCIC_SDS_REQUEST_T * this_request,
2246    U32                  completion_code
2247 )
2248 {
2249    SCIC_LOG_TRACE((
2250       sci_base_object_get_logger(this_request),
2251       SCIC_LOG_OBJECT_STP_IO_REQUEST,
2252       "scic_sds_stp_request_soft_reset_await_h2d_tc_completion_handler(0x%x, 0x%x) enter\n",
2253       this_request, completion_code
2254    ));
2255 
2256    switch (SCU_GET_COMPLETION_TL_STATUS(completion_code))
2257    {
2258    case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
2259       scic_sds_request_set_status(
2260          this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
2261       );
2262 
2263       sci_base_state_machine_change_state(
2264          &this_request->started_substate_machine,
2265          SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
2266       );
2267       break;
2268 
2269    default:
2270       // All other completion status cause the IO to be complete.  If a NAK
2271       // was received, then it is up to the user to retry the request.
2272       scic_sds_request_set_status(
2273          this_request,
2274          SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
2275          SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
2276       );
2277 
2278       sci_base_state_machine_change_state(
2279          &this_request->parent.state_machine, SCI_BASE_REQUEST_STATE_COMPLETED
2280       );
2281       break;
2282    }
2283 
2284    return SCI_SUCCESS;
2285 }
2286 
2287 /**
2288  * This method processes frames received from the target while waiting
2289  * for a device to host register FIS.  If a non-register FIS is received
2290  * during this time, it is treated as a protocol violation from an
2291  * IO perspective.
2292  *
2293  * @param[in] request This parameter specifies the request for which a
2294  *            frame has been received.
2295  * @param[in] frame_index This parameter specifies the index of the frame
2296  *            that has been received.
2297  *
2298  * @return Indicate if the received frame was processed successfully.
2299  */
2300 static
2301 SCI_STATUS scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
2302    SCIC_SDS_REQUEST_T * request,
2303    U32                  frame_index
2304 )
2305 {
2306    SCI_STATUS               status;
2307    SATA_FIS_HEADER_T      * frame_header;
2308    U32                    * frame_buffer;
2309    SCIC_SDS_STP_REQUEST_T * this_request = (SCIC_SDS_STP_REQUEST_T *)request;
2310 
2311    // Save off the controller, so that we do not touch the request after it
2312    //  is completed.
2313    SCIC_SDS_CONTROLLER_T  * owning_controller = this_request->parent.owning_controller;
2314 
2315    SCIC_LOG_TRACE((
2316       sci_base_object_get_logger(this_request),
2317       SCIC_LOG_OBJECT_STP_IO_REQUEST,
2318       "scic_sds_stp_request_soft_reset_await_d2h_frame_handler(0x%x, 0x%x) enter\n",
2319       this_request, frame_index
2320    ));
2321 
2322    status = scic_sds_unsolicited_frame_control_get_header(
2323                &(owning_controller->uf_control),
2324                frame_index,
2325                (void**) &frame_header
2326             );
2327 
2328    if (status == SCI_SUCCESS)
2329    {
2330       switch (frame_header->fis_type)
2331       {
2332       case SATA_FIS_TYPE_REGD2H:
2333          scic_sds_unsolicited_frame_control_get_buffer(
2334             &(owning_controller->uf_control),
2335             frame_index,
2336             (void**) &frame_buffer
2337          );
2338 
2339          scic_sds_controller_copy_sata_response(
2340             &this_request->d2h_reg_fis, (U32 *)frame_header, frame_buffer
2341          );
2342 
2343          // The command has completed with error
2344          scic_sds_request_set_status(
2345             &this_request->parent,
2346             SCU_TASK_DONE_CHECK_RESPONSE,
2347             SCI_FAILURE_IO_RESPONSE_VALID
2348          );
2349          break;
2350 
2351       default:
2352          SCIC_LOG_WARNING((
2353             sci_base_object_get_logger(this_request),
2354             SCIC_LOG_OBJECT_STP_IO_REQUEST,
2355             "IO Request:0x%x Frame Id:%d protocol violation occurred\n",
2356             this_request, frame_index
2357          ));
2358 
2359          scic_sds_request_set_status(
2360             &this_request->parent,
2361             SCU_TASK_DONE_UNEXP_FIS,
2362             SCI_FAILURE_PROTOCOL_VIOLATION
2363          );
2364          break;
2365       }
2366 
2367       sci_base_state_machine_change_state(
2368          &this_request->parent.parent.state_machine,
2369          SCI_BASE_REQUEST_STATE_COMPLETED
2370       );
2371 
2372       // Frame has been decoded return it to the controller
2373       scic_sds_controller_release_frame(
2374          owning_controller, frame_index
2375       );
2376    }
2377    else
2378    {
2379       SCIC_LOG_ERROR((
2380          sci_base_object_get_logger(this_request),
2381          SCIC_LOG_OBJECT_STP_IO_REQUEST,
2382          "SCIC IO Request 0x%x could not get frame header for frame index %d, status %x\n",
2383          this_request, frame_index, status
2384       ));
2385    }
2386 
2387    return status;
2388 }
2389 
2390 // ---------------------------------------------------------------------------
2391 
2392 SCIC_SDS_IO_REQUEST_STATE_HANDLER_T
2393    scic_sds_stp_request_started_soft_reset_substate_handler_table
2394       [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_MAX_SUBSTATES] =
2395 {
2396    // SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
2397    {
2398       {
2399          scic_sds_request_default_start_handler,
2400          scic_sds_request_started_state_abort_handler,
2401          scic_sds_request_default_complete_handler,
2402          scic_sds_request_default_destruct_handler
2403       },
2404       scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler,
2405       scic_sds_request_default_event_handler,
2406       scic_sds_request_default_frame_handler
2407    },
2408    // SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
2409    {
2410       {
2411          scic_sds_request_default_start_handler,
2412          scic_sds_request_started_state_abort_handler,
2413          scic_sds_request_default_complete_handler,
2414          scic_sds_request_default_destruct_handler
2415       },
2416       scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler,
2417       scic_sds_request_default_event_handler,
2418       scic_sds_request_default_frame_handler
2419    },
2420    // SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
2421    {
2422       {
2423          scic_sds_request_default_start_handler,
2424          scic_sds_request_started_state_abort_handler,
2425          scic_sds_request_default_complete_handler,
2426          scic_sds_request_default_destruct_handler
2427       },
2428       scic_sds_request_default_tc_completion_handler,
2429       scic_sds_request_default_event_handler,
2430       scic_sds_stp_request_soft_reset_await_d2h_frame_handler
2431    }
2432 };
2433 
2434 static
2435 void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(
2436    SCI_BASE_OBJECT_T *object
2437 )
2438 {
2439    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
2440 
2441    SET_STATE_HANDLER(
2442       this_request,
2443       scic_sds_stp_request_started_soft_reset_substate_handler_table,
2444       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
2445    );
2446 
2447    scic_sds_remote_device_set_working_request(
2448       this_request->target_device, this_request
2449    );
2450 }
2451 
2452 static
2453 void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(
2454    SCI_BASE_OBJECT_T *object
2455 )
2456 {
2457    SCI_STATUS status;
2458    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
2459    SATA_FIS_REG_H2D_T *h2d_fis;
2460    SCU_TASK_CONTEXT_T *task_context;
2461 
2462    // Clear the SRST bit
2463    h2d_fis = scic_stp_io_request_get_h2d_reg_address(this_request);
2464    h2d_fis->control = 0;
2465 
2466    // Clear the TC control bit
2467    task_context = scic_sds_controller_get_task_context_buffer(
2468                         this_request->owning_controller, this_request->io_tag);
2469    task_context->control_frame = 0;
2470 
2471    status = this_request->owning_controller->state_handlers->parent.continue_io_handler(
2472       &this_request->owning_controller->parent,
2473       &this_request->target_device->parent,
2474       &this_request->parent
2475    );
2476 
2477    if (status == SCI_SUCCESS)
2478    {
2479       SET_STATE_HANDLER(
2480          this_request,
2481          scic_sds_stp_request_started_soft_reset_substate_handler_table,
2482          SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
2483       );
2484    }
2485 }
2486 
2487 static
2488 void scic_sds_stp_request_started_soft_reset_await_d2h_response_enter(
2489    SCI_BASE_OBJECT_T *object
2490 )
2491 {
2492    SCIC_SDS_REQUEST_T *this_request = (SCIC_SDS_REQUEST_T *)object;
2493 
2494    SET_STATE_HANDLER(
2495       this_request,
2496       scic_sds_stp_request_started_soft_reset_substate_handler_table,
2497       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
2498    );
2499 }
2500 
2501 // ---------------------------------------------------------------------------
2502 
2503 SCI_BASE_STATE_T
2504    scic_sds_stp_request_started_soft_reset_substate_table
2505       [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_MAX_SUBSTATES] =
2506 {
2507    {
2508       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE,
2509       scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter,
2510       NULL
2511    },
2512    {
2513       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE,
2514       scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter,
2515       NULL
2516    },
2517    {
2518       SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE,
2519       scic_sds_stp_request_started_soft_reset_await_d2h_response_enter,
2520       NULL
2521    }
2522 };
2523 
2524 // ---------------------------------------------------------------------------
2525 
2526 SCI_STATUS scic_io_request_construct_basic_sata(
2527    SCI_IO_REQUEST_HANDLE_T  scic_io_request
2528 )
2529 {
2530    SCI_STATUS           status;
2531    SCIC_SDS_REQUEST_T * request = (SCIC_SDS_REQUEST_T *)scic_io_request;
2532 
2533    SCIC_LOG_TRACE((
2534       sci_base_object_get_logger(scic_io_request),
2535       SCIC_LOG_OBJECT_STP_IO_REQUEST,
2536       "scic_io_request_construct_basic_sata(0x%x) enter\n",
2537       scic_io_request
2538    ));
2539 
2540    status = scic_sds_io_request_construct_sata(
2541                request,
2542                scic_cb_request_get_sat_protocol(request->user_request),
2543                scic_cb_io_request_get_transfer_length(request->user_request),
2544                scic_cb_io_request_get_data_direction(request->user_request),
2545                scic_cb_io_request_do_copy_rx_frames(request->user_request),
2546                TRUE
2547             );
2548 
2549    return status;
2550 }
2551 
2552 // ---------------------------------------------------------------------------
2553 
2554 SCI_STATUS scic_io_request_construct_advanced_sata(
2555    SCI_IO_REQUEST_HANDLE_T     scic_io_request,
2556    SCIC_IO_SATA_PARAMETERS_T * io_parameters
2557 )
2558 {
2559    SCI_STATUS           status;
2560    SCIC_SDS_REQUEST_T * request = (SCIC_SDS_REQUEST_T *)scic_io_request;
2561 
2562    SCIC_LOG_TRACE((
2563       sci_base_object_get_logger(scic_io_request),
2564       SCIC_LOG_OBJECT_STP_IO_REQUEST,
2565       "scic_io_request_construct_basic_sata(0x%x) enter\n",
2566       scic_io_request
2567    ));
2568 
2569    status = scic_sds_io_request_construct_sata(
2570                request,
2571                scic_cb_request_get_sat_protocol(request->user_request),
2572                scic_sds_request_get_sgl_element_pair(request, 0)->A.length,
2573                scic_cb_io_request_get_data_direction(request->user_request),
2574                scic_cb_io_request_do_copy_rx_frames(request->user_request),
2575                io_parameters->do_translate_sgl
2576             );
2577 
2578    return status;
2579 }
2580 
2581