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 *
59 * @brief This file contains the method implementations for the
60 * SCIF_SAS_STP_IO_REQUEST object. The contents will implement
61 * SATA/STP specific functionality.
62 */
63
64 #include <dev/isci/scil/scif_sas_stp_io_request.h>
65 #include <dev/isci/scil/scif_sas_stp_remote_device.h>
66 #include <dev/isci/scil/scif_sas_logger.h>
67 #include <dev/isci/scil/scif_sas_controller.h>
68
69 #include <dev/isci/scil/sci_status.h>
70 #include <dev/isci/scil/scic_io_request.h>
71
72 #include <dev/isci/scil/sati.h>
73 #include <dev/isci/scil/sati_atapi.h>
74 #include <dev/isci/scil/intel_sat.h>
75 #include <dev/isci/scil/sati_util.h>
76 #include <dev/isci/scil/sati_callbacks.h>
77
78 //******************************************************************************
79 // P R I V A T E M E T H O D S
80 //******************************************************************************
81
82 /**
83 * @brief This method provides SATA/STP CONSTRUCTED state specific handling
84 * for when the user attempts to start the supplied IO request. It
85 * will allocate NCQ tags if necessary.
86 *
87 * @param[in] io_request This parameter specifies the IO request object
88 * to be started.
89 *
90 * @return This method returns a value indicating if the IO request was
91 * successfully started or not.
92 * @retval SCI_SUCCESS This return value indicates successful starting
93 * of the IO request.
94 */
95 static
scif_sas_stp_io_request_constructed_start_handler(SCI_BASE_REQUEST_T * io_request)96 SCI_STATUS scif_sas_stp_io_request_constructed_start_handler(
97 SCI_BASE_REQUEST_T * io_request
98 )
99 {
100 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *) io_request;
101
102 SCIF_LOG_TRACE((
103 sci_base_object_get_logger(io_request),
104 SCIF_LOG_OBJECT_IO_REQUEST,
105 "scif_sas_stp_io_request_constructed_start_handler(0x%x) enter\n",
106 io_request
107 ));
108
109 if (fw_io->parent.stp.sequence.protocol == SAT_PROTOCOL_FPDMA)
110 {
111 SATA_FIS_REG_H2D_T * fis;
112
113 // For NCQ, we need to attempt to allocate an available tag.
114 fw_io->parent.stp.ncq_tag = scif_sas_stp_remote_device_allocate_ncq_tag(
115 fw_io->parent.device
116 );
117
118 if (fw_io->parent.stp.ncq_tag == SCIF_SAS_INVALID_NCQ_TAG)
119 return SCI_FAILURE_NO_NCQ_TAG_AVAILABLE;
120
121 // Set the NCQ tag in the host to device register FIS (upper 5 bits
122 // of the 8-bit sector count register).
123 fis = scic_stp_io_request_get_h2d_reg_address(fw_io->parent.core_object);
124 fis->sector_count = (fw_io->parent.stp.ncq_tag << 3);
125
126 // The Core also requires that we inform it separately regarding the
127 // NCQ tag for this IO.
128 scic_stp_io_request_set_ncq_tag(
129 fw_io->parent.core_object, fw_io->parent.stp.ncq_tag
130 );
131 }
132
133 return SCI_SUCCESS;
134 }
135
136 /**
137 * @brief This method provides SATA/STP CONSTRUCTED state specific handling
138 * for when the user attempts to complete the supplied IO request.
139 * This method will be invoked in the event the call to start the
140 * core IO request fails for some reason. In this situation, the
141 * NCQ tag will be freed.
142 *
143 * @param[in] io_request This parameter specifies the IO request object
144 * to be started.
145 *
146 * @return This method returns a value indicating if the IO request was
147 * successfully started or not.
148 * @retval SCI_SUCCESS This return value indicates successful starting
149 * of the IO request.
150 */
151 static
scif_sas_stp_io_request_constructed_complete_handler(SCI_BASE_REQUEST_T * io_request)152 SCI_STATUS scif_sas_stp_io_request_constructed_complete_handler(
153 SCI_BASE_REQUEST_T * io_request
154 )
155 {
156 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *) io_request;
157
158 SCIF_LOG_TRACE((
159 sci_base_object_get_logger(io_request),
160 SCIF_LOG_OBJECT_IO_REQUEST,
161 "scif_sas_stp_io_request_constructed_complete_handler(0x%x) enter\n",
162 io_request
163 ));
164
165 if (fw_io->parent.stp.sequence.protocol == SAT_PROTOCOL_FPDMA)
166 {
167 // For NCQ, we need to return the tag back to the free pool.
168 if (fw_io->parent.stp.ncq_tag != SCIF_SAS_INVALID_NCQ_TAG)
169 scif_sas_stp_remote_device_free_ncq_tag(
170 fw_io->parent.device, fw_io->parent.stp.ncq_tag
171 );
172 }
173
174 sati_sequence_terminate(&fw_io->parent.stp.sequence, fw_io, fw_io);
175
176 return SCI_SUCCESS;
177 }
178 /**
179 * @brief This method provides SATA/STP STARTED state specific handling for
180 * when the user attempts to complete the supplied IO request.
181 * It will perform data/response translation and free NCQ tags
182 * if necessary.
183 *
184 * @param[in] io_request This parameter specifies the IO request object
185 * to be started.
186 *
187 * @return This method returns a value indicating if the IO request was
188 * successfully completed or not.
189 */
190 static
scif_sas_stp_core_cb_io_request_complete_handler(SCIF_SAS_CONTROLLER_T * fw_controller,SCIF_SAS_REMOTE_DEVICE_T * fw_device,SCIF_SAS_REQUEST_T * fw_request,SCI_STATUS * completion_status)191 SCI_STATUS scif_sas_stp_core_cb_io_request_complete_handler(
192 SCIF_SAS_CONTROLLER_T * fw_controller,
193 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
194 SCIF_SAS_REQUEST_T * fw_request,
195 SCI_STATUS * completion_status
196 )
197 {
198 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *) fw_request;
199
200 SCIF_LOG_TRACE((
201 sci_base_object_get_logger(fw_controller),
202 SCIF_LOG_OBJECT_IO_REQUEST,
203 "scif_sas_stp_core_cb_io_request_complete_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
204 fw_controller, fw_device, fw_request, *completion_status
205 ));
206
207 if (fw_io->parent.stp.sequence.protocol == SAT_PROTOCOL_FPDMA)
208 scif_sas_stp_remote_device_free_ncq_tag(
209 fw_request->device, fw_io->parent.stp.ncq_tag
210 );
211
212 // Translating the response is only necessary if:
213 // - some sort of error occurred resulting in having the error bit
214 // set in the ATA status register and values to decode in the
215 // ATA error register.
216 // - the command returns information in the register FIS itself,
217 // which requires translation.
218 // - the request completed ok but the sequence requires a callback
219 // to possibly continue the translation
220 if ((*completion_status == SCI_FAILURE_IO_RESPONSE_VALID) ||
221 ((sati_cb_do_translate_response(fw_request)) &&
222 (*completion_status != SCI_FAILURE_IO_TERMINATED)))
223 {
224 SATI_STATUS sati_status = sati_translate_command_response(
225 &fw_io->parent.stp.sequence, fw_io, fw_io
226 );
227 if (sati_status == SATI_COMPLETE)
228 *completion_status = SCI_SUCCESS;
229 else if (sati_status == SATI_FAILURE_CHECK_RESPONSE_DATA)
230 *completion_status = SCI_FAILURE_IO_RESPONSE_VALID;
231 else if (sati_status == SATI_SEQUENCE_INCOMPLETE)
232 {
233 // The translation indicates that additional SATA requests are
234 // necessary to finish the original SCSI request. As a result,
235 // do not complete the IO and begin the next stage of the
236 // translation.
237 return SCI_WARNING_SEQUENCE_INCOMPLETE;
238 }
239 else if (sati_status == SATI_COMPLETE_IO_DONE_EARLY)
240 *completion_status = SCI_SUCCESS_IO_DONE_EARLY;
241 else
242 {
243 // Something unexpected occurred during translation. Fail the
244 // IO request to the user.
245 *completion_status = SCI_FAILURE;
246 }
247 }
248 else if (*completion_status != SCI_SUCCESS)
249 {
250 SCIF_LOG_INFO((
251 sci_base_object_get_logger(fw_controller),
252 SCIF_LOG_OBJECT_IO_REQUEST,
253 "Sequence Terminated(0x%x, 0x%x, 0x%x)\n",
254 fw_controller, fw_device, fw_request
255 ));
256
257 sati_sequence_terminate(&fw_io->parent.stp.sequence, fw_io, fw_io);
258 }
259
260 return SCI_SUCCESS;
261 }
262
263 #if !defined(DISABLE_ATAPI)
264 /**
265 * @brief This method provides STP PACKET io request STARTED state specific handling for
266 * when the user attempts to complete the supplied IO request.
267 * It will perform data/response translation.
268 *
269 * @param[in] io_request This parameter specifies the IO request object
270 * to be started.
271 *
272 * @return This method returns a value indicating if the IO request was
273 * successfully completed or not.
274 */
275 static
scif_sas_stp_core_cb_packet_io_request_complete_handler(SCIF_SAS_CONTROLLER_T * fw_controller,SCIF_SAS_REMOTE_DEVICE_T * fw_device,SCIF_SAS_REQUEST_T * fw_request,SCI_STATUS * completion_status)276 SCI_STATUS scif_sas_stp_core_cb_packet_io_request_complete_handler(
277 SCIF_SAS_CONTROLLER_T * fw_controller,
278 SCIF_SAS_REMOTE_DEVICE_T * fw_device,
279 SCIF_SAS_REQUEST_T * fw_request,
280 SCI_STATUS * completion_status
281 )
282 {
283 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T *) fw_request;
284 SATI_STATUS sati_status;
285
286 SCIF_LOG_TRACE((
287 sci_base_object_get_logger(fw_controller),
288 SCIF_LOG_OBJECT_IO_REQUEST,
289 "scif_sas_stp_packet_core_cb_io_request_complete_handler(0x%x, 0x%x, 0x%x, 0x%x) enter\n",
290 fw_controller, fw_device, fw_request, *completion_status
291 ));
292
293 if (*completion_status == SCI_FAILURE_IO_RESPONSE_VALID)
294 {
295 sati_status = sati_atapi_translate_command_response(
296 &fw_io->parent.stp.sequence, fw_io, fw_io
297 );
298
299 if (sati_status == SATI_COMPLETE)
300 *completion_status = SCI_SUCCESS;
301 else if (sati_status == SATI_FAILURE_CHECK_RESPONSE_DATA)
302 *completion_status = SCI_FAILURE_IO_RESPONSE_VALID;
303 else if (sati_status == SATI_SEQUENCE_INCOMPLETE)
304 {
305 // The translation indicates that additional REQUEST SENSE command is
306 // necessary to finish the original SCSI request. As a result,
307 // do not complete the IO and begin the next stage of the IO.
308 return SCI_WARNING_SEQUENCE_INCOMPLETE;
309 }
310 else
311 {
312 // Something unexpected occurred during translation. Fail the
313 // IO request to the user.
314 *completion_status = SCI_FAILURE;
315 }
316 }
317 else if (*completion_status == SCI_SUCCESS &&
318 fw_request->stp.sequence.state == SATI_SEQUENCE_STATE_INCOMPLETE)
319 {
320 //The internal Request Sense command is completed successfully.
321 sati_atapi_translate_request_sense_response(
322 &fw_io->parent.stp.sequence, fw_io, fw_io
323 );
324
325 *completion_status = SCI_FAILURE_IO_RESPONSE_VALID;
326 }
327
328 return SCI_SUCCESS;
329 }
330 #endif // !defined(DISABLE_ATAPI)
331
332 //******************************************************************************
333 // P R O T E C T E D M E T H O D S
334 //******************************************************************************
335
336 /**
337 * @brief This method will construct the SATA/STP specific IO request
338 * object utilizing the SATI.
339 *
340 * @pre The scif_sas_request_construct() method should be invoked before
341 * calling this method.
342 *
343 * @param[in,out] stp_io_request This parameter specifies the stp_io_request
344 * to be constructed.
345 *
346 * @return Indicate if the construction was successful.
347 * @return SCI_FAILURE_NO_NCQ_TAG_AVAILABLE
348 * @return SCI_SUCCESS_IO_COMPLETE_BEFORE_START
349 * @return SCI_FAILURE_IO_RESPONSE_VALID
350 * @return SCI_FAILURE This return value indicates a change in the translator
351 * where a new return code has been given, but is not yet understood
352 * by this routine.
353 */
scif_sas_stp_io_request_construct(SCIF_SAS_IO_REQUEST_T * fw_io)354 SCI_STATUS scif_sas_stp_io_request_construct(
355 SCIF_SAS_IO_REQUEST_T * fw_io
356 )
357 {
358 SATI_STATUS sati_status;
359 SCI_STATUS sci_status = SCI_FAILURE;
360 SCIF_SAS_REMOTE_DEVICE_T * fw_device = fw_io->parent.device;
361
362 SCIF_LOG_TRACE((
363 sci_base_object_get_logger(fw_io),
364 SCIF_LOG_OBJECT_IO_REQUEST,
365 "scif_sas_stp_io_request_construct(0x%x) enter\n",
366 fw_io
367 ));
368
369 // The translator will indirectly invoke core methods to set the fields
370 // of the ATA register FIS inside of this method.
371 sati_status = sati_translate_command(
372 &fw_io->parent.stp.sequence,
373 &fw_device->protocol_device.stp_device.sati_device,
374 fw_io,
375 fw_io
376 );
377
378 if (sati_status == SATI_SUCCESS)
379 {
380 // Allow the core to finish construction of the IO request.
381 sci_status = scic_io_request_construct_basic_sata(fw_io->parent.core_object);
382 fw_io->parent.state_handlers = &stp_io_request_constructed_handlers;
383 fw_io->parent.protocol_complete_handler
384 = scif_sas_stp_core_cb_io_request_complete_handler;
385 }
386 else if (sati_status == SATI_SUCCESS_SGL_TRANSLATED)
387 {
388 SCIC_IO_SATA_PARAMETERS_T parms;
389 parms.do_translate_sgl = FALSE;
390
391 // The translation actually already caused translation of the
392 // scatter gather list. So, call into the core through an API
393 // that will not attempt to translate the SGL.
394 scic_io_request_construct_advanced_sata(
395 fw_io->parent.core_object, &parms
396 );
397 fw_io->parent.state_handlers = &stp_io_request_constructed_handlers;
398 fw_io->parent.protocol_complete_handler
399 = scif_sas_stp_core_cb_io_request_complete_handler;
400 // Done with translation
401 sci_status = SCI_SUCCESS;
402 }
403 else if (sati_status == SATI_COMPLETE)
404 sci_status = SCI_SUCCESS_IO_COMPLETE_BEFORE_START;
405 else if (sati_status == SATI_FAILURE_CHECK_RESPONSE_DATA)
406 sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
407 else
408 {
409 SCIF_LOG_ERROR((
410 sci_base_object_get_logger(fw_io),
411 SCIF_LOG_OBJECT_IO_REQUEST,
412 "Unexpected SAT translation failure 0x%x\n",
413 fw_io
414 ));
415 }
416
417 return sci_status;
418 }
419
420
421 #if !defined(DISABLE_ATAPI)
422 /**
423 * @brief This method will construct the STP PACKET protocol specific IO
424 * request object.
425 *
426 * @pre The scif_sas_request_construct() method should be invoked before
427 * calling this method.
428 *
429 * @param[in,out] fw_io This parameter specifies the stp packet io request
430 * to be constructed.
431 *
432 * @return Indicate if the construction was successful.
433 * @return SCI_SUCCESS_IO_COMPLETE_BEFORE_START
434 * @return SCI_FAILURE_IO_RESPONSE_VALID
435 * @return SCI_FAILURE This return value indicates a change in the translator
436 * where a new return code has been given, but is not yet understood
437 * by this routine.
438 */
scif_sas_stp_packet_io_request_construct(SCIF_SAS_IO_REQUEST_T * fw_io)439 SCI_STATUS scif_sas_stp_packet_io_request_construct(
440 SCIF_SAS_IO_REQUEST_T * fw_io
441 )
442 {
443 SATI_STATUS sati_status;
444 SCI_STATUS sci_status = SCI_FAILURE;
445 SCIF_SAS_REMOTE_DEVICE_T * fw_device = fw_io->parent.device;
446
447 SCIF_LOG_TRACE((
448 sci_base_object_get_logger(fw_io),
449 SCIF_LOG_OBJECT_IO_REQUEST,
450 "scif_sas_stp_packet_io_request_construct(0x%x) enter\n",
451 fw_io
452 ));
453
454 sati_status = sati_atapi_translate_command(
455 &fw_io->parent.stp.sequence,
456 &fw_device->protocol_device.stp_device.sati_device,
457 fw_io,
458 fw_io
459 );
460
461 if (sati_status == SATI_SUCCESS)
462 {
463 // Allow the core to finish construction of the IO request.
464 sci_status = scic_io_request_construct_basic_sata(fw_io->parent.core_object);
465
466 fw_io->parent.protocol_complete_handler
467 = scif_sas_stp_core_cb_packet_io_request_complete_handler;
468 }
469 else if (sati_status == SATI_COMPLETE)
470 sci_status = SCI_SUCCESS_IO_COMPLETE_BEFORE_START;
471 else if (sati_status == SATI_FAILURE_CHECK_RESPONSE_DATA)
472 sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
473 else
474 {
475 SCIF_LOG_ERROR((
476 sci_base_object_get_logger(fw_io),
477 SCIF_LOG_OBJECT_IO_REQUEST,
478 "Unexpected SAT ATAPI translation failure 0x%x\n",
479 fw_io
480 ));
481 }
482
483 return sci_status;
484 }
485 #endif
486
487
488 #if !defined(DISABLE_ATAPI)
489 /**
490 * @brief This method will get the number of bytes transferred in an packet IO.
491 *
492 * @param[in] fw_io This parameter specifies the stp packet io request whose
493 * actual transferred length is to be retrieved.
494 *
495 * @return Actual length of transferred data.
496 */
scif_sas_stp_packet_io_request_get_number_of_bytes_transferred(SCIF_SAS_IO_REQUEST_T * fw_io)497 U32 scif_sas_stp_packet_io_request_get_number_of_bytes_transferred(
498 SCIF_SAS_IO_REQUEST_T * fw_io
499 )
500 {
501 SCI_IO_REQUEST_HANDLE_T scic_io = scif_io_request_get_scic_handle(fw_io);
502 SCI_IO_STATUS io_status = scic_request_get_sci_status (scic_io);
503 U32 actual_data_length;
504
505 if (io_status == SCI_IO_FAILURE_RESPONSE_VALID)
506 actual_data_length = 0;
507 else if (io_status == SCI_IO_SUCCESS_IO_DONE_EARLY)
508 {
509 actual_data_length = sati_atapi_translate_number_of_bytes_transferred(
510 &fw_io->parent.stp.sequence, fw_io, fw_io);
511
512 if (actual_data_length == 0)
513 actual_data_length =
514 scic_io_request_get_number_of_bytes_transferred(scic_io);
515 }
516 else
517 actual_data_length =
518 scic_io_request_get_number_of_bytes_transferred(scic_io);
519
520 return actual_data_length;
521 }
522 #endif
523
524
525 //******************************************************************************
526 // P U B L I C M E T H O D S
527 //******************************************************************************
528
scic_cb_io_request_do_copy_rx_frames(void * scic_user_io_request)529 BOOL scic_cb_io_request_do_copy_rx_frames(
530 void * scic_user_io_request
531 )
532 {
533 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) scic_user_io_request;
534
535 SCIF_LOG_TRACE((
536 sci_base_object_get_logger(fw_io),
537 SCIF_LOG_OBJECT_IO_REQUEST,
538 "scic_cb_io_request_do_copy_rx_frames(0x%x) enter\n",
539 fw_io
540 ));
541
542 // If the translation was a PIO DATA IN (i.e. read) and the request
543 // was actually a READ payload operation, then copy the data, since
544 // there will be SGL space allocated for the transfer.
545 if (fw_io->parent.stp.sequence.protocol == SAT_PROTOCOL_PIO_DATA_IN)
546 {
547 if (
548 (fw_io->parent.stp.sequence.type == SATI_SEQUENCE_ATA_PASSTHROUGH_12)
549 || (fw_io->parent.stp.sequence.type == SATI_SEQUENCE_ATA_PASSTHROUGH_16)
550 || (
551 (fw_io->parent.stp.sequence.type >= SATI_SEQUENCE_TYPE_READ_MIN)
552 && (fw_io->parent.stp.sequence.type <= SATI_SEQUENCE_TYPE_READ_MAX)
553 )
554 )
555 {
556 SCIF_LOG_TRACE((
557 sci_base_object_get_logger(fw_io),
558 SCIF_LOG_OBJECT_IO_REQUEST,
559 "scic_cb_io_request_do_copy_rx_frames(0x%x) TRUE\n",
560 fw_io
561 ));
562 return TRUE;
563 }
564 }
565
566 // For all other requests we leave the data in the core buffers.
567 // This allows the translation to translate without having to have
568 // separate space allocated into which to copy the data.
569 return FALSE;
570 }
571
572 // ---------------------------------------------------------------------------
573
scic_cb_request_get_sat_protocol(void * scic_user_io_request)574 U8 scic_cb_request_get_sat_protocol(
575 void * scic_user_io_request
576 )
577 {
578 SCIF_SAS_IO_REQUEST_T * fw_io = (SCIF_SAS_IO_REQUEST_T*) scic_user_io_request;
579
580 return fw_io->parent.stp.sequence.protocol;
581 }
582
scic_cb_io_request_get_virtual_address_from_sgl(void * scic_user_io_request,U32 byte_offset)583 U8 *scic_cb_io_request_get_virtual_address_from_sgl(
584 void * scic_user_io_request,
585 U32 byte_offset
586 )
587 {
588 SCIF_SAS_REQUEST_T *fw_request =
589 (SCIF_SAS_REQUEST_T *) sci_object_get_association(scic_user_io_request);
590
591 return scif_cb_io_request_get_virtual_address_from_sgl(
592 sci_object_get_association(fw_request),
593 byte_offset
594 );
595 }
596
597 #ifdef ENABLE_OSSL_COPY_BUFFER
scic_cb_io_request_copy_buffer(void * scic_user_io_request,U8 * source_addr,U32 offset,U32 length)598 void scic_cb_io_request_copy_buffer(
599 void * scic_user_io_request,
600 U8 *source_addr,
601 U32 offset,
602 U32 length
603 )
604 {
605 SCIF_SAS_REQUEST_T *fw_request =
606 (SCIF_SAS_REQUEST_T *)sci_object_get_association(scic_user_io_request);
607
608 return scif_cb_io_request_copy_buffer(
609 sci_object_get_association(fw_request),
610 source_addr,
611 offset,
612 length
613 );
614 }
615 #endif
616 // ---------------------------------------------------------------------------
617
618 SCI_BASE_REQUEST_STATE_HANDLER_T stp_io_request_constructed_handlers =
619 {
620 scif_sas_stp_io_request_constructed_start_handler,
621 scif_sas_io_request_constructed_abort_handler,
622 scif_sas_stp_io_request_constructed_complete_handler,
623 scif_sas_io_request_default_destruct_handler
624 };
625
626