xref: /freebsd/sys/dev/isci/scil/sati.c (revision 5ca8e32633c4ffbbcd6762e5888b6a4ba0708c6c)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
3  *
4  * This file is provided under a dual BSD/GPLv2 license.  When using or
5  * redistributing this file, you may do so under either license.
6  *
7  * GPL LICENSE SUMMARY
8  *
9  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of version 2 of the GNU General Public License as
13  * published by the Free Software Foundation.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
23  * The full GNU General Public License is included in this distribution
24  * in the file called LICENSE.GPL.
25  *
26  * BSD LICENSE
27  *
28  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
29  * All rights reserved.
30  *
31  * Redistribution and use in source and binary forms, with or without
32  * modification, are permitted provided that the following conditions
33  * are met:
34  *
35  *   * Redistributions of source code must retain the above copyright
36  *     notice, this list of conditions and the following disclaimer.
37  *   * Redistributions in binary form must reproduce the above copyright
38  *     notice, this list of conditions and the following disclaimer in
39  *     the documentation and/or other materials provided with the
40  *     distribution.
41  *
42  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
43  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
44  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
45  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
46  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
47  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
48  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
49  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
50  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
51  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
52  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
53  */
54 
55 #include <sys/cdefs.h>
56 /**
57  * @file
58  * @brief This file contains all of the method implementations that
59  *        can be utilized by a user to perform SCSI-to-ATA Translation.
60  *        SATI adheres to the www.t10.org SAT specification.
61  *
62  * For situations where compliance is not observed, the SATI will
63  * return an error indication (most likely INVALID FIELD IN CDB sense data).
64  */
65 
66 #include <dev/isci/scil/sati.h>
67 #include <dev/isci/scil/sati_callbacks.h>
68 #include <dev/isci/scil/sati_util.h>
69 #include <dev/isci/scil/sati_report_luns.h>
70 #include <dev/isci/scil/sati_inquiry.h>
71 #include <dev/isci/scil/sati_mode_sense_6.h>
72 #include <dev/isci/scil/sati_mode_sense_10.h>
73 #include <dev/isci/scil/sati_mode_select.h>
74 #include <dev/isci/scil/sati_test_unit_ready.h>
75 #include <dev/isci/scil/sati_read_capacity.h>
76 #include <dev/isci/scil/sati_read.h>
77 #include <dev/isci/scil/sati_write.h>
78 #include <dev/isci/scil/sati_verify.h>
79 #include <dev/isci/scil/sati_synchronize_cache.h>
80 #include <dev/isci/scil/sati_lun_reset.h>
81 #include <dev/isci/scil/sati_start_stop_unit.h>
82 #include <dev/isci/scil/sati_request_sense.h>
83 #include <dev/isci/scil/sati_write_long.h>
84 #include <dev/isci/scil/sati_reassign_blocks.h>
85 #include <dev/isci/scil/sati_log_sense.h>
86 #include <dev/isci/scil/sati_abort_task_set.h>
87 #include <dev/isci/scil/sati_unmap.h>
88 #include <dev/isci/scil/sati_passthrough.h>
89 #include <dev/isci/scil/sati_write_and_verify.h>
90 #include <dev/isci/scil/sati_read_buffer.h>
91 #include <dev/isci/scil/sati_write_buffer.h>
92 #include <dev/isci/scil/intel_ata.h>
93 #include <dev/isci/scil/intel_scsi.h>
94 #include <dev/isci/scil/intel_sat.h>
95 
96 //******************************************************************************
97 //* P R I V A T E   M E T H O D S
98 //******************************************************************************
99 
100 /**
101  * @brief This method performs the translation of ATA error register values
102  *        into SCSI sense data.
103  *        For more information on the parameter passed to this method please
104  *        reference the sati_translate_response() method.
105  *
106  * @param[in] error This parameter specifies the contents of the ATA error
107  *            register to be translated.
108  *
109  * @return none
110  */
111 void sati_translate_error(
112    SATI_TRANSLATOR_SEQUENCE_T * sequence,
113    void                       * scsi_io,
114    U8                           error
115 )
116 {
117    if (error & ATA_ERROR_REG_NO_MEDIA_BIT)
118    {
119       sati_scsi_sense_data_construct(
120          sequence,
121          scsi_io,
122          SCSI_STATUS_CHECK_CONDITION,
123          SCSI_SENSE_NOT_READY,
124          SCSI_ASC_MEDIUM_NOT_PRESENT,
125          SCSI_ASCQ_MEDIUM_NOT_PRESENT
126       );
127    }
128    else if (error & ATA_ERROR_REG_MEDIA_CHANGE_BIT)
129    {
130       sati_scsi_sense_data_construct(
131          sequence,
132          scsi_io,
133          SCSI_STATUS_CHECK_CONDITION,
134          SCSI_SENSE_UNIT_ATTENTION,
135          SCSI_ASC_NOT_READY_TO_READY_CHANGE,
136          SCSI_ASCQ_NOT_READY_TO_READY_CHANGE
137       );
138    }
139    else if (error & ATA_ERROR_REG_MEDIA_CHANGE_REQUEST_BIT)
140    {
141       sati_scsi_sense_data_construct(
142          sequence,
143          scsi_io,
144          SCSI_STATUS_CHECK_CONDITION,
145          SCSI_SENSE_UNIT_ATTENTION,
146          SCSI_ASC_MEDIUM_REMOVAL_REQUEST,
147          SCSI_ASCQ_MEDIUM_REMOVAL_REQUEST
148       );
149    }
150    else if (error & ATA_ERROR_REG_ID_NOT_FOUND_BIT)
151    {
152       sati_scsi_sense_data_construct(
153          sequence,
154          scsi_io,
155          SCSI_STATUS_CHECK_CONDITION,
156          SCSI_SENSE_ILLEGAL_REQUEST,
157          SCSI_ASC_LBA_OUT_OF_RANGE,
158          SCSI_ASCQ_LBA_OUT_OF_RANGE
159       );
160    }
161    else if (error & ATA_ERROR_REG_UNCORRECTABLE_BIT)
162    {
163       //Mark the Sequence state as a read error so more sense data
164       //can be returned later
165       sequence->state = SATI_SEQUENCE_STATE_READ_ERROR;
166       sati_scsi_sense_data_construct(
167          sequence,
168          scsi_io,
169          SCSI_STATUS_CHECK_CONDITION,
170          SCSI_SENSE_MEDIUM_ERROR,
171          SCSI_ASC_UNRECOVERED_READ_ERROR,
172          SCSI_ASCQ_UNRECOVERED_READ_ERROR
173       );
174    }
175    else if (  (sequence->data_direction == SATI_DATA_DIRECTION_OUT)
176            && (error & ATA_ERROR_REG_WRITE_PROTECTED_BIT) )
177    {
178       sati_scsi_sense_data_construct(
179          sequence,
180          scsi_io,
181          SCSI_STATUS_CHECK_CONDITION,
182          SCSI_SENSE_DATA_PROTECT,
183          SCSI_ASC_WRITE_PROTECTED,
184          SCSI_ASCQ_WRITE_PROTECTED
185       );
186    }
187    else if (error & ATA_ERROR_REG_ICRC_BIT)
188    {
189       sati_scsi_sense_data_construct(
190          sequence,
191          scsi_io,
192          SCSI_STATUS_CHECK_CONDITION,
193          SCSI_SENSE_ABORTED_COMMAND,
194          SCSI_ASC_IU_CRC_ERROR_DETECTED,
195          SCSI_ASCQ_IU_CRC_ERROR_DETECTED
196       );
197    }
198    else // (error & ATA_ERROR_REG_ABORT_BIT)
199    {
200       // The ABORT bit has the lowest precedence of all errors.
201       // As a result, it is at the bottom of the conditional
202       // statement.
203       sati_scsi_sense_data_construct(
204          sequence,
205          scsi_io,
206          SCSI_STATUS_CHECK_CONDITION,
207          SCSI_SENSE_ABORTED_COMMAND,
208          SCSI_ASC_NO_ADDITIONAL_SENSE,
209          SCSI_ASCQ_NO_ADDITIONAL_SENSE
210       );
211    }
212 }
213 
214 /**
215  * @brief This method translates the supplied ATA payload data into the
216  *        corresponding SCSI data.  This is necessary for SCSI commands
217  *        that have well-defined payload data associated with them (e.g.
218  *        READ CAPACITY).
219  *
220  * @param[in]  sequence This parameter specifies the sequence
221  *             data associated with the translation.
222  * @param[in]  ata_io This parameter specifies the ATA payload
223  *             buffer location and size to be translated.
224  * @param[out] scsi_output_data This parameter specifies the SCSI payload
225  *             memory area into which the translator is to write.
226  *
227  * @return none
228  */
229 static
230 void sati_translate_data(
231    SATI_TRANSLATOR_SEQUENCE_T * sequence,
232    void                       * ata_input_data,
233    void                       * scsi_io
234 )
235 {
236    // Update the device capabilities in the odd/crazy event something changed.
237    sati_device_update_capabilities(
238       sequence->device, (ATA_IDENTIFY_DEVICE_DATA_T*) ata_input_data
239    );
240 
241    // Look at the first byte to determine the SCSI command to translate.
242    switch (sequence->type)
243    {
244 #if !defined(DISABLE_SATI_INQUIRY)
245       case SATI_SEQUENCE_INQUIRY_STANDARD:
246          sati_inquiry_standard_translate_data(
247             sequence, ata_input_data, scsi_io
248          );
249       break;
250 
251       case SATI_SEQUENCE_INQUIRY_SERIAL_NUMBER:
252          sati_inquiry_serial_number_translate_data(
253             sequence, ata_input_data, scsi_io
254          );
255       break;
256 
257       case SATI_SEQUENCE_INQUIRY_DEVICE_ID:
258          sati_inquiry_device_id_translate_data(
259             sequence, ata_input_data, scsi_io
260          );
261       break;
262 
263       case SATI_SEQUENCE_INQUIRY_BLOCK_DEVICE:
264          sati_inquiry_block_device_translate_data(
265             sequence, ata_input_data, scsi_io
266          );
267       break;
268 
269       case SATI_SEQUENCE_INQUIRY_ATA_INFORMATION:
270          sati_inquiry_ata_information_translate_data(
271             sequence, ata_input_data, scsi_io
272          );
273       break;
274 
275 #endif // !defined(DISABLE_SATI_INQUIRY)
276 
277 #if !defined(DISABLE_SATI_READ_CAPACITY)
278       case SATI_SEQUENCE_READ_CAPACITY_10:
279          sati_read_capacity_10_translate_data(sequence, ata_input_data, scsi_io);
280       break;
281 
282       case SATI_SEQUENCE_READ_CAPACITY_16:
283          sati_read_capacity_16_translate_data(sequence, ata_input_data, scsi_io);
284       break;
285 #endif // !defined(DISABLE_SATI_READ_CAPACITY)
286 
287 #if !defined(DISABLE_SATI_MODE_SENSE)
288       case SATI_SEQUENCE_MODE_SENSE_6_CACHING:
289          sati_mode_sense_6_caching_translate_data(
290             sequence, ata_input_data, scsi_io
291          );
292       break;
293 
294       case SATI_SEQUENCE_MODE_SENSE_6_INFORMATIONAL_EXCP_CONTROL:
295          sati_mode_sense_6_informational_excp_control_translate_data(
296             sequence, ata_input_data, scsi_io
297          );
298       break;
299 
300       case SATI_SEQUENCE_MODE_SENSE_6_READ_WRITE_ERROR:
301          sati_mode_sense_6_read_write_error_translate_data(
302             sequence, ata_input_data, scsi_io
303          );
304       break;
305 
306       case SATI_SEQUENCE_MODE_SENSE_6_DISCONNECT_RECONNECT:
307          sati_mode_sense_6_disconnect_reconnect_translate_data(
308             sequence, ata_input_data, scsi_io
309          );
310       break;
311 
312       case SATI_SEQUENCE_MODE_SENSE_6_CONTROL:
313          sati_mode_sense_6_control_translate_data(
314             sequence, ata_input_data, scsi_io
315          );
316       break;
317 
318       case SATI_SEQUENCE_MODE_SENSE_6_ALL_PAGES:
319          sati_mode_sense_6_all_pages_translate_data(
320             sequence, ata_input_data, scsi_io
321          );
322       break;
323 
324       case SATI_SEQUENCE_MODE_SENSE_6_POWER_CONDITION:
325          sati_mode_sense_6_power_condition_translate_data(
326             sequence, ata_input_data, scsi_io
327          );
328       break;
329 
330       case SATI_SEQUENCE_MODE_SENSE_10_POWER_CONDITION:
331          sati_mode_sense_10_power_condition_translate_data(
332             sequence, ata_input_data, scsi_io
333          );
334       break;
335 
336       case SATI_SEQUENCE_MODE_SENSE_10_CACHING:
337          sati_mode_sense_10_caching_translate_data(
338             sequence, ata_input_data, scsi_io
339          );
340       break;
341 
342       case SATI_SEQUENCE_MODE_SENSE_10_INFORMATIONAL_EXCP_CONTROL:
343          sati_mode_sense_10_informational_excp_control_translate_data(
344             sequence, ata_input_data, scsi_io
345          );
346       break;
347 
348       case SATI_SEQUENCE_MODE_SENSE_10_READ_WRITE_ERROR:
349          sati_mode_sense_10_read_write_error_translate_data(
350             sequence, ata_input_data, scsi_io
351          );
352       break;
353 
354       case SATI_SEQUENCE_MODE_SENSE_10_DISCONNECT_RECONNECT:
355          sati_mode_sense_10_disconnect_reconnect_translate_data(
356             sequence, ata_input_data, scsi_io
357          );
358       break;
359 
360       case SATI_SEQUENCE_MODE_SENSE_10_CONTROL:
361          sati_mode_sense_10_control_translate_data(
362             sequence, ata_input_data, scsi_io
363          );
364       break;
365 
366       case SATI_SEQUENCE_MODE_SENSE_10_ALL_PAGES:
367          sati_mode_sense_10_all_pages_translate_data(
368             sequence, ata_input_data, scsi_io
369          );
370       break;
371 #endif // !defined(DISABLE_SATI_MODE_SENSE)
372 
373       default:
374       break;
375    }
376 }
377 
378 //******************************************************************************
379 //* P U B L I C   M E T H O D S
380 //******************************************************************************
381 
382 SATI_STATUS sati_translate_command(
383    SATI_TRANSLATOR_SEQUENCE_T * sequence,
384    SATI_DEVICE_T              * sati_device,
385    void                       * scsi_io,
386    void                       * ata_io
387 )
388 {
389    SATI_STATUS   status = SATI_FAILURE;
390    U8          * cdb = sati_cb_get_cdb_address(scsi_io);
391 
392    //No sense response has been set for the translation sequence yet
393    sequence->is_sense_response_set          = FALSE;
394    // Default to no translation response required
395    sequence->is_translate_response_required = FALSE;
396    // Assign sati_device to sequence
397    sequence->device  = sati_device;
398 
399    /**
400     * Fail any I/O request with LUN != 0
401     */
402    if (sati_cb_get_lun(scsi_io) != 0)
403    {
404       sati_scsi_sense_data_construct(
405          sequence,
406          scsi_io,
407          SCSI_STATUS_CHECK_CONDITION,
408          SCSI_SENSE_ILLEGAL_REQUEST,
409          SCSI_ASC_LOGICAL_UNIT_NOT_SUPPORTED,
410          0
411       );
412       return SATI_FAILURE_CHECK_RESPONSE_DATA;
413    }
414 
415    /**
416     * SAT dictates:
417     * - the NACA bit in the control byte (last byte) must be 0
418     */
419    if ( (sati_get_cdb_byte(cdb, sati_cb_get_cdb_length(scsi_io) - 1)
420          & SCSI_CONTROL_BYTE_NACA_BIT_ENABLE))
421    {
422       sati_scsi_sense_data_construct(
423          sequence,
424          scsi_io,
425          SCSI_STATUS_CHECK_CONDITION,
426          SCSI_SENSE_ILLEGAL_REQUEST,
427          SCSI_ASC_INVALID_FIELD_IN_CDB,
428          SCSI_ASCQ_INVALID_FIELD_IN_CDB
429       );
430       return SATI_FAILURE_CHECK_RESPONSE_DATA;
431    }
432 
433    /**
434     * Per SAT "Error and sense reporting" section.  All subsequent IOs after
435     * a device fault should receive INTERNAL TARGET FAILURE sense data.
436     */
437    if (sati_device->state == SATI_DEVICE_STATE_DEVICE_FAULT_OCCURRED)
438    {
439       sati_scsi_sense_data_construct(
440          sequence,
441          scsi_io,
442          SCSI_STATUS_CHECK_CONDITION,
443          SCSI_SENSE_HARDWARE_ERROR,
444          SCSI_ASC_INTERNAL_TARGET_FAILURE,
445          SCSI_ASCQ_INTERNAL_TARGET_FAILURE
446       );
447       return SATI_FAILURE_CHECK_RESPONSE_DATA;
448    }
449 
450    if(sequence->state == SATI_SEQUENCE_STATE_INITIAL)
451    {
452       sequence->command_specific_data.scratch = 0;
453       sequence->number_data_bytes_set = 0;
454    }
455 
456 
457 #ifdef SATI_TRANSPORT_SUPPORTS_SATA
458    {
459       U8 * register_fis = sati_cb_get_h2d_register_fis_address(ata_io);
460       sati_set_sata_command_flag(register_fis);
461       sati_set_sata_fis_type(register_fis, SATA_FIS_TYPE_REGH2D);
462    }
463 #endif // SATI_TRANSPORT_SUPPORTS_SATA
464 
465    // Look at the first byte to determine the SCSI command to translate.
466    switch (sati_get_cdb_byte(cdb, 0))
467    {
468 #if !defined(DISABLE_SATI_REPORT_LUNS)
469       case SCSI_REPORT_LUNS:
470          status = sati_report_luns_translate_command(
471                      sequence, scsi_io, ata_io
472                   );
473       break;
474 #endif // !defined(DISABLE_SATI_REPORT_LUNS)
475 
476 #if !defined(DISABLE_SATI_INQUIRY)
477       case SCSI_INQUIRY:
478          status = sati_inquiry_translate_command(
479                      sequence, scsi_io, ata_io
480                   );
481       break;
482 #endif // !defined(DISABLE_SATI_INQUIRY)
483 
484 #if !defined(DISABLE_SATI_MODE_SENSE)
485       case SCSI_MODE_SENSE_6:
486          status = sati_mode_sense_6_translate_command(
487                      sequence, scsi_io, ata_io
488                   );
489       break;
490 
491       case SCSI_MODE_SENSE_10:
492          status = sati_mode_sense_10_translate_command(
493                      sequence, scsi_io, ata_io
494                   );
495       break;
496 #endif // !defined(DISABLE_SATI_MODE_SENSE)
497 
498 #if !defined(DISABLE_SATI_MODE_SELECT)
499       case SCSI_MODE_SELECT_6:
500          status = sati_mode_select_6_translate_command(
501                      sequence, scsi_io, ata_io
502                   );
503       break;
504 
505       case SCSI_MODE_SELECT_10:
506          status = sati_mode_select_10_translate_command(
507                      sequence, scsi_io, ata_io
508                   );
509       break;
510 #endif // !defined(DISABLE_SATI_MODE_SELECT)
511 
512 #if !defined(DISABLE_SATI_TEST_UNIT_READY)
513       case SCSI_TEST_UNIT_READY:
514          status = sati_test_unit_ready_translate_command(
515                      sequence, scsi_io, ata_io
516                   );
517       break;
518 #endif // !defined(DISABLE_SATI_TEST_UNIT_READY)
519 
520 #if !defined(DISABLE_SATI_READ_CAPACITY)
521       case SCSI_READ_CAPACITY_10:
522          status = sati_read_capacity_10_translate_command(
523                      sequence, scsi_io, ata_io
524                   );
525       break;
526 
527       case SCSI_SERVICE_ACTION_IN_16:
528          if ( (sati_get_cdb_byte(cdb, 1) & SCSI_SERVICE_ACTION_MASK)
529               == SCSI_SERVICE_ACTION_IN_CODES_READ_CAPACITY_16)
530             status = sati_read_capacity_16_translate_command(
531                         sequence, scsi_io, ata_io
532                      );
533          else
534             status = SATI_FAILURE_CHECK_RESPONSE_DATA;
535       break;
536 #endif // !defined(DISABLE_SATI_READ_CAPACITY)
537 
538 #if !defined(DISABLE_SATI_REQUEST_SENSE)
539       case SCSI_REQUEST_SENSE:
540          status = sati_request_sense_translate_command(
541                      sequence, scsi_io, ata_io
542                   );
543       break;
544 #endif // !defined(DISABLE_SATI_REQUEST_SENSE)
545 
546       case SCSI_READ_6:
547          status = sati_read_6_translate_command(sequence, scsi_io, ata_io);
548       break;
549 
550       case SCSI_READ_10:
551          status = sati_read_10_translate_command(sequence, scsi_io, ata_io);
552       break;
553 
554       case SCSI_READ_12:
555          status = sati_read_12_translate_command(sequence, scsi_io, ata_io);
556       break;
557 
558       case SCSI_READ_16:
559          status = sati_read_16_translate_command(sequence, scsi_io, ata_io);
560       break;
561 
562       case SCSI_WRITE_6:
563          status = sati_write_6_translate_command(sequence, scsi_io, ata_io);
564       break;
565 
566       case SCSI_WRITE_10:
567          status = sati_write_10_translate_command(sequence, scsi_io, ata_io);
568       break;
569 
570       case SCSI_WRITE_12:
571          status = sati_write_12_translate_command(sequence, scsi_io, ata_io);
572       break;
573 
574       case SCSI_WRITE_16:
575          status = sati_write_16_translate_command(sequence, scsi_io, ata_io);
576       break;
577 
578 #if !defined(DISABLE_SATI_VERIFY)
579       case SCSI_VERIFY_10:
580          status = sati_verify_10_translate_command(sequence, scsi_io, ata_io);
581       break;
582 
583       case SCSI_VERIFY_12:
584          status = sati_verify_12_translate_command(sequence, scsi_io, ata_io);
585       break;
586 
587       case SCSI_VERIFY_16:
588          status = sati_verify_16_translate_command(sequence, scsi_io, ata_io);
589       break;
590 #endif // !defined(DISABLE_SATI_VERIFY)
591 
592 #if    !defined(DISABLE_SATI_WRITE_AND_VERIFY)  \
593    && !defined(DISABLE_SATI_VERIFY)        \
594    && !defined(DISABLE_SATI_WRITE)
595 
596       case SCSI_WRITE_AND_VERIFY_10:
597          status = sati_write_and_verify_10_translate_command(sequence, scsi_io, ata_io);
598       break;
599 
600       case SCSI_WRITE_AND_VERIFY_12:
601          status = sati_write_and_verify_12_translate_command(sequence, scsi_io, ata_io);
602       break;
603 
604       case SCSI_WRITE_AND_VERIFY_16:
605          status = sati_write_and_verify_16_translate_command(sequence, scsi_io, ata_io);
606       break;
607 #endif //    !defined(DISABLE_SATI_WRITE_AND_VERIFY)
608       // && !defined(DISABLE_SATI_VERIFY)
609       // && !defined(DISABLE_SATI_WRITE)
610 
611 #if !defined(DISABLE_SATI_REASSIGN_BLOCKS)
612       case SCSI_REASSIGN_BLOCKS:
613          status = sati_reassign_blocks_translate_command(sequence, scsi_io, ata_io);
614       break;
615 #endif // !defined(DISABLE_SATI_REASSIGN_BLOCKS)
616 
617 #if !defined(DISABLE_SATI_SYNCHRONIZE_CACHE)
618       case SCSI_SYNCHRONIZE_CACHE_10:
619       case SCSI_SYNCHRONIZE_CACHE_16:
620          status = sati_synchronize_cache_translate_command(sequence, scsi_io, ata_io);
621       break;
622 #endif // !defined(DISABLE_SATI_SYNCHRONIZE_CACHE)
623 
624 #if !defined(DISABLE_SATI_START_STOP_UNIT)
625       case SCSI_START_STOP_UNIT:
626          status = sati_start_stop_unit_translate_command(
627                      sequence, scsi_io, ata_io
628                   );
629       break;
630 #endif // !defined(DISABLE_SATI_START_STOP_UNIT)
631 
632 #if !defined(DISABLE_SATI_WRITE_LONG)
633       case SCSI_WRITE_LONG_10:
634       case SCSI_WRITE_LONG_16:
635          status = sati_write_long_translate_command(sequence, scsi_io, ata_io);
636       break;
637 #endif // !defined(DISABLE_SATI_WRITE_LONG)
638 
639 #if !defined(DISABLE_SATI_LOG_SENSE)
640       case SCSI_LOG_SENSE:
641          status = sati_log_sense_translate_command(sequence, scsi_io, ata_io);
642       break;
643 #endif // !defined(DISABLE_SATI_LOG_SENSE)
644 
645       case SCSI_PERSISTENT_RESERVE_IN:
646       case SCSI_PERSISTENT_RESERVE_OUT:
647          //These commands are not supported by SATI
648          sati_scsi_sense_data_construct(
649             sequence,
650             scsi_io,
651             SCSI_STATUS_CHECK_CONDITION,
652             SCSI_SENSE_ILLEGAL_REQUEST,
653             SCSI_ASC_INVALID_COMMAND_OPERATION_CODE,
654             SCSI_ASCQ_INVALID_COMMAND_OPERATION_CODE
655          );
656          //returning status now to keep sense data set above
657          return SATI_FAILURE_CHECK_RESPONSE_DATA;
658       break;
659 
660 #if !defined(DISABLE_SATI_UNMAP)
661       case SCSI_UNMAP:
662          status = sati_unmap_translate_command(sequence, scsi_io, ata_io);
663       break;
664 #endif // !defined(DISABLE_SATI_UNMAP)
665 
666 #if !defined(DISABLE_SATI_ATA_PASSTHROUGH)
667       case SCSI_ATA_PASSTHRU_12:
668           status = sati_passthrough_12_translate_command(sequence, scsi_io, ata_io);
669       break;
670 
671       case SCSI_ATA_PASSTHRU_16:
672           status = sati_passthrough_16_translate_command(sequence, scsi_io, ata_io);
673       break;
674 
675 #endif // !define(DISABLE_SATI_ATA_PASSTHRU)
676 
677 #if !defined(DISABLE_SATI_READ_BUFFER)
678       case SCSI_READ_BUFFER:
679          status = sati_read_buffer_translate_command(sequence, scsi_io, ata_io);
680       break;
681 #endif //!defined(DISABLE_SATI_READ_BUFFER)
682 
683 #if !defined(DISABLE_SATI_WRITE_BUFFER)
684       case SCSI_WRITE_BUFFER:
685          status = sati_write_buffer_translate_command(sequence, scsi_io, ata_io);
686       break;
687 #endif //!defined(DISABLE_SATI_WRITE_BUFFER)
688       default:
689          status = SATI_FAILURE_CHECK_RESPONSE_DATA;
690       break;
691    }
692 
693    if( (status == SATI_FAILURE_CHECK_RESPONSE_DATA) &&
694        !(sequence->is_sense_response_set) )
695    {
696       sati_scsi_sense_data_construct(
697          sequence,
698          scsi_io,
699          SCSI_STATUS_CHECK_CONDITION,
700          SCSI_SENSE_ILLEGAL_REQUEST,
701          SCSI_ASC_INVALID_FIELD_IN_CDB,
702          SCSI_ASCQ_INVALID_FIELD_IN_CDB
703       );
704    }
705    return status;
706 }
707 
708 // -----------------------------------------------------------------------------
709 
710 #if !defined(DISABLE_SATI_TASK_MANAGEMENT)
711 SATI_STATUS sati_translate_task_management(
712    SATI_TRANSLATOR_SEQUENCE_T * sequence,
713    SATI_DEVICE_T              * sati_device,
714    void                       * scsi_task,
715    void                       * ata_io
716 )
717 {
718    SATI_STATUS status=SATI_FAILURE;
719    U8 task_function = sati_cb_get_task_function(scsi_task);
720 
721    sequence->device = sati_device;
722 
723    switch (task_function)
724    {
725       /**
726        * @todo We need to update the ABORT_TASK and ABORT_TASK_SET to be
727        *       SAT compliant.
728        */
729       case SCSI_TASK_REQUEST_ABORT_TASK:
730       case SCSI_TASK_REQUEST_LOGICAL_UNIT_RESET:
731          status = sati_lun_reset_translate_command(sequence, scsi_task, ata_io);
732       break;
733 
734       case SCSI_TASK_REQUEST_ABORT_TASK_SET:
735 #if !defined(DISABLE_SATI_ABORT_TASK_SET)
736          status = sati_abort_task_set_translate_command(sequence, scsi_task, ata_io);
737 #else
738          status = SATI_FAILURE;
739 #endif
740          break;
741       default:
742          status = SATI_FAILURE;
743       break;
744    }
745 
746    return status;
747 }
748 #endif // !defined(DISABLE_SATI_TASK_MANAGEMENT)
749 
750 // -----------------------------------------------------------------------------
751 #if      !defined(DISABLE_SATI_INQUIRY)            \
752       || !defined(DISABLE_SATI_READY_CAPACITY)     \
753       || !defined(DISABLE_SATI_MODE_SENSE)         \
754       || !defined(DISABLE_SATI_MODE_SELECT)        \
755       || !defined(DISABLE_SATI_REASSIGN_BLOCKS)    \
756       || !defined(DISABLE_SATI_START_STOP_UNIT)    \
757       || !defined(DISABLE_SATI_REQUEST_SENSE)      \
758       || !defined(DISABLE_SATI_WRITE_LONG)         \
759       || !defined(DISABLE_SATI_LOG_SENSE)          \
760       || !defined(DISABLE_SATI_UNMAP)
761 
762 static
763 SATI_STATUS sati_check_data_io(
764    SATI_TRANSLATOR_SEQUENCE_T * sequence
765 )
766 {
767    if(sequence->state == SATI_SEQUENCE_STATE_INCOMPLETE)
768    {
769       return SATI_SEQUENCE_INCOMPLETE;
770    }
771    else if(sequence->number_data_bytes_set < sequence->allocation_length)
772    {
773       return SATI_COMPLETE_IO_DONE_EARLY;
774    }
775    else
776    {
777       return SATI_COMPLETE;
778    }
779 }
780 #endif   //    !defined(DISABLE_SATI_INQUIRY)
781          // || !defined(DISABLE_SATI_READY_CAPACITY)
782          // || !defined(DISABLE_SATI_MODE_SENSE)
783          // || !defined(DISABLE_SATI_MODE_SELECT)
784          // || !defined(DISABLE_SATI_REASSIGN_BLOCKS)
785          // || !defined(DISABLE_SATI_START_STOP_UNIT)
786          // || !defined(DISABLE_SATI_REQUEST_SENSE)
787          // || !defined(DISABLE_SATI_WRITE_LONG)
788          // || !defined(DISABLE_SATI_LOG_SENSE)
789          // || !defined(DISABLE_SATI_UNMAP)
790 // -----------------------------------------------------------------------------
791 SATI_STATUS sati_translate_command_response(
792    SATI_TRANSLATOR_SEQUENCE_T * sequence,
793    void                       * scsi_io,
794    void                       * ata_io
795 )
796 {
797    SATI_STATUS   status       = SATI_COMPLETE;
798    U8          * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
799    U8            ata_status;
800 
801    /**
802     * If the device fault bit is set in the status register, then
803     * set the sense data and return.
804     */
805    ata_status = (U8) sati_get_ata_status(register_fis);
806    if (ata_status & ATA_STATUS_REG_DEVICE_FAULT_BIT)
807    {
808       sati_scsi_sense_data_construct(
809          sequence,
810          scsi_io,
811          SCSI_STATUS_CHECK_CONDITION,
812          SCSI_SENSE_HARDWARE_ERROR,
813          SCSI_ASC_INTERNAL_TARGET_FAILURE,
814          SCSI_ASCQ_INTERNAL_TARGET_FAILURE
815       );
816 
817       sequence->device->state = SATI_DEVICE_STATE_DEVICE_FAULT_OCCURRED;
818 
819       // Make sure that the terminate sequence is called to allow
820       // translation logic to perform any cleanup before the IO is completed.
821       sati_sequence_terminate(sequence,
822                               scsi_io,
823                               ata_io);
824 
825       return SATI_FAILURE_CHECK_RESPONSE_DATA;
826    }
827 
828    // Look at the sequence type to determine the response translation method
829    // to invoke.
830    switch (sequence->type)
831    {
832 #if !defined(DISABLE_SATI_TEST_UNIT_READY)
833       case SATI_SEQUENCE_TEST_UNIT_READY:
834          status = sati_test_unit_ready_translate_response(
835                      sequence, scsi_io, ata_io
836                   );
837       break;
838 #endif // !defined(DISABLE_SATI_TEST_UNIT_READY)
839 
840 #if    !defined(DISABLE_SATI_INQUIRY)        \
841     || !defined(DISABLE_SATI_READY_CAPACITY) \
842     || !defined(DISABLE_SATI_MODE_SENSE)
843 
844       case SATI_SEQUENCE_INQUIRY_EXECUTE_DEVICE_DIAG:
845 
846          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
847          {
848             U8  error = (U8) sati_get_ata_error(register_fis);
849             status    = SATI_FAILURE_CHECK_RESPONSE_DATA;
850             sati_translate_error(sequence, scsi_io, error);
851          }
852          else
853          {
854             sati_inquiry_ata_information_finish_translation(
855                sequence,
856                scsi_io,
857                ata_io
858             );
859             status = sati_check_data_io(sequence);
860          }
861       break;
862 
863       case SATI_SEQUENCE_INQUIRY_STANDARD:
864       case SATI_SEQUENCE_INQUIRY_SUPPORTED_PAGES:
865       case SATI_SEQUENCE_INQUIRY_SERIAL_NUMBER:
866       case SATI_SEQUENCE_INQUIRY_BLOCK_DEVICE:
867       case SATI_SEQUENCE_INQUIRY_ATA_INFORMATION:
868       case SATI_SEQUENCE_INQUIRY_DEVICE_ID:
869       case SATI_SEQUENCE_READ_CAPACITY_10:
870       case SATI_SEQUENCE_READ_CAPACITY_16:
871       case SATI_SEQUENCE_MODE_SENSE_6_CACHING:
872       case SATI_SEQUENCE_MODE_SENSE_6_INFORMATIONAL_EXCP_CONTROL:
873       case SATI_SEQUENCE_MODE_SENSE_6_READ_WRITE_ERROR:
874       case SATI_SEQUENCE_MODE_SENSE_6_DISCONNECT_RECONNECT:
875       case SATI_SEQUENCE_MODE_SENSE_6_CONTROL:
876       case SATI_SEQUENCE_MODE_SENSE_6_POWER_CONDITION:
877       case SATI_SEQUENCE_MODE_SENSE_6_ALL_PAGES:
878       case SATI_SEQUENCE_MODE_SENSE_10_CACHING:
879       case SATI_SEQUENCE_MODE_SENSE_10_INFORMATIONAL_EXCP_CONTROL:
880       case SATI_SEQUENCE_MODE_SENSE_10_READ_WRITE_ERROR:
881       case SATI_SEQUENCE_MODE_SENSE_10_CONTROL:
882       case SATI_SEQUENCE_MODE_SENSE_10_POWER_CONDITION:
883       case SATI_SEQUENCE_MODE_SENSE_10_DISCONNECT_RECONNECT:
884       case SATI_SEQUENCE_MODE_SENSE_10_ALL_PAGES:
885          // Did an error occur during the IO request?
886          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
887          {
888             U8  error = (U8) sati_get_ata_error(register_fis);
889             status    = SATI_FAILURE_CHECK_RESPONSE_DATA;
890             sati_translate_error(sequence, scsi_io, error);
891          }
892          else
893          {
894             void * ata_data = sati_cb_get_ata_data_address(ata_io);
895 
896             if(ata_data == NULL)
897             {
898                status = SATI_FAILURE;
899             }
900             else
901             {
902                sati_translate_data(sequence, ata_data, scsi_io);
903                status = sati_check_data_io(sequence);
904             }
905          }
906       break;
907 #endif //    !defined(DISABLE_SATI_INQUIRY)
908        // && !defined(DISABLE_SATI_READY_CAPACITY)
909        // && !defined(DISABLE_SATI_MODE_SENSE)
910 
911 #if !defined(DISABLE_SATI_MODE_SELECT)
912       case SATI_SEQUENCE_MODE_SELECT_MODE_PAGE_CACHING:
913 
914          status = sati_mode_select_translate_response(
915             sequence, scsi_io, ata_io
916                );
917          if(status == SATI_COMPLETE)
918          {
919             status = sati_check_data_io(sequence);
920          }
921          break;
922 
923       case SATI_SEQUENCE_MODE_SELECT_MODE_POWER_CONDITION:
924       case SATI_SEQUENCE_MODE_SELECT_MODE_INFORMATION_EXCEPT_CONTROL:
925          // Did an error occur during the IO request?
926          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
927          {
928             U8  error = (U8) sati_get_ata_error(register_fis);
929             status    = SATI_FAILURE_CHECK_RESPONSE_DATA;
930             sati_translate_error(sequence, scsi_io, error);
931          }
932          else
933          {
934             status = sati_check_data_io(sequence);
935          }
936       break;
937 #endif // !defined(DISABLE_SATI_MODE_SELECT)
938 
939 #if !defined(DISABLE_SATI_WRITE_AND_VERIFY)
940       case SATI_SEQUENCE_WRITE_AND_VERIFY:
941 
942          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
943          {
944             U8  error = (U8) sati_get_ata_error(register_fis);
945             sati_translate_error(sequence, scsi_io, error);
946 
947             return SATI_FAILURE_CHECK_RESPONSE_DATA;
948          }
949          else
950          {
951             status = sati_write_and_verify_translate_response(
952                         sequence,
953                         scsi_io,
954                         ata_io
955                      );
956          }
957       break;
958 #endif // !defined(DISABLE_SATI_WRITE_AND_VERIFY)
959 
960       case SATI_SEQUENCE_READ_6:
961       case SATI_SEQUENCE_READ_10:
962       case SATI_SEQUENCE_READ_12:
963       case SATI_SEQUENCE_READ_16:
964       case SATI_SEQUENCE_WRITE_6:
965       case SATI_SEQUENCE_WRITE_10:
966       case SATI_SEQUENCE_WRITE_12:
967       case SATI_SEQUENCE_WRITE_16:
968       case SATI_SEQUENCE_VERIFY_10:
969       case SATI_SEQUENCE_VERIFY_12:
970       case SATI_SEQUENCE_VERIFY_16:
971       case SATI_SEQUENCE_SYNCHRONIZE_CACHE:
972          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
973          {
974             U8  error = (U8) sati_get_ata_error(register_fis);
975             status    = SATI_FAILURE_CHECK_RESPONSE_DATA;
976             sati_translate_error(sequence, scsi_io, error);
977 
978             if(sequence->state == SATI_SEQUENCE_STATE_READ_ERROR )
979             {
980                sati_scsi_read_error_sense_construct(
981                   sequence,
982                   scsi_io,
983                   ata_io,
984                   SCSI_STATUS_CHECK_CONDITION,
985                   SCSI_SENSE_MEDIUM_ERROR,
986                   SCSI_ASC_UNRECOVERED_READ_ERROR,
987                   SCSI_ASCQ_UNRECOVERED_READ_ERROR
988                );
989                sequence->state = SATI_SEQUENCE_STATE_FINAL;
990             }
991          }
992          else
993          {
994             // We haven't satisified the transfer count from the original
995             // SCSI CDB.  As a result, we need to re-issue the command
996             // with updated logical block address and transfer count.
997             if (sequence->command_specific_data.scratch)
998             {
999                /** @todo update the contents of the CDB directly?  Should be
1000                 *  done during previous command translation?
1001                 */
1002                status = SATI_SEQUENCE_INCOMPLETE;
1003             }
1004          }
1005       break;
1006 
1007 #if !defined(DISABLE_SATI_READ_BUFFER)
1008       case SATI_SEQUENCE_READ_BUFFER:
1009          status = sati_read_buffer_translate_response(
1010                      sequence, scsi_io, ata_io
1011                   );
1012 
1013          if(status == SATI_COMPLETE)
1014          {
1015             status = sati_check_data_io(sequence);
1016          }
1017       break;
1018 #endif //!defined(DISABLE_SATI_READ_BUFFER)
1019 
1020 #if !defined(DISABLE_SATI_WRITE_BUFFER)
1021       case SATI_SEQUENCE_WRITE_BUFFER:
1022       case SATI_SEQUENCE_WRITE_BUFFER_MICROCODE:
1023          status = sati_write_buffer_translate_response(
1024                      sequence, scsi_io, ata_io
1025                   );
1026       break;
1027 #endif //!defined(DISABLE_SATI_WRITE_BUFFER)
1028 
1029 #if !defined(DISABLE_SATI_REASSIGN_BLOCKS)
1030       case SATI_SEQUENCE_REASSIGN_BLOCKS:
1031          status = sati_reassign_blocks_translate_response(
1032                      sequence, scsi_io, ata_io
1033                   );
1034          if(status == SATI_COMPLETE)
1035          {
1036             status = sati_check_data_io(sequence);
1037          }
1038       break;
1039 #endif // !defined(DISABLE_SATI_REASSIGN_BLOCKS)
1040 
1041 #if !defined(DISABLE_SATI_START_STOP_UNIT)
1042       case SATI_SEQUENCE_START_STOP_UNIT:
1043          status = sati_start_stop_unit_translate_response(
1044                      sequence, scsi_io, ata_io
1045                   );
1046          if(status == SATI_COMPLETE)
1047          {
1048             status = sati_check_data_io(sequence);
1049          }
1050       break;
1051 #endif // !defined(DISABLE_SATI_START_STOP_UNIT)
1052 
1053 #if !defined(DISABLE_SATI_REQUEST_SENSE)
1054       case SATI_SEQUENCE_REQUEST_SENSE_SMART_RETURN_STATUS:
1055       case SATI_SEQUENCE_REQUEST_SENSE_CHECK_POWER_MODE:
1056          status = sati_request_sense_translate_response(
1057                      sequence, scsi_io, ata_io
1058                   );
1059          if(status == SATI_COMPLETE)
1060          {
1061             status = sati_check_data_io(sequence);
1062          }
1063       break;
1064 #endif // !defined(DISABLE_SATI_REQUEST_SENSE)
1065 
1066 #if !defined(DISABLE_SATI_WRITE_LONG)
1067       case SATI_SEQUENCE_WRITE_LONG:
1068          status = sati_write_long_translate_response(
1069                      sequence, scsi_io, ata_io
1070                   );
1071          if(status == SATI_COMPLETE)
1072          {
1073             status = sati_check_data_io(sequence);
1074          }
1075       break;
1076 #endif // !defined(DISABLE_SATI_WRITE_LONG)
1077 
1078 #if !defined(DISABLE_SATI_LOG_SENSE)
1079       case SATI_SEQUENCE_LOG_SENSE_SUPPORTED_LOG_PAGE:
1080       case SATI_SEQUENCE_LOG_SENSE_SELF_TEST_LOG_PAGE:
1081       case SATI_SEQUENCE_LOG_SENSE_EXTENDED_SELF_TEST_LOG_PAGE:
1082       case SATI_SEQUENCE_LOG_SENSE_INFO_EXCEPTION_LOG_PAGE:
1083          status = sati_log_sense_translate_response(
1084                      sequence, scsi_io, ata_io
1085                   );
1086          if(status == SATI_COMPLETE)
1087          {
1088             status = sati_check_data_io(sequence);
1089          }
1090       break;
1091 #endif // !defined(DISABLE_SATI_LOG_SENSE)
1092 
1093 #if !defined(DISABLE_SATI_UNMAP)
1094       case SATI_SEQUENCE_UNMAP:
1095          status = sati_unmap_translate_response(
1096                      sequence, scsi_io, ata_io
1097                   );
1098       break;
1099 #endif // !defined(DISABLE_SATI_UNMAP)
1100 
1101 #if !defined(DISABLE_SATI_ATA_PASSTHROUGH)
1102       case SATI_SEQUENCE_ATA_PASSTHROUGH_12:
1103       case SATI_SEQUENCE_ATA_PASSTHROUGH_16:
1104          status = sati_passthrough_translate_response(
1105                      sequence, scsi_io, ata_io
1106                   );
1107       break;
1108 #endif // !defined(DISABLE_SATI_ATA_PASSTHROUGH)
1109 
1110       default:
1111          status = SATI_FAILURE_INVALID_SEQUENCE_TYPE;
1112       break;
1113    }
1114 
1115    return status;
1116 }
1117 
1118 // -----------------------------------------------------------------------------
1119 
1120 #if !defined(DISABLE_SATI_TASK_MANAGEMENT)
1121 SATI_STATUS sati_translate_task_response(
1122    SATI_TRANSLATOR_SEQUENCE_T * sequence,
1123    void                       * scsi_io,
1124    void                       * ata_io
1125 )
1126 {
1127    SATI_STATUS   status       = SATI_FAILURE_CHECK_RESPONSE_DATA;
1128    U8          * register_fis = sati_cb_get_d2h_register_fis_address(ata_io);
1129    U8            ata_status;
1130 
1131    /**
1132     * If the device fault bit is set in the status register, then
1133     * set the sense data and return.
1134     */
1135    ata_status = (U8) sati_get_ata_status(register_fis);
1136    if (ata_status & ATA_STATUS_REG_DEVICE_FAULT_BIT)
1137    {
1138       sati_scsi_response_data_construct(
1139          sequence,
1140          scsi_io,
1141          SCSI_TASK_MGMT_FUNC_FAILED
1142       );
1143       return SATI_FAILURE_CHECK_RESPONSE_DATA;
1144    }
1145 
1146    // Look at the sequence type to determine the response translation method
1147    // to invoke.
1148    switch (sequence->type)
1149    {
1150       case SATI_SEQUENCE_LUN_RESET:
1151          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
1152          {
1153             sati_scsi_response_data_construct(
1154                sequence, scsi_io, SCSI_TASK_MGMT_FUNC_FAILED);
1155          }
1156          else
1157          {
1158             sati_scsi_response_data_construct(
1159                sequence, scsi_io, SCSI_TASK_MGMT_FUNC_COMPLETE);
1160          }
1161 
1162          status = SATI_COMPLETE;
1163       break;
1164 
1165 #if !defined(DISABLE_SATI_ABORT_TASK_SET)
1166       case SATI_SEQUENCE_ABORT_TASK_SET:
1167          if (ata_status & ATA_STATUS_REG_ERROR_BIT)
1168          {
1169             sati_scsi_response_data_construct(
1170                sequence, scsi_io, SCSI_TASK_MGMT_FUNC_FAILED);
1171          }
1172          else
1173          {
1174             void * ata_data = sati_cb_get_ata_data_address(ata_io);
1175 
1176             if(ata_data == NULL)
1177             {
1178                status = SATI_FAILURE;
1179             }
1180             else
1181             {
1182                status = sati_abort_task_set_translate_data(
1183                            sequence,
1184                            ata_data,
1185                            scsi_io
1186                         );
1187             }
1188          }
1189       break;
1190 #endif // !defined(DISABLE_SATI_ABORT_TASK_SET)
1191 
1192       default:
1193          status = SATI_FAILURE_INVALID_SEQUENCE_TYPE;
1194       break;
1195    }
1196 
1197    return status;
1198 }
1199 #endif // !defined(DISABLE_SATI_TASK_MANAGEMENT)
1200 
1201 #if !defined(ENABLE_MINIMUM_MEMORY_MODE)
1202 U32 sati_get_sat_compliance_version(
1203    void
1204 )
1205 {
1206    return 2;  // Compliant with SAT-2.
1207 }
1208 
1209 U32 sati_get_sat_compliance_version_revision(
1210    void
1211 )
1212 {
1213    return 7;  // Compliant with SAT-2 revision 7.
1214 }
1215 
1216 #endif // !defined(ENABLE_MINIMUM_MEMORY_MODE)
1217 
1218 U16 sati_get_number_data_bytes_set(
1219    SATI_TRANSLATOR_SEQUENCE_T * sequence
1220 )
1221 {
1222    return sequence->number_data_bytes_set;
1223 }
1224 
1225 void sati_sequence_construct(
1226    SATI_TRANSLATOR_SEQUENCE_T * sequence
1227 )
1228 {
1229    sequence->state = SATI_SEQUENCE_STATE_INITIAL;
1230 }
1231 
1232 void sati_sequence_terminate(
1233    SATI_TRANSLATOR_SEQUENCE_T * sequence,
1234    void                       * scsi_io,
1235    void                       * ata_io
1236 )
1237 {
1238    // Decode the sequence type to determine how to handle the termination
1239    // of the translation method.
1240    switch (sequence->type)
1241    {
1242    case SATI_SEQUENCE_UNMAP:
1243       sati_unmap_terminate(sequence,scsi_io,ata_io);
1244    break;
1245    }
1246 }
1247