2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 #include <scsi/scsi_cmnd.h>
60 #include "scu_completion_codes.h"
61 #include "scu_event_codes.h"
66 const char *req_state_name(enum sci_base_request_states state
)
68 static const char * const strings
[] = REQUEST_STATES
;
70 return strings
[state
];
74 static struct scu_sgl_element_pair
*to_sgl_element_pair(struct isci_request
*ireq
,
78 return &ireq
->tc
->sgl_pair_ab
;
80 return &ireq
->tc
->sgl_pair_cd
;
84 return &ireq
->sg_table
[idx
- 2];
87 static dma_addr_t
to_sgl_element_pair_dma(struct isci_host
*ihost
,
88 struct isci_request
*ireq
, u32 idx
)
93 offset
= (void *) &ireq
->tc
->sgl_pair_ab
-
94 (void *) &ihost
->task_context_table
[0];
95 return ihost
->tc_dma
+ offset
;
96 } else if (idx
== 1) {
97 offset
= (void *) &ireq
->tc
->sgl_pair_cd
-
98 (void *) &ihost
->task_context_table
[0];
99 return ihost
->tc_dma
+ offset
;
102 return sci_io_request_get_dma_addr(ireq
, &ireq
->sg_table
[idx
- 2]);
105 static void init_sgl_element(struct scu_sgl_element
*e
, struct scatterlist
*sg
)
107 e
->length
= sg_dma_len(sg
);
108 e
->address_upper
= upper_32_bits(sg_dma_address(sg
));
109 e
->address_lower
= lower_32_bits(sg_dma_address(sg
));
110 e
->address_modifier
= 0;
113 static void sci_request_build_sgl(struct isci_request
*ireq
)
115 struct isci_host
*ihost
= ireq
->isci_host
;
116 struct sas_task
*task
= isci_request_access_task(ireq
);
117 struct scatterlist
*sg
= NULL
;
120 struct scu_sgl_element_pair
*scu_sg
= NULL
;
121 struct scu_sgl_element_pair
*prev_sg
= NULL
;
123 if (task
->num_scatter
> 0) {
127 scu_sg
= to_sgl_element_pair(ireq
, sg_idx
);
128 init_sgl_element(&scu_sg
->A
, sg
);
131 init_sgl_element(&scu_sg
->B
, sg
);
134 memset(&scu_sg
->B
, 0, sizeof(scu_sg
->B
));
137 dma_addr
= to_sgl_element_pair_dma(ihost
,
141 prev_sg
->next_pair_upper
=
142 upper_32_bits(dma_addr
);
143 prev_sg
->next_pair_lower
=
144 lower_32_bits(dma_addr
);
150 } else { /* handle when no sg */
151 scu_sg
= to_sgl_element_pair(ireq
, sg_idx
);
153 dma_addr
= dma_map_single(&ihost
->pdev
->dev
,
155 task
->total_xfer_len
,
158 ireq
->zero_scatter_daddr
= dma_addr
;
160 scu_sg
->A
.length
= task
->total_xfer_len
;
161 scu_sg
->A
.address_upper
= upper_32_bits(dma_addr
);
162 scu_sg
->A
.address_lower
= lower_32_bits(dma_addr
);
166 scu_sg
->next_pair_upper
= 0;
167 scu_sg
->next_pair_lower
= 0;
171 static void sci_io_request_build_ssp_command_iu(struct isci_request
*ireq
)
173 struct ssp_cmd_iu
*cmd_iu
;
174 struct sas_task
*task
= isci_request_access_task(ireq
);
176 cmd_iu
= &ireq
->ssp
.cmd
;
178 memcpy(cmd_iu
->LUN
, task
->ssp_task
.LUN
, 8);
179 cmd_iu
->add_cdb_len
= 0;
182 cmd_iu
->en_fburst
= 0; /* unsupported */
183 cmd_iu
->task_prio
= task
->ssp_task
.task_prio
;
184 cmd_iu
->task_attr
= task
->ssp_task
.task_attr
;
187 sci_swab32_cpy(&cmd_iu
->cdb
, task
->ssp_task
.cdb
,
188 sizeof(task
->ssp_task
.cdb
) / sizeof(u32
));
191 static void sci_task_request_build_ssp_task_iu(struct isci_request
*ireq
)
193 struct ssp_task_iu
*task_iu
;
194 struct sas_task
*task
= isci_request_access_task(ireq
);
195 struct isci_tmf
*isci_tmf
= isci_request_access_tmf(ireq
);
197 task_iu
= &ireq
->ssp
.tmf
;
199 memset(task_iu
, 0, sizeof(struct ssp_task_iu
));
201 memcpy(task_iu
->LUN
, task
->ssp_task
.LUN
, 8);
203 task_iu
->task_func
= isci_tmf
->tmf_code
;
205 (test_bit(IREQ_TMF
, &ireq
->flags
)) ?
207 SCI_CONTROLLER_INVALID_IO_TAG
;
211 * This method is will fill in the SCU Task Context for any type of SSP request.
216 static void scu_ssp_reqeust_construct_task_context(
217 struct isci_request
*ireq
,
218 struct scu_task_context
*task_context
)
221 struct isci_remote_device
*idev
;
222 struct isci_port
*iport
;
224 idev
= ireq
->target_device
;
225 iport
= idev
->owning_port
;
227 /* Fill in the TC with the its required data */
228 task_context
->abort
= 0;
229 task_context
->priority
= 0;
230 task_context
->initiator_request
= 1;
231 task_context
->connection_rate
= idev
->connection_rate
;
232 task_context
->protocol_engine_index
= ISCI_PEG
;
233 task_context
->logical_port_index
= iport
->physical_port_index
;
234 task_context
->protocol_type
= SCU_TASK_CONTEXT_PROTOCOL_SSP
;
235 task_context
->valid
= SCU_TASK_CONTEXT_VALID
;
236 task_context
->context_type
= SCU_TASK_CONTEXT_TYPE
;
238 task_context
->remote_node_index
= idev
->rnc
.remote_node_index
;
239 task_context
->command_code
= 0;
241 task_context
->link_layer_control
= 0;
242 task_context
->do_not_dma_ssp_good_response
= 1;
243 task_context
->strict_ordering
= 0;
244 task_context
->control_frame
= 0;
245 task_context
->timeout_enable
= 0;
246 task_context
->block_guard_enable
= 0;
248 task_context
->address_modifier
= 0;
250 /* task_context->type.ssp.tag = ireq->io_tag; */
251 task_context
->task_phase
= 0x01;
253 ireq
->post_context
= (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC
|
254 (ISCI_PEG
<< SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT
) |
255 (iport
->physical_port_index
<<
256 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT
) |
257 ISCI_TAG_TCI(ireq
->io_tag
));
260 * Copy the physical address for the command buffer to the
263 dma_addr
= sci_io_request_get_dma_addr(ireq
, &ireq
->ssp
.cmd
);
265 task_context
->command_iu_upper
= upper_32_bits(dma_addr
);
266 task_context
->command_iu_lower
= lower_32_bits(dma_addr
);
269 * Copy the physical address for the response buffer to the
272 dma_addr
= sci_io_request_get_dma_addr(ireq
, &ireq
->ssp
.rsp
);
274 task_context
->response_iu_upper
= upper_32_bits(dma_addr
);
275 task_context
->response_iu_lower
= lower_32_bits(dma_addr
);
278 static u8
scu_bg_blk_size(struct scsi_device
*sdp
)
280 switch (sdp
->sector_size
) {
292 static u32
scu_dif_bytes(u32 len
, u32 sector_size
)
294 return (len
>> ilog2(sector_size
)) * 8;
297 static void scu_ssp_ireq_dif_insert(struct isci_request
*ireq
, u8 type
, u8 op
)
299 struct scu_task_context
*tc
= ireq
->tc
;
300 struct scsi_cmnd
*scmd
= ireq
->ttype_ptr
.io_task_ptr
->uldd_task
;
301 u8 blk_sz
= scu_bg_blk_size(scmd
->device
);
303 tc
->block_guard_enable
= 1;
306 /* DIF write insert */
307 tc
->blk_prot_func
= 0x2;
309 tc
->transfer_length_bytes
+= scu_dif_bytes(tc
->transfer_length_bytes
,
310 scmd
->device
->sector_size
);
312 /* always init to 0, used by hw */
313 tc
->interm_crc_val
= 0;
315 tc
->init_crc_seed
= 0;
316 tc
->app_tag_verify
= 0;
318 tc
->ref_tag_seed_verify
= 0;
320 /* always init to same as bg_blk_sz */
321 tc
->UD_bytes_immed_val
= scmd
->device
->sector_size
;
323 tc
->reserved_DC_0
= 0;
325 /* always init to 8 */
326 tc
->DIF_bytes_immed_val
= 8;
328 tc
->reserved_DC_1
= 0;
329 tc
->bgc_blk_sz
= scmd
->device
->sector_size
;
330 tc
->reserved_E0_0
= 0;
331 tc
->app_tag_gen_mask
= 0;
333 /** setup block guard control **/
336 /* DIF write insert */
337 tc
->bgctl_f
.op
= 0x2;
339 tc
->app_tag_verify_mask
= 0;
341 /* must init to 0 for hw */
342 tc
->blk_guard_err
= 0;
344 tc
->reserved_E8_0
= 0;
346 if ((type
& SCSI_PROT_DIF_TYPE1
) || (type
& SCSI_PROT_DIF_TYPE2
))
347 tc
->ref_tag_seed_gen
= scsi_get_lba(scmd
) & 0xffffffff;
348 else if (type
& SCSI_PROT_DIF_TYPE3
)
349 tc
->ref_tag_seed_gen
= 0;
352 static void scu_ssp_ireq_dif_strip(struct isci_request
*ireq
, u8 type
, u8 op
)
354 struct scu_task_context
*tc
= ireq
->tc
;
355 struct scsi_cmnd
*scmd
= ireq
->ttype_ptr
.io_task_ptr
->uldd_task
;
356 u8 blk_sz
= scu_bg_blk_size(scmd
->device
);
358 tc
->block_guard_enable
= 1;
362 tc
->blk_prot_func
= 0x1;
364 tc
->transfer_length_bytes
+= scu_dif_bytes(tc
->transfer_length_bytes
,
365 scmd
->device
->sector_size
);
367 /* always init to 0, used by hw */
368 tc
->interm_crc_val
= 0;
370 tc
->init_crc_seed
= 0;
371 tc
->app_tag_verify
= 0;
374 if ((type
& SCSI_PROT_DIF_TYPE1
) || (type
& SCSI_PROT_DIF_TYPE2
))
375 tc
->ref_tag_seed_verify
= scsi_get_lba(scmd
) & 0xffffffff;
376 else if (type
& SCSI_PROT_DIF_TYPE3
)
377 tc
->ref_tag_seed_verify
= 0;
379 /* always init to same as bg_blk_sz */
380 tc
->UD_bytes_immed_val
= scmd
->device
->sector_size
;
382 tc
->reserved_DC_0
= 0;
384 /* always init to 8 */
385 tc
->DIF_bytes_immed_val
= 8;
387 tc
->reserved_DC_1
= 0;
388 tc
->bgc_blk_sz
= scmd
->device
->sector_size
;
389 tc
->reserved_E0_0
= 0;
390 tc
->app_tag_gen_mask
= 0;
392 /** setup block guard control **/
396 tc
->bgctl_f
.crc_verify
= 1;
397 tc
->bgctl_f
.op
= 0x1;
398 if ((type
& SCSI_PROT_DIF_TYPE1
) || (type
& SCSI_PROT_DIF_TYPE2
)) {
399 tc
->bgctl_f
.ref_tag_chk
= 1;
400 tc
->bgctl_f
.app_f_detect
= 1;
401 } else if (type
& SCSI_PROT_DIF_TYPE3
)
402 tc
->bgctl_f
.app_ref_f_detect
= 1;
404 tc
->app_tag_verify_mask
= 0;
406 /* must init to 0 for hw */
407 tc
->blk_guard_err
= 0;
409 tc
->reserved_E8_0
= 0;
410 tc
->ref_tag_seed_gen
= 0;
414 * This method is will fill in the SCU Task Context for a SSP IO request.
418 static void scu_ssp_io_request_construct_task_context(struct isci_request
*ireq
,
419 enum dma_data_direction dir
,
422 struct scu_task_context
*task_context
= ireq
->tc
;
423 struct sas_task
*sas_task
= ireq
->ttype_ptr
.io_task_ptr
;
424 struct scsi_cmnd
*scmd
= sas_task
->uldd_task
;
425 u8 prot_type
= scsi_get_prot_type(scmd
);
426 u8 prot_op
= scsi_get_prot_op(scmd
);
428 scu_ssp_reqeust_construct_task_context(ireq
, task_context
);
430 task_context
->ssp_command_iu_length
=
431 sizeof(struct ssp_cmd_iu
) / sizeof(u32
);
432 task_context
->type
.ssp
.frame_type
= SSP_COMMAND
;
435 case DMA_FROM_DEVICE
:
438 task_context
->task_type
= SCU_TASK_TYPE_IOREAD
;
441 task_context
->task_type
= SCU_TASK_TYPE_IOWRITE
;
445 task_context
->transfer_length_bytes
= len
;
447 if (task_context
->transfer_length_bytes
> 0)
448 sci_request_build_sgl(ireq
);
450 if (prot_type
!= SCSI_PROT_DIF_TYPE0
) {
451 if (prot_op
== SCSI_PROT_READ_STRIP
)
452 scu_ssp_ireq_dif_strip(ireq
, prot_type
, prot_op
);
453 else if (prot_op
== SCSI_PROT_WRITE_INSERT
)
454 scu_ssp_ireq_dif_insert(ireq
, prot_type
, prot_op
);
459 * This method will fill in the SCU Task Context for a SSP Task request. The
460 * following important settings are utilized: -# priority ==
461 * SCU_TASK_PRIORITY_HIGH. This ensures that the task request is issued
462 * ahead of other task destined for the same Remote Node. -# task_type ==
463 * SCU_TASK_TYPE_IOREAD. This simply indicates that a normal request type
464 * (i.e. non-raw frame) is being utilized to perform task management. -#
465 * control_frame == 1. This ensures that the proper endianess is set so
466 * that the bytes are transmitted in the right order for a task frame.
467 * @sci_req: This parameter specifies the task request object being
471 static void scu_ssp_task_request_construct_task_context(struct isci_request
*ireq
)
473 struct scu_task_context
*task_context
= ireq
->tc
;
475 scu_ssp_reqeust_construct_task_context(ireq
, task_context
);
477 task_context
->control_frame
= 1;
478 task_context
->priority
= SCU_TASK_PRIORITY_HIGH
;
479 task_context
->task_type
= SCU_TASK_TYPE_RAW_FRAME
;
480 task_context
->transfer_length_bytes
= 0;
481 task_context
->type
.ssp
.frame_type
= SSP_TASK
;
482 task_context
->ssp_command_iu_length
=
483 sizeof(struct ssp_task_iu
) / sizeof(u32
);
487 * This method is will fill in the SCU Task Context for any type of SATA
488 * request. This is called from the various SATA constructors.
489 * @sci_req: The general IO request object which is to be used in
490 * constructing the SCU task context.
491 * @task_context: The buffer pointer for the SCU task context which is being
494 * The general io request construction is complete. The buffer assignment for
495 * the command buffer is complete. none Revisit task context construction to
496 * determine what is common for SSP/SMP/STP task context structures.
498 static void scu_sata_reqeust_construct_task_context(
499 struct isci_request
*ireq
,
500 struct scu_task_context
*task_context
)
503 struct isci_remote_device
*idev
;
504 struct isci_port
*iport
;
506 idev
= ireq
->target_device
;
507 iport
= idev
->owning_port
;
509 /* Fill in the TC with the its required data */
510 task_context
->abort
= 0;
511 task_context
->priority
= SCU_TASK_PRIORITY_NORMAL
;
512 task_context
->initiator_request
= 1;
513 task_context
->connection_rate
= idev
->connection_rate
;
514 task_context
->protocol_engine_index
= ISCI_PEG
;
515 task_context
->logical_port_index
= iport
->physical_port_index
;
516 task_context
->protocol_type
= SCU_TASK_CONTEXT_PROTOCOL_STP
;
517 task_context
->valid
= SCU_TASK_CONTEXT_VALID
;
518 task_context
->context_type
= SCU_TASK_CONTEXT_TYPE
;
520 task_context
->remote_node_index
= idev
->rnc
.remote_node_index
;
521 task_context
->command_code
= 0;
523 task_context
->link_layer_control
= 0;
524 task_context
->do_not_dma_ssp_good_response
= 1;
525 task_context
->strict_ordering
= 0;
526 task_context
->control_frame
= 0;
527 task_context
->timeout_enable
= 0;
528 task_context
->block_guard_enable
= 0;
530 task_context
->address_modifier
= 0;
531 task_context
->task_phase
= 0x01;
533 task_context
->ssp_command_iu_length
=
534 (sizeof(struct host_to_dev_fis
) - sizeof(u32
)) / sizeof(u32
);
536 /* Set the first word of the H2D REG FIS */
537 task_context
->type
.words
[0] = *(u32
*)&ireq
->stp
.cmd
;
539 ireq
->post_context
= (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC
|
540 (ISCI_PEG
<< SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT
) |
541 (iport
->physical_port_index
<<
542 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT
) |
543 ISCI_TAG_TCI(ireq
->io_tag
));
545 * Copy the physical address for the command buffer to the SCU Task
546 * Context. We must offset the command buffer by 4 bytes because the
547 * first 4 bytes are transfered in the body of the TC.
549 dma_addr
= sci_io_request_get_dma_addr(ireq
,
550 ((char *) &ireq
->stp
.cmd
) +
553 task_context
->command_iu_upper
= upper_32_bits(dma_addr
);
554 task_context
->command_iu_lower
= lower_32_bits(dma_addr
);
556 /* SATA Requests do not have a response buffer */
557 task_context
->response_iu_upper
= 0;
558 task_context
->response_iu_lower
= 0;
561 static void scu_stp_raw_request_construct_task_context(struct isci_request
*ireq
)
563 struct scu_task_context
*task_context
= ireq
->tc
;
565 scu_sata_reqeust_construct_task_context(ireq
, task_context
);
567 task_context
->control_frame
= 0;
568 task_context
->priority
= SCU_TASK_PRIORITY_NORMAL
;
569 task_context
->task_type
= SCU_TASK_TYPE_SATA_RAW_FRAME
;
570 task_context
->type
.stp
.fis_type
= FIS_REGH2D
;
571 task_context
->transfer_length_bytes
= sizeof(struct host_to_dev_fis
) - sizeof(u32
);
574 static enum sci_status
sci_stp_pio_request_construct(struct isci_request
*ireq
,
577 struct isci_stp_request
*stp_req
= &ireq
->stp
.req
;
579 scu_stp_raw_request_construct_task_context(ireq
);
582 stp_req
->sgl
.offset
= 0;
583 stp_req
->sgl
.set
= SCU_SGL_ELEMENT_PAIR_A
;
586 sci_request_build_sgl(ireq
);
587 stp_req
->sgl
.index
= 0;
589 /* The user does not want the data copied to the SGL buffer location */
590 stp_req
->sgl
.index
= -1;
598 * @sci_req: This parameter specifies the request to be constructed as an
600 * @optimized_task_type: This parameter specifies whether the request is to be
601 * an UDMA request or a NCQ request. - A value of 0 indicates UDMA. - A
602 * value of 1 indicates NCQ.
604 * This method will perform request construction common to all types of STP
605 * requests that are optimized by the silicon (i.e. UDMA, NCQ). This method
606 * returns an indication as to whether the construction was successful.
608 static void sci_stp_optimized_request_construct(struct isci_request
*ireq
,
609 u8 optimized_task_type
,
611 enum dma_data_direction dir
)
613 struct scu_task_context
*task_context
= ireq
->tc
;
615 /* Build the STP task context structure */
616 scu_sata_reqeust_construct_task_context(ireq
, task_context
);
618 /* Copy over the SGL elements */
619 sci_request_build_sgl(ireq
);
621 /* Copy over the number of bytes to be transfered */
622 task_context
->transfer_length_bytes
= len
;
624 if (dir
== DMA_TO_DEVICE
) {
626 * The difference between the DMA IN and DMA OUT request task type
627 * values are consistent with the difference between FPDMA READ
628 * and FPDMA WRITE values. Add the supplied task type parameter
629 * to this difference to set the task type properly for this
630 * DATA OUT (WRITE) case. */
631 task_context
->task_type
= optimized_task_type
+ (SCU_TASK_TYPE_DMA_OUT
632 - SCU_TASK_TYPE_DMA_IN
);
635 * For the DATA IN (READ) case, simply save the supplied
636 * optimized task type. */
637 task_context
->task_type
= optimized_task_type
;
641 static void sci_atapi_construct(struct isci_request
*ireq
)
643 struct host_to_dev_fis
*h2d_fis
= &ireq
->stp
.cmd
;
644 struct sas_task
*task
;
646 /* To simplify the implementation we take advantage of the
647 * silicon's partial acceleration of atapi protocol (dma data
648 * transfers), so we promote all commands to dma protocol. This
649 * breaks compatibility with ATA_HORKAGE_ATAPI_MOD16_DMA drives.
651 h2d_fis
->features
|= ATAPI_PKT_DMA
;
653 scu_stp_raw_request_construct_task_context(ireq
);
655 task
= isci_request_access_task(ireq
);
656 if (task
->data_dir
== DMA_NONE
)
657 task
->total_xfer_len
= 0;
659 /* clear the response so we can detect arrivial of an
660 * unsolicited h2d fis
662 ireq
->stp
.rsp
.fis_type
= 0;
665 static enum sci_status
666 sci_io_request_construct_sata(struct isci_request
*ireq
,
668 enum dma_data_direction dir
,
671 enum sci_status status
= SCI_SUCCESS
;
672 struct sas_task
*task
= isci_request_access_task(ireq
);
673 struct domain_device
*dev
= ireq
->target_device
->domain_dev
;
675 /* check for management protocols */
676 if (test_bit(IREQ_TMF
, &ireq
->flags
)) {
677 struct isci_tmf
*tmf
= isci_request_access_tmf(ireq
);
679 dev_err(&ireq
->owning_controller
->pdev
->dev
,
680 "%s: Request 0x%p received un-handled SAT "
681 "management protocol 0x%x.\n",
682 __func__
, ireq
, tmf
->tmf_code
);
687 if (!sas_protocol_ata(task
->task_proto
)) {
688 dev_err(&ireq
->owning_controller
->pdev
->dev
,
689 "%s: Non-ATA protocol in SATA path: 0x%x\n",
697 if (dev
->sata_dev
.command_set
== ATAPI_COMMAND_SET
&&
698 task
->ata_task
.fis
.command
== ATA_CMD_PACKET
) {
699 sci_atapi_construct(ireq
);
704 if (task
->data_dir
== DMA_NONE
) {
705 scu_stp_raw_request_construct_task_context(ireq
);
710 if (task
->ata_task
.use_ncq
) {
711 sci_stp_optimized_request_construct(ireq
,
712 SCU_TASK_TYPE_FPDMAQ_READ
,
718 if (task
->ata_task
.dma_xfer
) {
719 sci_stp_optimized_request_construct(ireq
,
720 SCU_TASK_TYPE_DMA_IN
,
724 return sci_stp_pio_request_construct(ireq
, copy
);
729 static enum sci_status
sci_io_request_construct_basic_ssp(struct isci_request
*ireq
)
731 struct sas_task
*task
= isci_request_access_task(ireq
);
733 ireq
->protocol
= SAS_PROTOCOL_SSP
;
735 scu_ssp_io_request_construct_task_context(ireq
,
737 task
->total_xfer_len
);
739 sci_io_request_build_ssp_command_iu(ireq
);
741 sci_change_state(&ireq
->sm
, SCI_REQ_CONSTRUCTED
);
746 enum sci_status
sci_task_request_construct_ssp(
747 struct isci_request
*ireq
)
749 /* Construct the SSP Task SCU Task Context */
750 scu_ssp_task_request_construct_task_context(ireq
);
752 /* Fill in the SSP Task IU */
753 sci_task_request_build_ssp_task_iu(ireq
);
755 sci_change_state(&ireq
->sm
, SCI_REQ_CONSTRUCTED
);
760 static enum sci_status
sci_io_request_construct_basic_sata(struct isci_request
*ireq
)
762 enum sci_status status
;
764 struct sas_task
*task
= isci_request_access_task(ireq
);
766 ireq
->protocol
= SAS_PROTOCOL_STP
;
768 copy
= (task
->data_dir
== DMA_NONE
) ? false : true;
770 status
= sci_io_request_construct_sata(ireq
,
771 task
->total_xfer_len
,
775 if (status
== SCI_SUCCESS
)
776 sci_change_state(&ireq
->sm
, SCI_REQ_CONSTRUCTED
);
782 * sci_req_tx_bytes - bytes transferred when reply underruns request
783 * @ireq: request that was terminated early
785 #define SCU_TASK_CONTEXT_SRAM 0x200000
786 static u32
sci_req_tx_bytes(struct isci_request
*ireq
)
788 struct isci_host
*ihost
= ireq
->owning_controller
;
791 if (readl(&ihost
->smu_registers
->address_modifier
) == 0) {
792 void __iomem
*scu_reg_base
= ihost
->scu_registers
;
794 /* get the bytes of data from the Address == BAR1 + 20002Ch + (256*TCi) where
795 * BAR1 is the scu_registers
796 * 0x20002C = 0x200000 + 0x2c
797 * = start of task context SRAM + offset of (type.ssp.data_offset)
798 * TCi is the io_tag of struct sci_request
800 ret_val
= readl(scu_reg_base
+
801 (SCU_TASK_CONTEXT_SRAM
+ offsetof(struct scu_task_context
, type
.ssp
.data_offset
)) +
802 ((sizeof(struct scu_task_context
)) * ISCI_TAG_TCI(ireq
->io_tag
)));
808 enum sci_status
sci_request_start(struct isci_request
*ireq
)
810 enum sci_base_request_states state
;
811 struct scu_task_context
*tc
= ireq
->tc
;
812 struct isci_host
*ihost
= ireq
->owning_controller
;
814 state
= ireq
->sm
.current_state_id
;
815 if (state
!= SCI_REQ_CONSTRUCTED
) {
816 dev_warn(&ihost
->pdev
->dev
,
817 "%s: SCIC IO Request requested to start while in wrong "
818 "state %d\n", __func__
, state
);
819 return SCI_FAILURE_INVALID_STATE
;
822 tc
->task_index
= ISCI_TAG_TCI(ireq
->io_tag
);
824 switch (tc
->protocol_type
) {
825 case SCU_TASK_CONTEXT_PROTOCOL_SMP
:
826 case SCU_TASK_CONTEXT_PROTOCOL_SSP
:
828 tc
->type
.ssp
.tag
= ireq
->io_tag
;
829 tc
->type
.ssp
.target_port_transfer_tag
= 0xFFFF;
832 case SCU_TASK_CONTEXT_PROTOCOL_STP
:
834 * tc->type.stp.ncq_tag = ireq->ncq_tag;
838 case SCU_TASK_CONTEXT_PROTOCOL_NONE
:
839 /* / @todo When do we set no protocol type? */
843 /* This should never happen since we build the IO
848 /* Add to the post_context the io tag value */
849 ireq
->post_context
|= ISCI_TAG_TCI(ireq
->io_tag
);
851 /* Everything is good go ahead and change state */
852 sci_change_state(&ireq
->sm
, SCI_REQ_STARTED
);
858 sci_io_request_terminate(struct isci_request
*ireq
)
860 enum sci_base_request_states state
;
862 state
= ireq
->sm
.current_state_id
;
865 case SCI_REQ_CONSTRUCTED
:
866 /* Set to make sure no HW terminate posting is done: */
867 set_bit(IREQ_TC_ABORT_POSTED
, &ireq
->flags
);
868 ireq
->scu_status
= SCU_TASK_DONE_TASK_ABORT
;
869 ireq
->sci_status
= SCI_FAILURE_IO_TERMINATED
;
870 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
872 case SCI_REQ_STARTED
:
873 case SCI_REQ_TASK_WAIT_TC_COMP
:
874 case SCI_REQ_SMP_WAIT_RESP
:
875 case SCI_REQ_SMP_WAIT_TC_COMP
:
876 case SCI_REQ_STP_UDMA_WAIT_TC_COMP
:
877 case SCI_REQ_STP_UDMA_WAIT_D2H
:
878 case SCI_REQ_STP_NON_DATA_WAIT_H2D
:
879 case SCI_REQ_STP_NON_DATA_WAIT_D2H
:
880 case SCI_REQ_STP_PIO_WAIT_H2D
:
881 case SCI_REQ_STP_PIO_WAIT_FRAME
:
882 case SCI_REQ_STP_PIO_DATA_IN
:
883 case SCI_REQ_STP_PIO_DATA_OUT
:
884 case SCI_REQ_ATAPI_WAIT_H2D
:
885 case SCI_REQ_ATAPI_WAIT_PIO_SETUP
:
886 case SCI_REQ_ATAPI_WAIT_D2H
:
887 case SCI_REQ_ATAPI_WAIT_TC_COMP
:
888 /* Fall through and change state to ABORTING... */
889 case SCI_REQ_TASK_WAIT_TC_RESP
:
890 /* The task frame was already confirmed to have been
891 * sent by the SCU HW. Since the state machine is
892 * now only waiting for the task response itself,
893 * abort the request and complete it immediately
894 * and don't wait for the task response.
896 sci_change_state(&ireq
->sm
, SCI_REQ_ABORTING
);
897 /* Fall through and handle like ABORTING... */
898 case SCI_REQ_ABORTING
:
899 if (!isci_remote_device_is_safe_to_abort(ireq
->target_device
))
900 set_bit(IREQ_PENDING_ABORT
, &ireq
->flags
);
902 clear_bit(IREQ_PENDING_ABORT
, &ireq
->flags
);
903 /* If the request is only waiting on the remote device
904 * suspension, return SUCCESS so the caller will wait too.
907 case SCI_REQ_COMPLETED
:
909 dev_warn(&ireq
->owning_controller
->pdev
->dev
,
910 "%s: SCIC IO Request requested to abort while in wrong "
911 "state %d\n", __func__
, ireq
->sm
.current_state_id
);
915 return SCI_FAILURE_INVALID_STATE
;
918 enum sci_status
sci_request_complete(struct isci_request
*ireq
)
920 enum sci_base_request_states state
;
921 struct isci_host
*ihost
= ireq
->owning_controller
;
923 state
= ireq
->sm
.current_state_id
;
924 if (WARN_ONCE(state
!= SCI_REQ_COMPLETED
,
925 "isci: request completion from wrong state (%s)\n",
926 req_state_name(state
)))
927 return SCI_FAILURE_INVALID_STATE
;
929 if (ireq
->saved_rx_frame_index
!= SCU_INVALID_FRAME_INDEX
)
930 sci_controller_release_frame(ihost
,
931 ireq
->saved_rx_frame_index
);
933 /* XXX can we just stop the machine and remove the 'final' state? */
934 sci_change_state(&ireq
->sm
, SCI_REQ_FINAL
);
938 enum sci_status
sci_io_request_event_handler(struct isci_request
*ireq
,
941 enum sci_base_request_states state
;
942 struct isci_host
*ihost
= ireq
->owning_controller
;
944 state
= ireq
->sm
.current_state_id
;
946 if (state
!= SCI_REQ_STP_PIO_DATA_IN
) {
947 dev_warn(&ihost
->pdev
->dev
, "%s: (%x) in wrong state %s\n",
948 __func__
, event_code
, req_state_name(state
));
950 return SCI_FAILURE_INVALID_STATE
;
953 switch (scu_get_event_specifier(event_code
)) {
954 case SCU_TASK_DONE_CRC_ERR
<< SCU_EVENT_SPECIFIC_CODE_SHIFT
:
955 /* We are waiting for data and the SCU has R_ERR the data frame.
956 * Go back to waiting for the D2H Register FIS
958 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_WAIT_FRAME
);
961 dev_err(&ihost
->pdev
->dev
,
962 "%s: pio request unexpected event %#x\n",
963 __func__
, event_code
);
965 /* TODO Should we fail the PIO request when we get an
973 * This function copies response data for requests returning response data
974 * instead of sense data.
975 * @sci_req: This parameter specifies the request object for which to copy
978 static void sci_io_request_copy_response(struct isci_request
*ireq
)
982 struct ssp_response_iu
*ssp_response
;
983 struct isci_tmf
*isci_tmf
= isci_request_access_tmf(ireq
);
985 ssp_response
= &ireq
->ssp
.rsp
;
987 resp_buf
= &isci_tmf
->resp
.resp_iu
;
990 SSP_RESP_IU_MAX_SIZE
,
991 be32_to_cpu(ssp_response
->response_data_len
));
993 memcpy(resp_buf
, ssp_response
->resp_data
, len
);
996 static enum sci_status
997 request_started_state_tc_event(struct isci_request
*ireq
,
1000 struct ssp_response_iu
*resp_iu
;
1003 /* TODO: Any SDMA return code of other than 0 is bad decode 0x003C0000
1004 * to determine SDMA status
1006 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1007 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1008 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1009 ireq
->sci_status
= SCI_SUCCESS
;
1011 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EARLY_RESP
): {
1012 /* There are times when the SCU hardware will return an early
1013 * response because the io request specified more data than is
1014 * returned by the target device (mode pages, inquiry data,
1015 * etc.). We must check the response stats to see if this is
1016 * truly a failed request or a good request that just got
1019 struct ssp_response_iu
*resp
= &ireq
->ssp
.rsp
;
1020 ssize_t word_cnt
= SSP_RESP_IU_MAX_SIZE
/ sizeof(u32
);
1022 sci_swab32_cpy(&ireq
->ssp
.rsp
,
1026 if (resp
->status
== 0) {
1027 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1028 ireq
->sci_status
= SCI_SUCCESS_IO_DONE_EARLY
;
1030 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1031 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1035 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE
): {
1036 ssize_t word_cnt
= SSP_RESP_IU_MAX_SIZE
/ sizeof(u32
);
1038 sci_swab32_cpy(&ireq
->ssp
.rsp
,
1042 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1043 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1047 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RESP_LEN_ERR
):
1048 /* TODO With TASK_DONE_RESP_LEN_ERR is the response frame
1049 * guaranteed to be received before this completion status is
1052 resp_iu
= &ireq
->ssp
.rsp
;
1053 datapres
= resp_iu
->datapres
;
1055 if (datapres
== 1 || datapres
== 2) {
1056 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1057 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1059 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1060 ireq
->sci_status
= SCI_SUCCESS
;
1063 /* only stp device gets suspended. */
1064 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO
):
1065 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_PERR
):
1066 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_ERR
):
1067 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_DATA_LEN_ERR
):
1068 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_ABORT_ERR
):
1069 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_WD_LEN
):
1070 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR
):
1071 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_RESP
):
1072 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS
):
1073 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR
):
1074 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR
):
1075 if (ireq
->protocol
== SAS_PROTOCOL_STP
) {
1076 ireq
->scu_status
= SCU_GET_COMPLETION_TL_STATUS(completion_code
) >>
1077 SCU_COMPLETION_TL_STATUS_SHIFT
;
1078 ireq
->sci_status
= SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
;
1080 ireq
->scu_status
= SCU_GET_COMPLETION_TL_STATUS(completion_code
) >>
1081 SCU_COMPLETION_TL_STATUS_SHIFT
;
1082 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1086 /* both stp/ssp device gets suspended */
1087 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LF_ERR
):
1088 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_WRONG_DESTINATION
):
1089 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1
):
1090 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2
):
1091 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3
):
1092 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_BAD_DESTINATION
):
1093 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_ZONE_VIOLATION
):
1094 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY
):
1095 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED
):
1096 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED
):
1097 ireq
->scu_status
= SCU_GET_COMPLETION_TL_STATUS(completion_code
) >>
1098 SCU_COMPLETION_TL_STATUS_SHIFT
;
1099 ireq
->sci_status
= SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
;
1102 /* neither ssp nor stp gets suspended. */
1103 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_CMD_ERR
):
1104 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_XR
):
1105 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_IU_LEN_ERR
):
1106 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDMA_ERR
):
1107 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OFFSET_ERR
):
1108 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EXCESS_DATA
):
1109 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR
):
1110 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR
):
1111 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR
):
1112 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR
):
1113 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_DATA
):
1114 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OPEN_FAIL
):
1115 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_VIIT_ENTRY_NV
):
1116 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_IIT_ENTRY_NV
):
1117 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND
):
1119 ireq
->scu_status
= SCU_GET_COMPLETION_TL_STATUS(completion_code
) >>
1120 SCU_COMPLETION_TL_STATUS_SHIFT
;
1121 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1126 * TODO: This is probably wrong for ACK/NAK timeout conditions
1129 /* In all cases we will treat this as the completion of the IO req. */
1130 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1134 static enum sci_status
1135 request_aborting_state_tc_event(struct isci_request
*ireq
,
1136 u32 completion_code
)
1138 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1139 case (SCU_TASK_DONE_GOOD
<< SCU_COMPLETION_TL_STATUS_SHIFT
):
1140 case (SCU_TASK_DONE_TASK_ABORT
<< SCU_COMPLETION_TL_STATUS_SHIFT
):
1141 ireq
->scu_status
= SCU_TASK_DONE_TASK_ABORT
;
1142 ireq
->sci_status
= SCI_FAILURE_IO_TERMINATED
;
1143 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1147 /* Unless we get some strange error wait for the task abort to complete
1148 * TODO: Should there be a state change for this completion?
1156 static enum sci_status
ssp_task_request_await_tc_event(struct isci_request
*ireq
,
1157 u32 completion_code
)
1159 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1160 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1161 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1162 ireq
->sci_status
= SCI_SUCCESS
;
1163 sci_change_state(&ireq
->sm
, SCI_REQ_TASK_WAIT_TC_RESP
);
1165 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO
):
1166 /* Currently, the decision is to simply allow the task request
1167 * to timeout if the task IU wasn't received successfully.
1168 * There is a potential for receiving multiple task responses if
1169 * we decide to send the task IU again.
1171 dev_warn(&ireq
->owning_controller
->pdev
->dev
,
1172 "%s: TaskRequest:0x%p CompletionCode:%x - "
1173 "ACK/NAK timeout\n", __func__
, ireq
,
1176 sci_change_state(&ireq
->sm
, SCI_REQ_TASK_WAIT_TC_RESP
);
1180 * All other completion status cause the IO to be complete.
1181 * If a NAK was received, then it is up to the user to retry
1184 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1185 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1186 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1193 static enum sci_status
1194 smp_request_await_response_tc_event(struct isci_request
*ireq
,
1195 u32 completion_code
)
1197 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1198 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1199 /* In the AWAIT RESPONSE state, any TC completion is
1200 * unexpected. but if the TC has success status, we
1201 * complete the IO anyway.
1203 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1204 ireq
->sci_status
= SCI_SUCCESS
;
1205 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1207 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR
):
1208 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR
):
1209 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR
):
1210 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR
):
1211 /* These status has been seen in a specific LSI
1212 * expander, which sometimes is not able to send smp
1213 * response within 2 ms. This causes our hardware break
1214 * the connection and set TC completion with one of
1215 * these SMP_XXX_XX_ERR status. For these type of error,
1216 * we ask ihost user to retry the request.
1218 ireq
->scu_status
= SCU_TASK_DONE_SMP_RESP_TO_ERR
;
1219 ireq
->sci_status
= SCI_FAILURE_RETRY_REQUIRED
;
1220 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1223 /* All other completion status cause the IO to be complete. If a NAK
1224 * was received, then it is up to the user to retry the request
1226 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1227 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1228 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1235 static enum sci_status
1236 smp_request_await_tc_event(struct isci_request
*ireq
,
1237 u32 completion_code
)
1239 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1240 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1241 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1242 ireq
->sci_status
= SCI_SUCCESS
;
1243 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1246 /* All other completion status cause the IO to be
1247 * complete. If a NAK was received, then it is up to
1248 * the user to retry the request.
1250 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1251 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1252 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1259 static struct scu_sgl_element
*pio_sgl_next(struct isci_stp_request
*stp_req
)
1261 struct scu_sgl_element
*sgl
;
1262 struct scu_sgl_element_pair
*sgl_pair
;
1263 struct isci_request
*ireq
= to_ireq(stp_req
);
1264 struct isci_stp_pio_sgl
*pio_sgl
= &stp_req
->sgl
;
1266 sgl_pair
= to_sgl_element_pair(ireq
, pio_sgl
->index
);
1269 else if (pio_sgl
->set
== SCU_SGL_ELEMENT_PAIR_A
) {
1270 if (sgl_pair
->B
.address_lower
== 0 &&
1271 sgl_pair
->B
.address_upper
== 0) {
1274 pio_sgl
->set
= SCU_SGL_ELEMENT_PAIR_B
;
1278 if (sgl_pair
->next_pair_lower
== 0 &&
1279 sgl_pair
->next_pair_upper
== 0) {
1283 pio_sgl
->set
= SCU_SGL_ELEMENT_PAIR_A
;
1284 sgl_pair
= to_sgl_element_pair(ireq
, pio_sgl
->index
);
1292 static enum sci_status
1293 stp_request_non_data_await_h2d_tc_event(struct isci_request
*ireq
,
1294 u32 completion_code
)
1296 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1297 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1298 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1299 ireq
->sci_status
= SCI_SUCCESS
;
1300 sci_change_state(&ireq
->sm
, SCI_REQ_STP_NON_DATA_WAIT_D2H
);
1304 /* All other completion status cause the IO to be
1305 * complete. If a NAK was received, then it is up to
1306 * the user to retry the request.
1308 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1309 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1310 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1317 #define SCU_MAX_FRAME_BUFFER_SIZE 0x400 /* 1K is the maximum SCU frame data payload */
1319 /* transmit DATA_FIS from (current sgl + offset) for input
1320 * parameter length. current sgl and offset is alreay stored in the IO request
1322 static enum sci_status
sci_stp_request_pio_data_out_trasmit_data_frame(
1323 struct isci_request
*ireq
,
1326 struct isci_stp_request
*stp_req
= &ireq
->stp
.req
;
1327 struct scu_task_context
*task_context
= ireq
->tc
;
1328 struct scu_sgl_element_pair
*sgl_pair
;
1329 struct scu_sgl_element
*current_sgl
;
1331 /* Recycle the TC and reconstruct it for sending out DATA FIS containing
1332 * for the data from current_sgl+offset for the input length
1334 sgl_pair
= to_sgl_element_pair(ireq
, stp_req
->sgl
.index
);
1335 if (stp_req
->sgl
.set
== SCU_SGL_ELEMENT_PAIR_A
)
1336 current_sgl
= &sgl_pair
->A
;
1338 current_sgl
= &sgl_pair
->B
;
1341 task_context
->command_iu_upper
= current_sgl
->address_upper
;
1342 task_context
->command_iu_lower
= current_sgl
->address_lower
;
1343 task_context
->transfer_length_bytes
= length
;
1344 task_context
->type
.stp
.fis_type
= FIS_DATA
;
1346 /* send the new TC out. */
1347 return sci_controller_continue_io(ireq
);
1350 static enum sci_status
sci_stp_request_pio_data_out_transmit_data(struct isci_request
*ireq
)
1352 struct isci_stp_request
*stp_req
= &ireq
->stp
.req
;
1353 struct scu_sgl_element_pair
*sgl_pair
;
1354 enum sci_status status
= SCI_SUCCESS
;
1355 struct scu_sgl_element
*sgl
;
1359 offset
= stp_req
->sgl
.offset
;
1360 sgl_pair
= to_sgl_element_pair(ireq
, stp_req
->sgl
.index
);
1361 if (WARN_ONCE(!sgl_pair
, "%s: null sgl element", __func__
))
1364 if (stp_req
->sgl
.set
== SCU_SGL_ELEMENT_PAIR_A
) {
1366 len
= sgl_pair
->A
.length
- offset
;
1369 len
= sgl_pair
->B
.length
- offset
;
1372 if (stp_req
->pio_len
== 0)
1375 if (stp_req
->pio_len
>= len
) {
1376 status
= sci_stp_request_pio_data_out_trasmit_data_frame(ireq
, len
);
1377 if (status
!= SCI_SUCCESS
)
1379 stp_req
->pio_len
-= len
;
1381 /* update the current sgl, offset and save for future */
1382 sgl
= pio_sgl_next(stp_req
);
1384 } else if (stp_req
->pio_len
< len
) {
1385 sci_stp_request_pio_data_out_trasmit_data_frame(ireq
, stp_req
->pio_len
);
1387 /* Sgl offset will be adjusted and saved for future */
1388 offset
+= stp_req
->pio_len
;
1389 sgl
->address_lower
+= stp_req
->pio_len
;
1390 stp_req
->pio_len
= 0;
1393 stp_req
->sgl
.offset
= offset
;
1400 * @stp_request: The request that is used for the SGL processing.
1401 * @data_buffer: The buffer of data to be copied.
1402 * @length: The length of the data transfer.
1404 * Copy the data from the buffer for the length specified to the IO reqeust SGL
1405 * specified data region. enum sci_status
1407 static enum sci_status
1408 sci_stp_request_pio_data_in_copy_data_buffer(struct isci_stp_request
*stp_req
,
1409 u8
*data_buf
, u32 len
)
1411 struct isci_request
*ireq
;
1414 struct sas_task
*task
;
1415 struct scatterlist
*sg
;
1417 int total_len
= len
;
1419 ireq
= to_ireq(stp_req
);
1420 task
= isci_request_access_task(ireq
);
1421 src_addr
= data_buf
;
1423 if (task
->num_scatter
> 0) {
1426 while (total_len
> 0) {
1427 struct page
*page
= sg_page(sg
);
1429 copy_len
= min_t(int, total_len
, sg_dma_len(sg
));
1430 kaddr
= kmap_atomic(page
);
1431 memcpy(kaddr
+ sg
->offset
, src_addr
, copy_len
);
1432 kunmap_atomic(kaddr
);
1433 total_len
-= copy_len
;
1434 src_addr
+= copy_len
;
1438 BUG_ON(task
->total_xfer_len
< total_len
);
1439 memcpy(task
->scatter
, src_addr
, total_len
);
1447 * @sci_req: The PIO DATA IN request that is to receive the data.
1448 * @data_buffer: The buffer to copy from.
1450 * Copy the data buffer to the io request data region. enum sci_status
1452 static enum sci_status
sci_stp_request_pio_data_in_copy_data(
1453 struct isci_stp_request
*stp_req
,
1456 enum sci_status status
;
1459 * If there is less than 1K remaining in the transfer request
1460 * copy just the data for the transfer */
1461 if (stp_req
->pio_len
< SCU_MAX_FRAME_BUFFER_SIZE
) {
1462 status
= sci_stp_request_pio_data_in_copy_data_buffer(
1463 stp_req
, data_buffer
, stp_req
->pio_len
);
1465 if (status
== SCI_SUCCESS
)
1466 stp_req
->pio_len
= 0;
1468 /* We are transfering the whole frame so copy */
1469 status
= sci_stp_request_pio_data_in_copy_data_buffer(
1470 stp_req
, data_buffer
, SCU_MAX_FRAME_BUFFER_SIZE
);
1472 if (status
== SCI_SUCCESS
)
1473 stp_req
->pio_len
-= SCU_MAX_FRAME_BUFFER_SIZE
;
1479 static enum sci_status
1480 stp_request_pio_await_h2d_completion_tc_event(struct isci_request
*ireq
,
1481 u32 completion_code
)
1483 enum sci_status status
= SCI_SUCCESS
;
1485 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1486 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1487 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1488 ireq
->sci_status
= SCI_SUCCESS
;
1489 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_WAIT_FRAME
);
1493 /* All other completion status cause the IO to be
1494 * complete. If a NAK was received, then it is up to
1495 * the user to retry the request.
1497 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1498 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1499 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1506 static enum sci_status
1507 pio_data_out_tx_done_tc_event(struct isci_request
*ireq
,
1508 u32 completion_code
)
1510 enum sci_status status
= SCI_SUCCESS
;
1511 bool all_frames_transferred
= false;
1512 struct isci_stp_request
*stp_req
= &ireq
->stp
.req
;
1514 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
1515 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
1517 if (stp_req
->pio_len
!= 0) {
1518 status
= sci_stp_request_pio_data_out_transmit_data(ireq
);
1519 if (status
== SCI_SUCCESS
) {
1520 if (stp_req
->pio_len
== 0)
1521 all_frames_transferred
= true;
1523 } else if (stp_req
->pio_len
== 0) {
1525 * this will happen if the all data is written at the
1526 * first time after the pio setup fis is received
1528 all_frames_transferred
= true;
1531 /* all data transferred. */
1532 if (all_frames_transferred
) {
1534 * Change the state to SCI_REQ_STP_PIO_DATA_IN
1535 * and wait for PIO_SETUP fis / or D2H REg fis. */
1536 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_WAIT_FRAME
);
1542 * All other completion status cause the IO to be complete.
1543 * If a NAK was received, then it is up to the user to retry
1546 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
1547 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1548 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1555 static enum sci_status
sci_stp_request_udma_general_frame_handler(struct isci_request
*ireq
,
1558 struct isci_host
*ihost
= ireq
->owning_controller
;
1559 struct dev_to_host_fis
*frame_header
;
1560 enum sci_status status
;
1563 status
= sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1565 (void **)&frame_header
);
1567 if ((status
== SCI_SUCCESS
) &&
1568 (frame_header
->fis_type
== FIS_REGD2H
)) {
1569 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1571 (void **)&frame_buffer
);
1573 sci_controller_copy_sata_response(&ireq
->stp
.rsp
,
1578 sci_controller_release_frame(ihost
, frame_index
);
1583 static enum sci_status
process_unsolicited_fis(struct isci_request
*ireq
,
1586 struct isci_host
*ihost
= ireq
->owning_controller
;
1587 enum sci_status status
;
1588 struct dev_to_host_fis
*frame_header
;
1591 status
= sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1593 (void **)&frame_header
);
1595 if (status
!= SCI_SUCCESS
)
1598 if (frame_header
->fis_type
!= FIS_REGD2H
) {
1599 dev_err(&ireq
->isci_host
->pdev
->dev
,
1600 "%s ERROR: invalid fis type 0x%X\n",
1601 __func__
, frame_header
->fis_type
);
1605 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1607 (void **)&frame_buffer
);
1609 sci_controller_copy_sata_response(&ireq
->stp
.rsp
,
1610 (u32
*)frame_header
,
1613 /* Frame has been decoded return it to the controller */
1614 sci_controller_release_frame(ihost
, frame_index
);
1619 static enum sci_status
atapi_d2h_reg_frame_handler(struct isci_request
*ireq
,
1622 struct sas_task
*task
= isci_request_access_task(ireq
);
1623 enum sci_status status
;
1625 status
= process_unsolicited_fis(ireq
, frame_index
);
1627 if (status
== SCI_SUCCESS
) {
1628 if (ireq
->stp
.rsp
.status
& ATA_ERR
)
1629 status
= SCI_IO_FAILURE_RESPONSE_VALID
;
1631 status
= SCI_IO_FAILURE_RESPONSE_VALID
;
1634 if (status
!= SCI_SUCCESS
) {
1635 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1636 ireq
->sci_status
= status
;
1638 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1639 ireq
->sci_status
= SCI_SUCCESS
;
1642 /* the d2h ufi is the end of non-data commands */
1643 if (task
->data_dir
== DMA_NONE
)
1644 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1649 static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request
*ireq
)
1651 struct ata_device
*dev
= sas_to_ata_dev(ireq
->target_device
->domain_dev
);
1652 void *atapi_cdb
= ireq
->ttype_ptr
.io_task_ptr
->ata_task
.atapi_packet
;
1653 struct scu_task_context
*task_context
= ireq
->tc
;
1655 /* fill in the SCU Task Context for a DATA fis containing CDB in Raw Frame
1656 * type. The TC for previous Packet fis was already there, we only need to
1657 * change the H2D fis content.
1659 memset(&ireq
->stp
.cmd
, 0, sizeof(struct host_to_dev_fis
));
1660 memcpy(((u8
*)&ireq
->stp
.cmd
+ sizeof(u32
)), atapi_cdb
, ATAPI_CDB_LEN
);
1661 memset(&(task_context
->type
.stp
), 0, sizeof(struct stp_task_context
));
1662 task_context
->type
.stp
.fis_type
= FIS_DATA
;
1663 task_context
->transfer_length_bytes
= dev
->cdb_len
;
1666 static void scu_atapi_construct_task_context(struct isci_request
*ireq
)
1668 struct ata_device
*dev
= sas_to_ata_dev(ireq
->target_device
->domain_dev
);
1669 struct sas_task
*task
= isci_request_access_task(ireq
);
1670 struct scu_task_context
*task_context
= ireq
->tc
;
1671 int cdb_len
= dev
->cdb_len
;
1673 /* reference: SSTL 1.13.4.2
1674 * task_type, sata_direction
1676 if (task
->data_dir
== DMA_TO_DEVICE
) {
1677 task_context
->task_type
= SCU_TASK_TYPE_PACKET_DMA_OUT
;
1678 task_context
->sata_direction
= 0;
1680 /* todo: for NO_DATA command, we need to send out raw frame. */
1681 task_context
->task_type
= SCU_TASK_TYPE_PACKET_DMA_IN
;
1682 task_context
->sata_direction
= 1;
1685 memset(&task_context
->type
.stp
, 0, sizeof(task_context
->type
.stp
));
1686 task_context
->type
.stp
.fis_type
= FIS_DATA
;
1688 memset(&ireq
->stp
.cmd
, 0, sizeof(ireq
->stp
.cmd
));
1689 memcpy(&ireq
->stp
.cmd
.lbal
, task
->ata_task
.atapi_packet
, cdb_len
);
1690 task_context
->ssp_command_iu_length
= cdb_len
/ sizeof(u32
);
1692 /* task phase is set to TX_CMD */
1693 task_context
->task_phase
= 0x1;
1696 task_context
->stp_retry_count
= 0;
1698 /* data transfer size. */
1699 task_context
->transfer_length_bytes
= task
->total_xfer_len
;
1702 sci_request_build_sgl(ireq
);
1706 sci_io_request_frame_handler(struct isci_request
*ireq
,
1709 struct isci_host
*ihost
= ireq
->owning_controller
;
1710 struct isci_stp_request
*stp_req
= &ireq
->stp
.req
;
1711 enum sci_base_request_states state
;
1712 enum sci_status status
;
1715 state
= ireq
->sm
.current_state_id
;
1717 case SCI_REQ_STARTED
: {
1718 struct ssp_frame_hdr ssp_hdr
;
1721 sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1725 word_cnt
= sizeof(struct ssp_frame_hdr
) / sizeof(u32
);
1726 sci_swab32_cpy(&ssp_hdr
, frame_header
, word_cnt
);
1728 if (ssp_hdr
.frame_type
== SSP_RESPONSE
) {
1729 struct ssp_response_iu
*resp_iu
;
1730 ssize_t word_cnt
= SSP_RESP_IU_MAX_SIZE
/ sizeof(u32
);
1732 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1736 sci_swab32_cpy(&ireq
->ssp
.rsp
, resp_iu
, word_cnt
);
1738 resp_iu
= &ireq
->ssp
.rsp
;
1740 if (resp_iu
->datapres
== 0x01 ||
1741 resp_iu
->datapres
== 0x02) {
1742 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1743 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1745 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1746 ireq
->sci_status
= SCI_SUCCESS
;
1749 /* not a response frame, why did it get forwarded? */
1750 dev_err(&ihost
->pdev
->dev
,
1751 "%s: SCIC IO Request 0x%p received unexpected "
1752 "frame %d type 0x%02x\n", __func__
, ireq
,
1753 frame_index
, ssp_hdr
.frame_type
);
1757 * In any case we are done with this frame buffer return it to
1760 sci_controller_release_frame(ihost
, frame_index
);
1765 case SCI_REQ_TASK_WAIT_TC_RESP
:
1766 sci_io_request_copy_response(ireq
);
1767 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1768 sci_controller_release_frame(ihost
, frame_index
);
1771 case SCI_REQ_SMP_WAIT_RESP
: {
1772 struct sas_task
*task
= isci_request_access_task(ireq
);
1773 struct scatterlist
*sg
= &task
->smp_task
.smp_resp
;
1774 void *frame_header
, *kaddr
;
1777 sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1780 kaddr
= kmap_atomic(sg_page(sg
));
1781 rsp
= kaddr
+ sg
->offset
;
1782 sci_swab32_cpy(rsp
, frame_header
, 1);
1784 if (rsp
[0] == SMP_RESPONSE
) {
1787 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1791 word_cnt
= (sg
->length
/4)-1;
1793 word_cnt
= min_t(unsigned int, word_cnt
,
1794 SCU_UNSOLICITED_FRAME_BUFFER_SIZE
/4);
1795 sci_swab32_cpy(rsp
+ 4, smp_resp
, word_cnt
);
1797 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
1798 ireq
->sci_status
= SCI_SUCCESS
;
1799 sci_change_state(&ireq
->sm
, SCI_REQ_SMP_WAIT_TC_COMP
);
1802 * This was not a response frame why did it get
1805 dev_err(&ihost
->pdev
->dev
,
1806 "%s: SCIC SMP Request 0x%p received unexpected "
1807 "frame %d type 0x%02x\n",
1813 ireq
->scu_status
= SCU_TASK_DONE_SMP_FRM_TYPE_ERR
;
1814 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
1815 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1817 kunmap_atomic(kaddr
);
1819 sci_controller_release_frame(ihost
, frame_index
);
1824 case SCI_REQ_STP_UDMA_WAIT_TC_COMP
:
1825 return sci_stp_request_udma_general_frame_handler(ireq
,
1828 case SCI_REQ_STP_UDMA_WAIT_D2H
:
1829 /* Use the general frame handler to copy the resposne data */
1830 status
= sci_stp_request_udma_general_frame_handler(ireq
, frame_index
);
1832 if (status
!= SCI_SUCCESS
)
1835 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1836 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1837 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1840 case SCI_REQ_STP_NON_DATA_WAIT_D2H
: {
1841 struct dev_to_host_fis
*frame_header
;
1844 status
= sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1846 (void **)&frame_header
);
1848 if (status
!= SCI_SUCCESS
) {
1849 dev_err(&ihost
->pdev
->dev
,
1850 "%s: SCIC IO Request 0x%p could not get frame "
1851 "header for frame index %d, status %x\n",
1860 switch (frame_header
->fis_type
) {
1862 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1864 (void **)&frame_buffer
);
1866 sci_controller_copy_sata_response(&ireq
->stp
.rsp
,
1870 /* The command has completed with error */
1871 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1872 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1876 dev_warn(&ihost
->pdev
->dev
,
1877 "%s: IO Request:0x%p Frame Id:%d protocol "
1878 "violation occurred\n", __func__
, stp_req
,
1881 ireq
->scu_status
= SCU_TASK_DONE_UNEXP_FIS
;
1882 ireq
->sci_status
= SCI_FAILURE_PROTOCOL_VIOLATION
;
1886 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1888 /* Frame has been decoded return it to the controller */
1889 sci_controller_release_frame(ihost
, frame_index
);
1894 case SCI_REQ_STP_PIO_WAIT_FRAME
: {
1895 struct sas_task
*task
= isci_request_access_task(ireq
);
1896 struct dev_to_host_fis
*frame_header
;
1899 status
= sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
1901 (void **)&frame_header
);
1903 if (status
!= SCI_SUCCESS
) {
1904 dev_err(&ihost
->pdev
->dev
,
1905 "%s: SCIC IO Request 0x%p could not get frame "
1906 "header for frame index %d, status %x\n",
1907 __func__
, stp_req
, frame_index
, status
);
1911 switch (frame_header
->fis_type
) {
1913 /* Get from the frame buffer the PIO Setup Data */
1914 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1916 (void **)&frame_buffer
);
1918 /* Get the data from the PIO Setup The SCU Hardware
1919 * returns first word in the frame_header and the rest
1920 * of the data is in the frame buffer so we need to
1924 /* transfer_count: first 16bits in the 4th dword */
1925 stp_req
->pio_len
= frame_buffer
[3] & 0xffff;
1927 /* status: 4th byte in the 3rd dword */
1928 stp_req
->status
= (frame_buffer
[2] >> 24) & 0xff;
1930 sci_controller_copy_sata_response(&ireq
->stp
.rsp
,
1934 ireq
->stp
.rsp
.status
= stp_req
->status
;
1936 /* The next state is dependent on whether the
1937 * request was PIO Data-in or Data out
1939 if (task
->data_dir
== DMA_FROM_DEVICE
) {
1940 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_DATA_IN
);
1941 } else if (task
->data_dir
== DMA_TO_DEVICE
) {
1943 status
= sci_stp_request_pio_data_out_transmit_data(ireq
);
1944 if (status
!= SCI_SUCCESS
)
1946 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_DATA_OUT
);
1950 case FIS_SETDEVBITS
:
1951 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_WAIT_FRAME
);
1955 if (frame_header
->status
& ATA_BUSY
) {
1957 * Now why is the drive sending a D2H Register
1958 * FIS when it is still busy? Do nothing since
1959 * we are still in the right state.
1961 dev_dbg(&ihost
->pdev
->dev
,
1962 "%s: SCIC PIO Request 0x%p received "
1963 "D2H Register FIS with BSY status "
1967 frame_header
->status
);
1971 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
1973 (void **)&frame_buffer
);
1975 sci_controller_copy_sata_response(&ireq
->stp
.req
,
1979 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
1980 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
1981 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
1985 /* FIXME: what do we do here? */
1989 /* Frame is decoded return it to the controller */
1990 sci_controller_release_frame(ihost
, frame_index
);
1995 case SCI_REQ_STP_PIO_DATA_IN
: {
1996 struct dev_to_host_fis
*frame_header
;
1997 struct sata_fis_data
*frame_buffer
;
1999 status
= sci_unsolicited_frame_control_get_header(&ihost
->uf_control
,
2001 (void **)&frame_header
);
2003 if (status
!= SCI_SUCCESS
) {
2004 dev_err(&ihost
->pdev
->dev
,
2005 "%s: SCIC IO Request 0x%p could not get frame "
2006 "header for frame index %d, status %x\n",
2014 if (frame_header
->fis_type
!= FIS_DATA
) {
2015 dev_err(&ihost
->pdev
->dev
,
2016 "%s: SCIC PIO Request 0x%p received frame %d "
2017 "with fis type 0x%02x when expecting a data "
2022 frame_header
->fis_type
);
2024 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
2025 ireq
->sci_status
= SCI_FAILURE_IO_REQUIRES_SCSI_ABORT
;
2026 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2028 /* Frame is decoded return it to the controller */
2029 sci_controller_release_frame(ihost
, frame_index
);
2033 if (stp_req
->sgl
.index
< 0) {
2034 ireq
->saved_rx_frame_index
= frame_index
;
2035 stp_req
->pio_len
= 0;
2037 sci_unsolicited_frame_control_get_buffer(&ihost
->uf_control
,
2039 (void **)&frame_buffer
);
2041 status
= sci_stp_request_pio_data_in_copy_data(stp_req
,
2042 (u8
*)frame_buffer
);
2044 /* Frame is decoded return it to the controller */
2045 sci_controller_release_frame(ihost
, frame_index
);
2048 /* Check for the end of the transfer, are there more
2049 * bytes remaining for this data transfer
2051 if (status
!= SCI_SUCCESS
|| stp_req
->pio_len
!= 0)
2054 if ((stp_req
->status
& ATA_BUSY
) == 0) {
2055 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
2056 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
2057 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2059 sci_change_state(&ireq
->sm
, SCI_REQ_STP_PIO_WAIT_FRAME
);
2064 case SCI_REQ_ATAPI_WAIT_PIO_SETUP
: {
2065 struct sas_task
*task
= isci_request_access_task(ireq
);
2067 sci_controller_release_frame(ihost
, frame_index
);
2068 ireq
->target_device
->working_request
= ireq
;
2069 if (task
->data_dir
== DMA_NONE
) {
2070 sci_change_state(&ireq
->sm
, SCI_REQ_ATAPI_WAIT_TC_COMP
);
2071 scu_atapi_reconstruct_raw_frame_task_context(ireq
);
2073 sci_change_state(&ireq
->sm
, SCI_REQ_ATAPI_WAIT_D2H
);
2074 scu_atapi_construct_task_context(ireq
);
2077 sci_controller_continue_io(ireq
);
2080 case SCI_REQ_ATAPI_WAIT_D2H
:
2081 return atapi_d2h_reg_frame_handler(ireq
, frame_index
);
2082 case SCI_REQ_ABORTING
:
2084 * TODO: Is it even possible to get an unsolicited frame in the
2087 sci_controller_release_frame(ihost
, frame_index
);
2091 dev_warn(&ihost
->pdev
->dev
,
2092 "%s: SCIC IO Request given unexpected frame %x while "
2098 sci_controller_release_frame(ihost
, frame_index
);
2099 return SCI_FAILURE_INVALID_STATE
;
2103 static enum sci_status
stp_request_udma_await_tc_event(struct isci_request
*ireq
,
2104 u32 completion_code
)
2106 enum sci_status status
= SCI_SUCCESS
;
2108 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
2109 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
2110 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
2111 ireq
->sci_status
= SCI_SUCCESS
;
2112 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2114 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS
):
2115 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR
):
2116 /* We must check ther response buffer to see if the D2H
2117 * Register FIS was received before we got the TC
2120 if (ireq
->stp
.rsp
.fis_type
== FIS_REGD2H
) {
2121 sci_remote_device_suspend(ireq
->target_device
,
2122 SCI_SW_SUSPEND_NORMAL
);
2124 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
2125 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
2126 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2128 /* If we have an error completion status for the
2129 * TC then we can expect a D2H register FIS from
2130 * the device so we must change state to wait
2133 sci_change_state(&ireq
->sm
, SCI_REQ_STP_UDMA_WAIT_D2H
);
2137 /* TODO Check to see if any of these completion status need to
2138 * wait for the device to host register fis.
2140 /* TODO We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR
2141 * - this comes only for B0
2144 /* All other completion status cause the IO to be complete. */
2145 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
2146 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
2147 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2154 static enum sci_status
atapi_raw_completion(struct isci_request
*ireq
, u32 completion_code
,
2155 enum sci_base_request_states next
)
2157 enum sci_status status
= SCI_SUCCESS
;
2159 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
2160 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD
):
2161 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
2162 ireq
->sci_status
= SCI_SUCCESS
;
2163 sci_change_state(&ireq
->sm
, next
);
2166 /* All other completion status cause the IO to be complete.
2167 * If a NAK was received, then it is up to the user to retry
2170 ireq
->scu_status
= SCU_NORMALIZE_COMPLETION_STATUS(completion_code
);
2171 ireq
->sci_status
= SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
;
2173 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2180 static enum sci_status
atapi_data_tc_completion_handler(struct isci_request
*ireq
,
2181 u32 completion_code
)
2183 struct isci_remote_device
*idev
= ireq
->target_device
;
2184 struct dev_to_host_fis
*d2h
= &ireq
->stp
.rsp
;
2185 enum sci_status status
= SCI_SUCCESS
;
2187 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code
)) {
2188 case (SCU_TASK_DONE_GOOD
<< SCU_COMPLETION_TL_STATUS_SHIFT
):
2189 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2192 case (SCU_TASK_DONE_UNEXP_FIS
<< SCU_COMPLETION_TL_STATUS_SHIFT
): {
2193 u16 len
= sci_req_tx_bytes(ireq
);
2195 /* likely non-error data underrrun, workaround missing
2196 * d2h frame from the controller
2198 if (d2h
->fis_type
!= FIS_REGD2H
) {
2199 d2h
->fis_type
= FIS_REGD2H
;
2200 d2h
->flags
= (1 << 6);
2204 d2h
->byte_count_low
= len
& 0xff;
2205 d2h
->byte_count_high
= len
>> 8;
2211 d2h
->sector_count
= 0x3;
2212 d2h
->sector_count_exp
= 0;
2218 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
2219 ireq
->sci_status
= SCI_SUCCESS_IO_DONE_EARLY
;
2220 status
= ireq
->sci_status
;
2222 /* the hw will have suspended the rnc, so complete the
2223 * request upon pending resume
2225 sci_change_state(&idev
->sm
, SCI_STP_DEV_ATAPI_ERROR
);
2228 case (SCU_TASK_DONE_EXCESS_DATA
<< SCU_COMPLETION_TL_STATUS_SHIFT
):
2229 /* In this case, there is no UF coming after.
2230 * compelte the IO now.
2232 ireq
->scu_status
= SCU_TASK_DONE_GOOD
;
2233 ireq
->sci_status
= SCI_SUCCESS
;
2234 sci_change_state(&ireq
->sm
, SCI_REQ_COMPLETED
);
2238 if (d2h
->fis_type
== FIS_REGD2H
) {
2239 /* UF received change the device state to ATAPI_ERROR */
2240 status
= ireq
->sci_status
;
2241 sci_change_state(&idev
->sm
, SCI_STP_DEV_ATAPI_ERROR
);
2243 /* If receiving any non-sucess TC status, no UF
2244 * received yet, then an UF for the status fis
2245 * is coming after (XXX: suspect this is
2246 * actually a protocol error or a bug like the
2247 * DONE_UNEXP_FIS case)
2249 ireq
->scu_status
= SCU_TASK_DONE_CHECK_RESPONSE
;
2250 ireq
->sci_status
= SCI_FAILURE_IO_RESPONSE_VALID
;
2252 sci_change_state(&ireq
->sm
, SCI_REQ_ATAPI_WAIT_D2H
);
2260 static int sci_request_smp_completion_status_is_tx_suspend(
2261 unsigned int completion_status
)
2263 switch (completion_status
) {
2264 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION
:
2265 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1
:
2266 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2
:
2267 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3
:
2268 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION
:
2269 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION
:
2275 static int sci_request_smp_completion_status_is_tx_rx_suspend(
2276 unsigned int completion_status
)
2278 return 0; /* There are no Tx/Rx SMP suspend conditions. */
2281 static int sci_request_ssp_completion_status_is_tx_suspend(
2282 unsigned int completion_status
)
2284 switch (completion_status
) {
2285 case SCU_TASK_DONE_TX_RAW_CMD_ERR
:
2286 case SCU_TASK_DONE_LF_ERR
:
2287 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION
:
2288 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1
:
2289 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2
:
2290 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3
:
2291 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION
:
2292 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION
:
2293 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY
:
2294 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED
:
2295 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED
:
2301 static int sci_request_ssp_completion_status_is_tx_rx_suspend(
2302 unsigned int completion_status
)
2304 return 0; /* There are no Tx/Rx SSP suspend conditions. */
2307 static int sci_request_stpsata_completion_status_is_tx_suspend(
2308 unsigned int completion_status
)
2310 switch (completion_status
) {
2311 case SCU_TASK_DONE_TX_RAW_CMD_ERR
:
2312 case SCU_TASK_DONE_LL_R_ERR
:
2313 case SCU_TASK_DONE_LL_PERR
:
2314 case SCU_TASK_DONE_REG_ERR
:
2315 case SCU_TASK_DONE_SDB_ERR
:
2316 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION
:
2317 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1
:
2318 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2
:
2319 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3
:
2320 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION
:
2321 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION
:
2322 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY
:
2323 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED
:
2324 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED
:
2331 static int sci_request_stpsata_completion_status_is_tx_rx_suspend(
2332 unsigned int completion_status
)
2334 switch (completion_status
) {
2335 case SCU_TASK_DONE_LF_ERR
:
2336 case SCU_TASK_DONE_LL_SY_TERM
:
2337 case SCU_TASK_DONE_LL_LF_TERM
:
2338 case SCU_TASK_DONE_BREAK_RCVD
:
2339 case SCU_TASK_DONE_INV_FIS_LEN
:
2340 case SCU_TASK_DONE_UNEXP_FIS
:
2341 case SCU_TASK_DONE_UNEXP_SDBFIS
:
2342 case SCU_TASK_DONE_MAX_PLD_ERR
:
2348 static void sci_request_handle_suspending_completions(
2349 struct isci_request
*ireq
,
2350 u32 completion_code
)
2355 switch (ireq
->protocol
) {
2356 case SAS_PROTOCOL_SMP
:
2357 is_tx
= sci_request_smp_completion_status_is_tx_suspend(
2359 is_tx_rx
= sci_request_smp_completion_status_is_tx_rx_suspend(
2362 case SAS_PROTOCOL_SSP
:
2363 is_tx
= sci_request_ssp_completion_status_is_tx_suspend(
2365 is_tx_rx
= sci_request_ssp_completion_status_is_tx_rx_suspend(
2368 case SAS_PROTOCOL_STP
:
2369 is_tx
= sci_request_stpsata_completion_status_is_tx_suspend(
2372 sci_request_stpsata_completion_status_is_tx_rx_suspend(
2376 dev_warn(&ireq
->isci_host
->pdev
->dev
,
2377 "%s: request %p has no valid protocol\n",
2381 if (is_tx
|| is_tx_rx
) {
2382 BUG_ON(is_tx
&& is_tx_rx
);
2384 sci_remote_node_context_suspend(
2385 &ireq
->target_device
->rnc
,
2387 (is_tx_rx
) ? SCU_EVENT_TL_RNC_SUSPEND_TX_RX
2388 : SCU_EVENT_TL_RNC_SUSPEND_TX
);
2393 sci_io_request_tc_completion(struct isci_request
*ireq
,
2394 u32 completion_code
)
2396 enum sci_base_request_states state
;
2397 struct isci_host
*ihost
= ireq
->owning_controller
;
2399 state
= ireq
->sm
.current_state_id
;
2401 /* Decode those completions that signal upcoming suspension events. */
2402 sci_request_handle_suspending_completions(
2403 ireq
, SCU_GET_COMPLETION_TL_STATUS(completion_code
));
2406 case SCI_REQ_STARTED
:
2407 return request_started_state_tc_event(ireq
, completion_code
);
2409 case SCI_REQ_TASK_WAIT_TC_COMP
:
2410 return ssp_task_request_await_tc_event(ireq
,
2413 case SCI_REQ_SMP_WAIT_RESP
:
2414 return smp_request_await_response_tc_event(ireq
,
2417 case SCI_REQ_SMP_WAIT_TC_COMP
:
2418 return smp_request_await_tc_event(ireq
, completion_code
);
2420 case SCI_REQ_STP_UDMA_WAIT_TC_COMP
:
2421 return stp_request_udma_await_tc_event(ireq
,
2424 case SCI_REQ_STP_NON_DATA_WAIT_H2D
:
2425 return stp_request_non_data_await_h2d_tc_event(ireq
,
2428 case SCI_REQ_STP_PIO_WAIT_H2D
:
2429 return stp_request_pio_await_h2d_completion_tc_event(ireq
,
2432 case SCI_REQ_STP_PIO_DATA_OUT
:
2433 return pio_data_out_tx_done_tc_event(ireq
, completion_code
);
2435 case SCI_REQ_ABORTING
:
2436 return request_aborting_state_tc_event(ireq
,
2439 case SCI_REQ_ATAPI_WAIT_H2D
:
2440 return atapi_raw_completion(ireq
, completion_code
,
2441 SCI_REQ_ATAPI_WAIT_PIO_SETUP
);
2443 case SCI_REQ_ATAPI_WAIT_TC_COMP
:
2444 return atapi_raw_completion(ireq
, completion_code
,
2445 SCI_REQ_ATAPI_WAIT_D2H
);
2447 case SCI_REQ_ATAPI_WAIT_D2H
:
2448 return atapi_data_tc_completion_handler(ireq
, completion_code
);
2451 dev_warn(&ihost
->pdev
->dev
, "%s: %x in wrong state %s\n",
2452 __func__
, completion_code
, req_state_name(state
));
2453 return SCI_FAILURE_INVALID_STATE
;
2458 * isci_request_process_response_iu() - This function sets the status and
2459 * response iu, in the task struct, from the request object for the upper
2461 * @sas_task: This parameter is the task struct from the upper layer driver.
2462 * @resp_iu: This parameter points to the response iu of the completed request.
2463 * @dev: This parameter specifies the linux device struct.
2467 static void isci_request_process_response_iu(
2468 struct sas_task
*task
,
2469 struct ssp_response_iu
*resp_iu
,
2474 "resp_iu->status = 0x%x,\nresp_iu->datapres = %d "
2475 "resp_iu->response_data_len = %x, "
2476 "resp_iu->sense_data_len = %x\nrepsonse data: ",
2481 resp_iu
->response_data_len
,
2482 resp_iu
->sense_data_len
);
2484 task
->task_status
.stat
= resp_iu
->status
;
2486 /* libsas updates the task status fields based on the response iu. */
2487 sas_ssp_task_response(dev
, task
, resp_iu
);
2491 * isci_request_set_open_reject_status() - This function prepares the I/O
2492 * completion for OPEN_REJECT conditions.
2493 * @request: This parameter is the completed isci_request object.
2494 * @response_ptr: This parameter specifies the service response for the I/O.
2495 * @status_ptr: This parameter specifies the exec status for the I/O.
2496 * @open_rej_reason: This parameter specifies the encoded reason for the
2497 * abandon-class reject.
2501 static void isci_request_set_open_reject_status(
2502 struct isci_request
*request
,
2503 struct sas_task
*task
,
2504 enum service_response
*response_ptr
,
2505 enum exec_status
*status_ptr
,
2506 enum sas_open_rej_reason open_rej_reason
)
2508 /* Task in the target is done. */
2509 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2510 *response_ptr
= SAS_TASK_UNDELIVERED
;
2511 *status_ptr
= SAS_OPEN_REJECT
;
2512 task
->task_status
.open_rej_reason
= open_rej_reason
;
2516 * isci_request_handle_controller_specific_errors() - This function decodes
2517 * controller-specific I/O completion error conditions.
2518 * @request: This parameter is the completed isci_request object.
2519 * @response_ptr: This parameter specifies the service response for the I/O.
2520 * @status_ptr: This parameter specifies the exec status for the I/O.
2524 static void isci_request_handle_controller_specific_errors(
2525 struct isci_remote_device
*idev
,
2526 struct isci_request
*request
,
2527 struct sas_task
*task
,
2528 enum service_response
*response_ptr
,
2529 enum exec_status
*status_ptr
)
2531 unsigned int cstatus
;
2533 cstatus
= request
->scu_status
;
2535 dev_dbg(&request
->isci_host
->pdev
->dev
,
2536 "%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR "
2537 "- controller status = 0x%x\n",
2538 __func__
, request
, cstatus
);
2540 /* Decode the controller-specific errors; most
2541 * important is to recognize those conditions in which
2542 * the target may still have a task outstanding that
2545 * Note that there are SCU completion codes being
2546 * named in the decode below for which SCIC has already
2547 * done work to handle them in a way other than as
2548 * a controller-specific completion code; these are left
2549 * in the decode below for completeness sake.
2552 case SCU_TASK_DONE_DMASETUP_DIRERR
:
2553 /* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */
2554 case SCU_TASK_DONE_XFERCNT_ERR
:
2555 /* Also SCU_TASK_DONE_SMP_UFI_ERR: */
2556 if (task
->task_proto
== SAS_PROTOCOL_SMP
) {
2557 /* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */
2558 *response_ptr
= SAS_TASK_COMPLETE
;
2560 /* See if the device has been/is being stopped. Note
2561 * that we ignore the quiesce state, since we are
2562 * concerned about the actual device state.
2565 *status_ptr
= SAS_DEVICE_UNKNOWN
;
2567 *status_ptr
= SAS_ABORTED_TASK
;
2569 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2571 /* Task in the target is not done. */
2572 *response_ptr
= SAS_TASK_UNDELIVERED
;
2575 *status_ptr
= SAS_DEVICE_UNKNOWN
;
2577 *status_ptr
= SAM_STAT_TASK_ABORTED
;
2579 clear_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2584 case SCU_TASK_DONE_CRC_ERR
:
2585 case SCU_TASK_DONE_NAK_CMD_ERR
:
2586 case SCU_TASK_DONE_EXCESS_DATA
:
2587 case SCU_TASK_DONE_UNEXP_FIS
:
2588 /* Also SCU_TASK_DONE_UNEXP_RESP: */
2589 case SCU_TASK_DONE_VIIT_ENTRY_NV
: /* TODO - conditions? */
2590 case SCU_TASK_DONE_IIT_ENTRY_NV
: /* TODO - conditions? */
2591 case SCU_TASK_DONE_RNCNV_OUTBOUND
: /* TODO - conditions? */
2592 /* These are conditions in which the target
2593 * has completed the task, so that no cleanup
2596 *response_ptr
= SAS_TASK_COMPLETE
;
2598 /* See if the device has been/is being stopped. Note
2599 * that we ignore the quiesce state, since we are
2600 * concerned about the actual device state.
2603 *status_ptr
= SAS_DEVICE_UNKNOWN
;
2605 *status_ptr
= SAS_ABORTED_TASK
;
2607 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2611 /* Note that the only open reject completion codes seen here will be
2612 * abandon-class codes; all others are automatically retried in the SCU.
2614 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION
:
2616 isci_request_set_open_reject_status(
2617 request
, task
, response_ptr
, status_ptr
,
2618 SAS_OREJ_WRONG_DEST
);
2621 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION
:
2623 /* Note - the return of AB0 will change when
2624 * libsas implements detection of zone violations.
2626 isci_request_set_open_reject_status(
2627 request
, task
, response_ptr
, status_ptr
,
2631 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1
:
2633 isci_request_set_open_reject_status(
2634 request
, task
, response_ptr
, status_ptr
,
2638 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2
:
2640 isci_request_set_open_reject_status(
2641 request
, task
, response_ptr
, status_ptr
,
2645 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3
:
2647 isci_request_set_open_reject_status(
2648 request
, task
, response_ptr
, status_ptr
,
2652 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION
:
2654 isci_request_set_open_reject_status(
2655 request
, task
, response_ptr
, status_ptr
,
2659 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY
:
2661 isci_request_set_open_reject_status(
2662 request
, task
, response_ptr
, status_ptr
,
2663 SAS_OREJ_STP_NORES
);
2666 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED
:
2668 isci_request_set_open_reject_status(
2669 request
, task
, response_ptr
, status_ptr
,
2673 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED
:
2675 isci_request_set_open_reject_status(
2676 request
, task
, response_ptr
, status_ptr
,
2677 SAS_OREJ_CONN_RATE
);
2680 case SCU_TASK_DONE_LL_R_ERR
:
2681 /* Also SCU_TASK_DONE_ACK_NAK_TO: */
2682 case SCU_TASK_DONE_LL_PERR
:
2683 case SCU_TASK_DONE_LL_SY_TERM
:
2684 /* Also SCU_TASK_DONE_NAK_ERR:*/
2685 case SCU_TASK_DONE_LL_LF_TERM
:
2686 /* Also SCU_TASK_DONE_DATA_LEN_ERR: */
2687 case SCU_TASK_DONE_LL_ABORT_ERR
:
2688 case SCU_TASK_DONE_SEQ_INV_TYPE
:
2689 /* Also SCU_TASK_DONE_UNEXP_XR: */
2690 case SCU_TASK_DONE_XR_IU_LEN_ERR
:
2691 case SCU_TASK_DONE_INV_FIS_LEN
:
2692 /* Also SCU_TASK_DONE_XR_WD_LEN: */
2693 case SCU_TASK_DONE_SDMA_ERR
:
2694 case SCU_TASK_DONE_OFFSET_ERR
:
2695 case SCU_TASK_DONE_MAX_PLD_ERR
:
2696 case SCU_TASK_DONE_LF_ERR
:
2697 case SCU_TASK_DONE_SMP_RESP_TO_ERR
: /* Escalate to dev reset? */
2698 case SCU_TASK_DONE_SMP_LL_RX_ERR
:
2699 case SCU_TASK_DONE_UNEXP_DATA
:
2700 case SCU_TASK_DONE_UNEXP_SDBFIS
:
2701 case SCU_TASK_DONE_REG_ERR
:
2702 case SCU_TASK_DONE_SDB_ERR
:
2703 case SCU_TASK_DONE_TASK_ABORT
:
2705 /* Task in the target is not done. */
2706 *response_ptr
= SAS_TASK_UNDELIVERED
;
2707 *status_ptr
= SAM_STAT_TASK_ABORTED
;
2709 if (task
->task_proto
== SAS_PROTOCOL_SMP
)
2710 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2712 clear_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2717 static void isci_process_stp_response(struct sas_task
*task
, struct dev_to_host_fis
*fis
)
2719 struct task_status_struct
*ts
= &task
->task_status
;
2720 struct ata_task_resp
*resp
= (void *)&ts
->buf
[0];
2722 resp
->frame_len
= sizeof(*fis
);
2723 memcpy(resp
->ending_fis
, fis
, sizeof(*fis
));
2724 ts
->buf_valid_size
= sizeof(*resp
);
2726 /* If the device fault bit is set in the status register, then
2727 * set the sense data and return.
2729 if (fis
->status
& ATA_DF
)
2730 ts
->stat
= SAS_PROTO_RESPONSE
;
2731 else if (fis
->status
& ATA_ERR
)
2732 ts
->stat
= SAM_STAT_CHECK_CONDITION
;
2734 ts
->stat
= SAM_STAT_GOOD
;
2736 ts
->resp
= SAS_TASK_COMPLETE
;
2739 static void isci_request_io_request_complete(struct isci_host
*ihost
,
2740 struct isci_request
*request
,
2741 enum sci_io_status completion_status
)
2743 struct sas_task
*task
= isci_request_access_task(request
);
2744 struct ssp_response_iu
*resp_iu
;
2745 unsigned long task_flags
;
2746 struct isci_remote_device
*idev
= request
->target_device
;
2747 enum service_response response
= SAS_TASK_UNDELIVERED
;
2748 enum exec_status status
= SAS_ABORTED_TASK
;
2750 dev_dbg(&ihost
->pdev
->dev
,
2751 "%s: request = %p, task = %p,\n"
2752 "task->data_dir = %d completion_status = 0x%x\n",
2759 /* The request is done from an SCU HW perspective. */
2761 /* This is an active request being completed from the core. */
2762 switch (completion_status
) {
2764 case SCI_IO_FAILURE_RESPONSE_VALID
:
2765 dev_dbg(&ihost
->pdev
->dev
,
2766 "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
2767 __func__
, request
, task
);
2769 if (sas_protocol_ata(task
->task_proto
)) {
2770 isci_process_stp_response(task
, &request
->stp
.rsp
);
2771 } else if (SAS_PROTOCOL_SSP
== task
->task_proto
) {
2773 /* crack the iu response buffer. */
2774 resp_iu
= &request
->ssp
.rsp
;
2775 isci_request_process_response_iu(task
, resp_iu
,
2778 } else if (SAS_PROTOCOL_SMP
== task
->task_proto
) {
2780 dev_err(&ihost
->pdev
->dev
,
2781 "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
2782 "SAS_PROTOCOL_SMP protocol\n",
2786 dev_err(&ihost
->pdev
->dev
,
2787 "%s: unknown protocol\n", __func__
);
2789 /* use the task status set in the task struct by the
2790 * isci_request_process_response_iu call.
2792 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2793 response
= task
->task_status
.resp
;
2794 status
= task
->task_status
.stat
;
2797 case SCI_IO_SUCCESS
:
2798 case SCI_IO_SUCCESS_IO_DONE_EARLY
:
2800 response
= SAS_TASK_COMPLETE
;
2801 status
= SAM_STAT_GOOD
;
2802 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2804 if (completion_status
== SCI_IO_SUCCESS_IO_DONE_EARLY
) {
2806 /* This was an SSP / STP / SATA transfer.
2807 * There is a possibility that less data than
2808 * the maximum was transferred.
2810 u32 transferred_length
= sci_req_tx_bytes(request
);
2812 task
->task_status
.residual
2813 = task
->total_xfer_len
- transferred_length
;
2815 /* If there were residual bytes, call this an
2818 if (task
->task_status
.residual
!= 0)
2819 status
= SAS_DATA_UNDERRUN
;
2821 dev_dbg(&ihost
->pdev
->dev
,
2822 "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
2826 dev_dbg(&ihost
->pdev
->dev
, "%s: SCI_IO_SUCCESS\n",
2830 case SCI_IO_FAILURE_TERMINATED
:
2832 dev_dbg(&ihost
->pdev
->dev
,
2833 "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
2834 __func__
, request
, task
);
2836 /* The request was terminated explicitly. */
2837 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2838 response
= SAS_TASK_UNDELIVERED
;
2840 /* See if the device has been/is being stopped. Note
2841 * that we ignore the quiesce state, since we are
2842 * concerned about the actual device state.
2845 status
= SAS_DEVICE_UNKNOWN
;
2847 status
= SAS_ABORTED_TASK
;
2850 case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
:
2852 isci_request_handle_controller_specific_errors(idev
, request
,
2857 case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
:
2858 /* This is a special case, in that the I/O completion
2859 * is telling us that the device needs a reset.
2860 * In order for the device reset condition to be
2861 * noticed, the I/O has to be handled in the error
2862 * handler. Set the reset flag and cause the
2863 * SCSI error thread to be scheduled.
2865 spin_lock_irqsave(&task
->task_state_lock
, task_flags
);
2866 task
->task_state_flags
|= SAS_TASK_NEED_DEV_RESET
;
2867 spin_unlock_irqrestore(&task
->task_state_lock
, task_flags
);
2870 response
= SAS_TASK_UNDELIVERED
;
2871 status
= SAM_STAT_TASK_ABORTED
;
2873 clear_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2876 case SCI_FAILURE_RETRY_REQUIRED
:
2878 /* Fail the I/O so it can be retried. */
2879 response
= SAS_TASK_UNDELIVERED
;
2881 status
= SAS_DEVICE_UNKNOWN
;
2883 status
= SAS_ABORTED_TASK
;
2885 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2890 /* Catch any otherwise unhandled error codes here. */
2891 dev_dbg(&ihost
->pdev
->dev
,
2892 "%s: invalid completion code: 0x%x - "
2893 "isci_request = %p\n",
2894 __func__
, completion_status
, request
);
2896 response
= SAS_TASK_UNDELIVERED
;
2898 /* See if the device has been/is being stopped. Note
2899 * that we ignore the quiesce state, since we are
2900 * concerned about the actual device state.
2903 status
= SAS_DEVICE_UNKNOWN
;
2905 status
= SAS_ABORTED_TASK
;
2907 if (SAS_PROTOCOL_SMP
== task
->task_proto
)
2908 set_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2910 clear_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
);
2914 switch (task
->task_proto
) {
2915 case SAS_PROTOCOL_SSP
:
2916 if (task
->data_dir
== DMA_NONE
)
2918 if (task
->num_scatter
== 0)
2919 /* 0 indicates a single dma address */
2920 dma_unmap_single(&ihost
->pdev
->dev
,
2921 request
->zero_scatter_daddr
,
2922 task
->total_xfer_len
, task
->data_dir
);
2923 else /* unmap the sgl dma addresses */
2924 dma_unmap_sg(&ihost
->pdev
->dev
, task
->scatter
,
2925 request
->num_sg_entries
, task
->data_dir
);
2927 case SAS_PROTOCOL_SMP
: {
2928 struct scatterlist
*sg
= &task
->smp_task
.smp_req
;
2929 struct smp_req
*smp_req
;
2932 dma_unmap_sg(&ihost
->pdev
->dev
, sg
, 1, DMA_TO_DEVICE
);
2934 /* need to swab it back in case the command buffer is re-used */
2935 kaddr
= kmap_atomic(sg_page(sg
));
2936 smp_req
= kaddr
+ sg
->offset
;
2937 sci_swab32_cpy(smp_req
, smp_req
, sg
->length
/ sizeof(u32
));
2938 kunmap_atomic(kaddr
);
2945 spin_lock_irqsave(&task
->task_state_lock
, task_flags
);
2947 task
->task_status
.resp
= response
;
2948 task
->task_status
.stat
= status
;
2950 if (test_bit(IREQ_COMPLETE_IN_TARGET
, &request
->flags
)) {
2951 /* Normal notification (task_done) */
2952 task
->task_state_flags
|= SAS_TASK_STATE_DONE
;
2953 task
->task_state_flags
&= ~(SAS_TASK_AT_INITIATOR
|
2954 SAS_TASK_STATE_PENDING
);
2956 spin_unlock_irqrestore(&task
->task_state_lock
, task_flags
);
2958 /* Add to the completed list. */
2959 list_add(&request
->completed_node
, &ihost
->requests_to_complete
);
2961 /* complete the io request to the core. */
2962 sci_controller_complete_io(ihost
, request
->target_device
, request
);
2964 /* set terminated handle so it cannot be completed or
2965 * terminated again, and to cause any calls into abort
2966 * task to recognize the already completed case.
2968 set_bit(IREQ_TERMINATED
, &request
->flags
);
2971 static void sci_request_started_state_enter(struct sci_base_state_machine
*sm
)
2973 struct isci_request
*ireq
= container_of(sm
, typeof(*ireq
), sm
);
2974 struct domain_device
*dev
= ireq
->target_device
->domain_dev
;
2975 enum sci_base_request_states state
;
2976 struct sas_task
*task
;
2978 /* XXX as hch said always creating an internal sas_task for tmf
2979 * requests would simplify the driver
2981 task
= (test_bit(IREQ_TMF
, &ireq
->flags
)) ? NULL
: isci_request_access_task(ireq
);
2983 /* all unaccelerated request types (non ssp or ncq) handled with
2986 if (!task
&& dev
->dev_type
== SAS_END_DEV
) {
2987 state
= SCI_REQ_TASK_WAIT_TC_COMP
;
2988 } else if (task
&& task
->task_proto
== SAS_PROTOCOL_SMP
) {
2989 state
= SCI_REQ_SMP_WAIT_RESP
;
2990 } else if (task
&& sas_protocol_ata(task
->task_proto
) &&
2991 !task
->ata_task
.use_ncq
) {
2992 if (dev
->sata_dev
.command_set
== ATAPI_COMMAND_SET
&&
2993 task
->ata_task
.fis
.command
== ATA_CMD_PACKET
) {
2994 state
= SCI_REQ_ATAPI_WAIT_H2D
;
2995 } else if (task
->data_dir
== DMA_NONE
) {
2996 state
= SCI_REQ_STP_NON_DATA_WAIT_H2D
;
2997 } else if (task
->ata_task
.dma_xfer
) {
2998 state
= SCI_REQ_STP_UDMA_WAIT_TC_COMP
;
3000 state
= SCI_REQ_STP_PIO_WAIT_H2D
;
3003 /* SSP or NCQ are fully accelerated, no substates */
3006 sci_change_state(sm
, state
);
3009 static void sci_request_completed_state_enter(struct sci_base_state_machine
*sm
)
3011 struct isci_request
*ireq
= container_of(sm
, typeof(*ireq
), sm
);
3012 struct isci_host
*ihost
= ireq
->owning_controller
;
3014 /* Tell the SCI_USER that the IO request is complete */
3015 if (!test_bit(IREQ_TMF
, &ireq
->flags
))
3016 isci_request_io_request_complete(ihost
, ireq
,
3019 isci_task_request_complete(ihost
, ireq
, ireq
->sci_status
);
3022 static void sci_request_aborting_state_enter(struct sci_base_state_machine
*sm
)
3024 struct isci_request
*ireq
= container_of(sm
, typeof(*ireq
), sm
);
3026 /* Setting the abort bit in the Task Context is required by the silicon. */
3027 ireq
->tc
->abort
= 1;
3030 static void sci_stp_request_started_non_data_await_h2d_completion_enter(struct sci_base_state_machine
*sm
)
3032 struct isci_request
*ireq
= container_of(sm
, typeof(*ireq
), sm
);
3034 ireq
->target_device
->working_request
= ireq
;
3037 static void sci_stp_request_started_pio_await_h2d_completion_enter(struct sci_base_state_machine
*sm
)
3039 struct isci_request
*ireq
= container_of(sm
, typeof(*ireq
), sm
);
3041 ireq
->target_device
->working_request
= ireq
;
3044 static const struct sci_base_state sci_request_state_table
[] = {
3045 [SCI_REQ_INIT
] = { },
3046 [SCI_REQ_CONSTRUCTED
] = { },
3047 [SCI_REQ_STARTED
] = {
3048 .enter_state
= sci_request_started_state_enter
,
3050 [SCI_REQ_STP_NON_DATA_WAIT_H2D
] = {
3051 .enter_state
= sci_stp_request_started_non_data_await_h2d_completion_enter
,
3053 [SCI_REQ_STP_NON_DATA_WAIT_D2H
] = { },
3054 [SCI_REQ_STP_PIO_WAIT_H2D
] = {
3055 .enter_state
= sci_stp_request_started_pio_await_h2d_completion_enter
,
3057 [SCI_REQ_STP_PIO_WAIT_FRAME
] = { },
3058 [SCI_REQ_STP_PIO_DATA_IN
] = { },
3059 [SCI_REQ_STP_PIO_DATA_OUT
] = { },
3060 [SCI_REQ_STP_UDMA_WAIT_TC_COMP
] = { },
3061 [SCI_REQ_STP_UDMA_WAIT_D2H
] = { },
3062 [SCI_REQ_TASK_WAIT_TC_COMP
] = { },
3063 [SCI_REQ_TASK_WAIT_TC_RESP
] = { },
3064 [SCI_REQ_SMP_WAIT_RESP
] = { },
3065 [SCI_REQ_SMP_WAIT_TC_COMP
] = { },
3066 [SCI_REQ_ATAPI_WAIT_H2D
] = { },
3067 [SCI_REQ_ATAPI_WAIT_PIO_SETUP
] = { },
3068 [SCI_REQ_ATAPI_WAIT_D2H
] = { },
3069 [SCI_REQ_ATAPI_WAIT_TC_COMP
] = { },
3070 [SCI_REQ_COMPLETED
] = {
3071 .enter_state
= sci_request_completed_state_enter
,
3073 [SCI_REQ_ABORTING
] = {
3074 .enter_state
= sci_request_aborting_state_enter
,
3076 [SCI_REQ_FINAL
] = { },
3080 sci_general_request_construct(struct isci_host
*ihost
,
3081 struct isci_remote_device
*idev
,
3082 struct isci_request
*ireq
)
3084 sci_init_sm(&ireq
->sm
, sci_request_state_table
, SCI_REQ_INIT
);
3086 ireq
->target_device
= idev
;
3087 ireq
->protocol
= SAS_PROTOCOL_NONE
;
3088 ireq
->saved_rx_frame_index
= SCU_INVALID_FRAME_INDEX
;
3090 ireq
->sci_status
= SCI_SUCCESS
;
3091 ireq
->scu_status
= 0;
3092 ireq
->post_context
= 0xFFFFFFFF;
3095 static enum sci_status
3096 sci_io_request_construct(struct isci_host
*ihost
,
3097 struct isci_remote_device
*idev
,
3098 struct isci_request
*ireq
)
3100 struct domain_device
*dev
= idev
->domain_dev
;
3101 enum sci_status status
= SCI_SUCCESS
;
3103 /* Build the common part of the request */
3104 sci_general_request_construct(ihost
, idev
, ireq
);
3106 if (idev
->rnc
.remote_node_index
== SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX
)
3107 return SCI_FAILURE_INVALID_REMOTE_DEVICE
;
3109 if (dev
->dev_type
== SAS_END_DEV
)
3111 else if (dev_is_sata(dev
))
3112 memset(&ireq
->stp
.cmd
, 0, sizeof(ireq
->stp
.cmd
));
3113 else if (dev_is_expander(dev
))
3116 return SCI_FAILURE_UNSUPPORTED_PROTOCOL
;
3118 memset(ireq
->tc
, 0, offsetof(struct scu_task_context
, sgl_pair_ab
));
3123 enum sci_status
sci_task_request_construct(struct isci_host
*ihost
,
3124 struct isci_remote_device
*idev
,
3125 u16 io_tag
, struct isci_request
*ireq
)
3127 struct domain_device
*dev
= idev
->domain_dev
;
3128 enum sci_status status
= SCI_SUCCESS
;
3130 /* Build the common part of the request */
3131 sci_general_request_construct(ihost
, idev
, ireq
);
3133 if (dev
->dev_type
== SAS_END_DEV
|| dev_is_sata(dev
)) {
3134 set_bit(IREQ_TMF
, &ireq
->flags
);
3135 memset(ireq
->tc
, 0, sizeof(struct scu_task_context
));
3137 /* Set the protocol indicator. */
3138 if (dev_is_sata(dev
))
3139 ireq
->protocol
= SAS_PROTOCOL_STP
;
3141 ireq
->protocol
= SAS_PROTOCOL_SSP
;
3143 status
= SCI_FAILURE_UNSUPPORTED_PROTOCOL
;
3148 static enum sci_status
isci_request_ssp_request_construct(
3149 struct isci_request
*request
)
3151 enum sci_status status
;
3153 dev_dbg(&request
->isci_host
->pdev
->dev
,
3154 "%s: request = %p\n",
3157 status
= sci_io_request_construct_basic_ssp(request
);
3161 static enum sci_status
isci_request_stp_request_construct(struct isci_request
*ireq
)
3163 struct sas_task
*task
= isci_request_access_task(ireq
);
3164 struct host_to_dev_fis
*fis
= &ireq
->stp
.cmd
;
3165 struct ata_queued_cmd
*qc
= task
->uldd_task
;
3166 enum sci_status status
;
3168 dev_dbg(&ireq
->isci_host
->pdev
->dev
,
3173 memcpy(fis
, &task
->ata_task
.fis
, sizeof(struct host_to_dev_fis
));
3174 if (!task
->ata_task
.device_control_reg_update
)
3178 status
= sci_io_request_construct_basic_sata(ireq
);
3180 if (qc
&& (qc
->tf
.command
== ATA_CMD_FPDMA_WRITE
||
3181 qc
->tf
.command
== ATA_CMD_FPDMA_READ
)) {
3182 fis
->sector_count
= qc
->tag
<< 3;
3183 ireq
->tc
->type
.stp
.ncq_tag
= qc
->tag
;
3189 static enum sci_status
3190 sci_io_request_construct_smp(struct device
*dev
,
3191 struct isci_request
*ireq
,
3192 struct sas_task
*task
)
3194 struct scatterlist
*sg
= &task
->smp_task
.smp_req
;
3195 struct isci_remote_device
*idev
;
3196 struct scu_task_context
*task_context
;
3197 struct isci_port
*iport
;
3198 struct smp_req
*smp_req
;
3203 kaddr
= kmap_atomic(sg_page(sg
));
3204 smp_req
= kaddr
+ sg
->offset
;
3206 * Look at the SMP requests' header fields; for certain SAS 1.x SMP
3207 * functions under SAS 2.0, a zero request length really indicates
3208 * a non-zero default length.
3210 if (smp_req
->req_len
== 0) {
3211 switch (smp_req
->func
) {
3213 case SMP_REPORT_PHY_ERR_LOG
:
3214 case SMP_REPORT_PHY_SATA
:
3215 case SMP_REPORT_ROUTE_INFO
:
3216 smp_req
->req_len
= 2;
3218 case SMP_CONF_ROUTE_INFO
:
3219 case SMP_PHY_CONTROL
:
3220 case SMP_PHY_TEST_FUNCTION
:
3221 smp_req
->req_len
= 9;
3223 /* Default - zero is a valid default for 2.0. */
3226 req_len
= smp_req
->req_len
;
3227 sci_swab32_cpy(smp_req
, smp_req
, sg
->length
/ sizeof(u32
));
3228 cmd
= *(u32
*) smp_req
;
3229 kunmap_atomic(kaddr
);
3231 if (!dma_map_sg(dev
, sg
, 1, DMA_TO_DEVICE
))
3234 ireq
->protocol
= SAS_PROTOCOL_SMP
;
3236 /* byte swap the smp request. */
3238 task_context
= ireq
->tc
;
3240 idev
= ireq
->target_device
;
3241 iport
= idev
->owning_port
;
3244 * Fill in the TC with the its required data
3247 task_context
->priority
= 0;
3248 task_context
->initiator_request
= 1;
3249 task_context
->connection_rate
= idev
->connection_rate
;
3250 task_context
->protocol_engine_index
= ISCI_PEG
;
3251 task_context
->logical_port_index
= iport
->physical_port_index
;
3252 task_context
->protocol_type
= SCU_TASK_CONTEXT_PROTOCOL_SMP
;
3253 task_context
->abort
= 0;
3254 task_context
->valid
= SCU_TASK_CONTEXT_VALID
;
3255 task_context
->context_type
= SCU_TASK_CONTEXT_TYPE
;
3258 task_context
->remote_node_index
= idev
->rnc
.remote_node_index
;
3259 task_context
->command_code
= 0;
3260 task_context
->task_type
= SCU_TASK_TYPE_SMP_REQUEST
;
3263 task_context
->link_layer_control
= 0;
3264 task_context
->do_not_dma_ssp_good_response
= 1;
3265 task_context
->strict_ordering
= 0;
3266 task_context
->control_frame
= 1;
3267 task_context
->timeout_enable
= 0;
3268 task_context
->block_guard_enable
= 0;
3271 task_context
->address_modifier
= 0;
3274 task_context
->ssp_command_iu_length
= req_len
;
3277 task_context
->transfer_length_bytes
= 0;
3280 * 18h ~ 30h, protocol specific
3281 * since commandIU has been build by framework at this point, we just
3282 * copy the frist DWord from command IU to this location. */
3283 memcpy(&task_context
->type
.smp
, &cmd
, sizeof(u32
));
3287 * "For SMP you could program it to zero. We would prefer that way
3288 * so that done code will be consistent." - Venki
3290 task_context
->task_phase
= 0;
3292 ireq
->post_context
= (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC
|
3293 (ISCI_PEG
<< SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT
) |
3294 (iport
->physical_port_index
<<
3295 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT
) |
3296 ISCI_TAG_TCI(ireq
->io_tag
));
3298 * Copy the physical address for the command buffer to the SCU Task
3299 * Context command buffer should not contain command header.
3301 task_context
->command_iu_upper
= upper_32_bits(sg_dma_address(sg
));
3302 task_context
->command_iu_lower
= lower_32_bits(sg_dma_address(sg
) + sizeof(u32
));
3304 /* SMP response comes as UF, so no need to set response IU address. */
3305 task_context
->response_iu_upper
= 0;
3306 task_context
->response_iu_lower
= 0;
3308 sci_change_state(&ireq
->sm
, SCI_REQ_CONSTRUCTED
);
3314 * isci_smp_request_build() - This function builds the smp request.
3315 * @ireq: This parameter points to the isci_request allocated in the
3316 * request construct function.
3318 * SCI_SUCCESS on successfull completion, or specific failure code.
3320 static enum sci_status
isci_smp_request_build(struct isci_request
*ireq
)
3322 struct sas_task
*task
= isci_request_access_task(ireq
);
3323 struct device
*dev
= &ireq
->isci_host
->pdev
->dev
;
3324 enum sci_status status
= SCI_FAILURE
;
3326 status
= sci_io_request_construct_smp(dev
, ireq
, task
);
3327 if (status
!= SCI_SUCCESS
)
3328 dev_dbg(&ireq
->isci_host
->pdev
->dev
,
3329 "%s: failed with status = %d\n",
3337 * isci_io_request_build() - This function builds the io request object.
3338 * @ihost: This parameter specifies the ISCI host object
3339 * @request: This parameter points to the isci_request object allocated in the
3340 * request construct function.
3341 * @sci_device: This parameter is the handle for the sci core's remote device
3342 * object that is the destination for this request.
3344 * SCI_SUCCESS on successfull completion, or specific failure code.
3346 static enum sci_status
isci_io_request_build(struct isci_host
*ihost
,
3347 struct isci_request
*request
,
3348 struct isci_remote_device
*idev
)
3350 enum sci_status status
= SCI_SUCCESS
;
3351 struct sas_task
*task
= isci_request_access_task(request
);
3353 dev_dbg(&ihost
->pdev
->dev
,
3354 "%s: idev = 0x%p; request = %p, "
3355 "num_scatter = %d\n",
3361 /* map the sgl addresses, if present.
3362 * libata does the mapping for sata devices
3363 * before we get the request.
3365 if (task
->num_scatter
&&
3366 !sas_protocol_ata(task
->task_proto
) &&
3367 !(SAS_PROTOCOL_SMP
& task
->task_proto
)) {
3369 request
->num_sg_entries
= dma_map_sg(
3376 if (request
->num_sg_entries
== 0)
3377 return SCI_FAILURE_INSUFFICIENT_RESOURCES
;
3380 status
= sci_io_request_construct(ihost
, idev
, request
);
3382 if (status
!= SCI_SUCCESS
) {
3383 dev_dbg(&ihost
->pdev
->dev
,
3384 "%s: failed request construct\n",
3389 switch (task
->task_proto
) {
3390 case SAS_PROTOCOL_SMP
:
3391 status
= isci_smp_request_build(request
);
3393 case SAS_PROTOCOL_SSP
:
3394 status
= isci_request_ssp_request_construct(request
);
3396 case SAS_PROTOCOL_SATA
:
3397 case SAS_PROTOCOL_STP
:
3398 case SAS_PROTOCOL_SATA
| SAS_PROTOCOL_STP
:
3399 status
= isci_request_stp_request_construct(request
);
3402 dev_dbg(&ihost
->pdev
->dev
,
3403 "%s: unknown protocol\n", __func__
);
3410 static struct isci_request
*isci_request_from_tag(struct isci_host
*ihost
, u16 tag
)
3412 struct isci_request
*ireq
;
3414 ireq
= ihost
->reqs
[ISCI_TAG_TCI(tag
)];
3416 ireq
->io_request_completion
= NULL
;
3418 ireq
->num_sg_entries
= 0;
3419 INIT_LIST_HEAD(&ireq
->completed_node
);
3424 static struct isci_request
*isci_io_request_from_tag(struct isci_host
*ihost
,
3425 struct sas_task
*task
,
3428 struct isci_request
*ireq
;
3430 ireq
= isci_request_from_tag(ihost
, tag
);
3431 ireq
->ttype_ptr
.io_task_ptr
= task
;
3432 clear_bit(IREQ_TMF
, &ireq
->flags
);
3433 task
->lldd_task
= ireq
;
3438 struct isci_request
*isci_tmf_request_from_tag(struct isci_host
*ihost
,
3439 struct isci_tmf
*isci_tmf
,
3442 struct isci_request
*ireq
;
3444 ireq
= isci_request_from_tag(ihost
, tag
);
3445 ireq
->ttype_ptr
.tmf_task_ptr
= isci_tmf
;
3446 set_bit(IREQ_TMF
, &ireq
->flags
);
3451 int isci_request_execute(struct isci_host
*ihost
, struct isci_remote_device
*idev
,
3452 struct sas_task
*task
, u16 tag
)
3454 enum sci_status status
= SCI_FAILURE_UNSUPPORTED_PROTOCOL
;
3455 struct isci_request
*ireq
;
3456 unsigned long flags
;
3459 /* do common allocation and init of request object. */
3460 ireq
= isci_io_request_from_tag(ihost
, task
, tag
);
3462 status
= isci_io_request_build(ihost
, ireq
, idev
);
3463 if (status
!= SCI_SUCCESS
) {
3464 dev_dbg(&ihost
->pdev
->dev
,
3465 "%s: request_construct failed - status = 0x%x\n",
3471 spin_lock_irqsave(&ihost
->scic_lock
, flags
);
3473 if (test_bit(IDEV_IO_NCQERROR
, &idev
->flags
)) {
3475 if (isci_task_is_ncq_recovery(task
)) {
3477 /* The device is in an NCQ recovery state. Issue the
3478 * request on the task side. Note that it will
3479 * complete on the I/O request side because the
3480 * request was built that way (ie.
3481 * ireq->is_task_management_request is false).
3483 status
= sci_controller_start_task(ihost
,
3487 status
= SCI_FAILURE
;
3490 /* send the request, let the core assign the IO TAG. */
3491 status
= sci_controller_start_io(ihost
, idev
,
3495 if (status
!= SCI_SUCCESS
&&
3496 status
!= SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
) {
3497 dev_dbg(&ihost
->pdev
->dev
,
3498 "%s: failed request start (0x%x)\n",
3500 spin_unlock_irqrestore(&ihost
->scic_lock
, flags
);
3503 /* Either I/O started OK, or the core has signaled that
3504 * the device needs a target reset.
3506 if (status
!= SCI_SUCCESS
) {
3507 /* The request did not really start in the
3508 * hardware, so clear the request handle
3509 * here so no terminations will be done.
3511 set_bit(IREQ_TERMINATED
, &ireq
->flags
);
3513 spin_unlock_irqrestore(&ihost
->scic_lock
, flags
);
3516 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
) {
3517 /* Signal libsas that we need the SCSI error
3518 * handler thread to work on this I/O and that
3519 * we want a device reset.
3521 spin_lock_irqsave(&task
->task_state_lock
, flags
);
3522 task
->task_state_flags
|= SAS_TASK_NEED_DEV_RESET
;
3523 spin_unlock_irqrestore(&task
->task_state_lock
, flags
);
3525 /* Cause this task to be scheduled in the SCSI error
3528 sas_task_abort(task
);
3530 /* Change the status, since we are holding
3531 * the I/O until it is managed by the SCSI
3534 status
= SCI_SUCCESS
;