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 */
sati_translate_error(SATI_TRANSLATOR_SEQUENCE_T * sequence,void * scsi_io,U8 error)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
sati_translate_data(SATI_TRANSLATOR_SEQUENCE_T * sequence,void * ata_input_data,void * scsi_io)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
sati_translate_command(SATI_TRANSLATOR_SEQUENCE_T * sequence,SATI_DEVICE_T * sati_device,void * scsi_io,void * ata_io)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)
sati_translate_task_management(SATI_TRANSLATOR_SEQUENCE_T * sequence,SATI_DEVICE_T * sati_device,void * scsi_task,void * ata_io)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
sati_check_data_io(SATI_TRANSLATOR_SEQUENCE_T * sequence)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 // -----------------------------------------------------------------------------
sati_translate_command_response(SATI_TRANSLATOR_SEQUENCE_T * sequence,void * scsi_io,void * ata_io)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)
sati_translate_task_response(SATI_TRANSLATOR_SEQUENCE_T * sequence,void * scsi_io,void * ata_io)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)
sati_get_sat_compliance_version(void)1202 U32 sati_get_sat_compliance_version(
1203 void
1204 )
1205 {
1206 return 2; // Compliant with SAT-2.
1207 }
1208
sati_get_sat_compliance_version_revision(void)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
sati_get_number_data_bytes_set(SATI_TRANSLATOR_SEQUENCE_T * sequence)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
sati_sequence_construct(SATI_TRANSLATOR_SEQUENCE_T * sequence)1225 void sati_sequence_construct(
1226 SATI_TRANSLATOR_SEQUENCE_T * sequence
1227 )
1228 {
1229 sequence->state = SATI_SEQUENCE_STATE_INITIAL;
1230 }
1231
sati_sequence_terminate(SATI_TRANSLATOR_SEQUENCE_T * sequence,void * scsi_io,void * ata_io)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