projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
isci: cleanup/optimize pool implementation
[deliverable/linux.git] / drivers / scsi / isci / request.c
CommitLineData
6f231dda
DW		 1/*
2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
4 *
5 * GPL LICENSE SUMMARY
6 *
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
23 *
24 * BSD LICENSE
25 *
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
28 *
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
31 * are met:
32 *
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
38 * distribution.
39 * * 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.
42 *
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.
54 */
55
56#include "isci.h"
6f231dda
DW		 57#include "task.h"
58#include "request.h"
59#include "sata.h"
60#include "scu_completion_codes.h"
5dec6f4e 61#include "scu_event_codes.h"
2ec53eb4 62#include "sas.h"
6f231dda 63
f1f52e75
DW		 64/**
65 * This method returns the sgl element pair for the specificed sgl_pair index.
66 * @sci_req: This parameter specifies the IO request for which to retrieve
67 * the Scatter-Gather List element pair.
68 * @sgl_pair_index: This parameter specifies the index into the SGL element
69 * pair to be retrieved.
70 *
71 * This method returns a pointer to an struct scu_sgl_element_pair.
72 */
73static struct scu_sgl_element_pair *scic_sds_request_get_sgl_element_pair(
74 struct scic_sds_request *sci_req,
75 u32 sgl_pair_index
76 ) {
77 struct scu_task_context *task_context;
78
79 task_context = (struct scu_task_context *)sci_req->task_context_buffer;
80
81 if (sgl_pair_index == 0) {
82 return &task_context->sgl_pair_ab;
83 } else if (sgl_pair_index == 1) {
84 return &task_context->sgl_pair_cd;
85 }
6f231dda 86
f1f52e75 87 return &sci_req->sg_table[sgl_pair_index - 2];
6f231dda
DW		 88}
89
f1f52e75
DW		 90/**
91 * This function will build the SGL list for an IO request.
92 * @sci_req: This parameter specifies the IO request for which to build
93 * the Scatter-Gather List.
94 *
95 */
5dec6f4e 96static void scic_sds_request_build_sgl(struct scic_sds_request *sds_request)
6f231dda 97{
f1f52e75
DW		 98 struct isci_request *isci_request = sci_req_to_ireq(sds_request);
99 struct isci_host *isci_host = isci_request->isci_host;
100 struct sas_task *task = isci_request_access_task(isci_request);
101 struct scatterlist *sg = NULL;
102 dma_addr_t dma_addr;
103 u32 sg_idx = 0;
104 struct scu_sgl_element_pair *scu_sg = NULL;
105 struct scu_sgl_element_pair *prev_sg = NULL;
106
107 if (task->num_scatter > 0) {
108 sg = task->scatter;
109
110 while (sg) {
111 scu_sg = scic_sds_request_get_sgl_element_pair(
112 sds_request,
113 sg_idx);
114
115 SCU_SGL_COPY(scu_sg->A, sg);
116
117 sg = sg_next(sg);
118
119 if (sg) {
120 SCU_SGL_COPY(scu_sg->B, sg);
121 sg = sg_next(sg);
122 } else
123 SCU_SGL_ZERO(scu_sg->B);
124
125 if (prev_sg) {
126 dma_addr =
127 scic_io_request_get_dma_addr(
128 sds_request,
129 scu_sg);
130
131 prev_sg->next_pair_upper =
132 upper_32_bits(dma_addr);
133 prev_sg->next_pair_lower =
134 lower_32_bits(dma_addr);
135 }
136
137 prev_sg = scu_sg;
138 sg_idx++;
139 }
140 } else { /* handle when no sg */
141 scu_sg = scic_sds_request_get_sgl_element_pair(sds_request,
142 sg_idx);
6f231dda 143
f1f52e75
DW		 144 dma_addr = dma_map_single(&isci_host->pdev->dev,
145 task->scatter,
146 task->total_xfer_len,
147 task->data_dir);
6f231dda 148
f1f52e75 149 isci_request->zero_scatter_daddr = dma_addr;
6f231dda 150
f1f52e75
DW		 151 scu_sg->A.length = task->total_xfer_len;
152 scu_sg->A.address_upper = upper_32_bits(dma_addr);
153 scu_sg->A.address_lower = lower_32_bits(dma_addr);
154 }
6f231dda 155
f1f52e75
DW		 156 if (scu_sg) {
157 scu_sg->next_pair_upper = 0;
158 scu_sg->next_pair_lower = 0;
6f231dda 159 }
f1f52e75 160}
6f231dda 161
f1f52e75 162static void scic_sds_io_request_build_ssp_command_iu(struct scic_sds_request *sci_req)
6f231dda 163{
f1f52e75
DW		 164 struct ssp_cmd_iu *cmd_iu;
165 struct isci_request *ireq = sci_req_to_ireq(sci_req);
2ec53eb4 166 struct sas_task *task = isci_request_access_task(ireq);
6f231dda 167
f1f52e75 168 cmd_iu = &sci_req->ssp.cmd;
6f231dda 169
f1f52e75
DW		 170 memcpy(cmd_iu->LUN, task->ssp_task.LUN, 8);
171 cmd_iu->add_cdb_len = 0;
172 cmd_iu->_r_a = 0;
173 cmd_iu->_r_b = 0;
174 cmd_iu->en_fburst = 0; /* unsupported */
175 cmd_iu->task_prio = task->ssp_task.task_prio;
176 cmd_iu->task_attr = task->ssp_task.task_attr;
177 cmd_iu->_r_c = 0;
6f231dda 178
f1f52e75
DW		 179 sci_swab32_cpy(&cmd_iu->cdb, task->ssp_task.cdb,
180 sizeof(task->ssp_task.cdb) / sizeof(u32));
181}
6f231dda 182
f1f52e75
DW		 183static void scic_sds_task_request_build_ssp_task_iu(struct scic_sds_request *sci_req)
184{
185 struct ssp_task_iu *task_iu;
186 struct isci_request *ireq = sci_req_to_ireq(sci_req);
187 struct sas_task *task = isci_request_access_task(ireq);
188 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
6f231dda 189
f1f52e75
DW		 190 task_iu = &sci_req->ssp.tmf;
191
192 memset(task_iu, 0, sizeof(struct ssp_task_iu));
193
194 memcpy(task_iu->LUN, task->ssp_task.LUN, 8);
195
196 task_iu->task_func = isci_tmf->tmf_code;
197 task_iu->task_tag =
198 (ireq->ttype == tmf_task) ?
199 isci_tmf->io_tag :
200 SCI_CONTROLLER_INVALID_IO_TAG;
6f231dda
DW		 201}
202
203/**
f1f52e75
DW		 204 * This method is will fill in the SCU Task Context for any type of SSP request.
205 * @sci_req:
206 * @task_context:
6f231dda 207 *
6f231dda 208 */
f1f52e75
DW		 209static void scu_ssp_reqeust_construct_task_context(
210 struct scic_sds_request *sds_request,
211 struct scu_task_context *task_context)
6f231dda 212{
f1f52e75 213 dma_addr_t dma_addr;
f1f52e75
DW		 214 struct scic_sds_remote_device *target_device;
215 struct scic_sds_port *target_port;
216
f1f52e75
DW		 217 target_device = scic_sds_request_get_device(sds_request);
218 target_port = scic_sds_request_get_port(sds_request);
219
220 /* Fill in the TC with the its required data */
221 task_context->abort = 0;
222 task_context->priority = 0;
223 task_context->initiator_request = 1;
224 task_context->connection_rate = target_device->connection_rate;
225 task_context->protocol_engine_index =
226 scic_sds_controller_get_protocol_engine_group(controller);
227 task_context->logical_port_index =
228 scic_sds_port_get_index(target_port);
229 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SSP;
230 task_context->valid = SCU_TASK_CONTEXT_VALID;
231 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
232
233 task_context->remote_node_index =
234 scic_sds_remote_device_get_index(sds_request->target_device);
235 task_context->command_code = 0;
236
237 task_context->link_layer_control = 0;
238 task_context->do_not_dma_ssp_good_response = 1;
239 task_context->strict_ordering = 0;
240 task_context->control_frame = 0;
241 task_context->timeout_enable = 0;
242 task_context->block_guard_enable = 0;
243
244 task_context->address_modifier = 0;
245
246 /* task_context->type.ssp.tag = sci_req->io_tag; */
247 task_context->task_phase = 0x01;
248
249 if (sds_request->was_tag_assigned_by_user) {
250 /*
251 * Build the task context now since we have already read
252 * the data
253 */
254 sds_request->post_context =
255 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
256 (scic_sds_controller_get_protocol_engine_group(
257 controller) <<
258 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
259 (scic_sds_port_get_index(target_port) <<
260 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
261 scic_sds_io_tag_get_index(sds_request->io_tag));
262 } else {
263 /*
264 * Build the task context now since we have already read
265 * the data
266 *
267 * I/O tag index is not assigned because we have to wait
268 * until we get a TCi
269 */
270 sds_request->post_context =
271 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
272 (scic_sds_controller_get_protocol_engine_group(
273 owning_controller) <<
274 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
275 (scic_sds_port_get_index(target_port) <<
276 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT));
277 }
6f231dda 278
f1f52e75
DW		 279 /*
280 * Copy the physical address for the command buffer to the
281 * SCU Task Context
282 */
283 dma_addr = scic_io_request_get_dma_addr(sds_request,
284 &sds_request->ssp.cmd);
6f231dda 285
f1f52e75
DW		 286 task_context->command_iu_upper = upper_32_bits(dma_addr);
287 task_context->command_iu_lower = lower_32_bits(dma_addr);
288
289 /*
290 * Copy the physical address for the response buffer to the
291 * SCU Task Context
6f231dda 292 */
f1f52e75
DW		 293 dma_addr = scic_io_request_get_dma_addr(sds_request,
294 &sds_request->ssp.rsp);
6f231dda 295
f1f52e75
DW		 296 task_context->response_iu_upper = upper_32_bits(dma_addr);
297 task_context->response_iu_lower = lower_32_bits(dma_addr);
298}
6f231dda 299
f1f52e75
DW		 300/**
301 * This method is will fill in the SCU Task Context for a SSP IO request.
302 * @sci_req:
303 *
304 */
305static void scu_ssp_io_request_construct_task_context(
306 struct scic_sds_request *sci_req,
307 enum dma_data_direction dir,
308 u32 len)
309{
310 struct scu_task_context *task_context;
6f231dda 311
f1f52e75 312 task_context = scic_sds_request_get_task_context(sci_req);
6f231dda 313
f1f52e75 314 scu_ssp_reqeust_construct_task_context(sci_req, task_context);
6f231dda 315
f1f52e75
DW		 316 task_context->ssp_command_iu_length =
317 sizeof(struct ssp_cmd_iu) / sizeof(u32);
318 task_context->type.ssp.frame_type = SSP_COMMAND;
319
320 switch (dir) {
321 case DMA_FROM_DEVICE:
322 case DMA_NONE:
323 default:
324 task_context->task_type = SCU_TASK_TYPE_IOREAD;
a1a113b0 325 break;
f1f52e75
DW		 326 case DMA_TO_DEVICE:
327 task_context->task_type = SCU_TASK_TYPE_IOWRITE;
a1a113b0 328 break;
6f231dda
DW		 329 }
330
f1f52e75
DW		 331 task_context->transfer_length_bytes = len;
332
333 if (task_context->transfer_length_bytes > 0)
334 scic_sds_request_build_sgl(sci_req);
6f231dda
DW		 335}
336
6f231dda 337/**
f1f52e75
DW		 338 * This method will fill in the SCU Task Context for a SSP Task request. The
339 * following important settings are utilized: -# priority ==
340 * SCU_TASK_PRIORITY_HIGH. This ensures that the task request is issued
341 * ahead of other task destined for the same Remote Node. -# task_type ==
342 * SCU_TASK_TYPE_IOREAD. This simply indicates that a normal request type
343 * (i.e. non-raw frame) is being utilized to perform task management. -#
344 * control_frame == 1. This ensures that the proper endianess is set so
345 * that the bytes are transmitted in the right order for a task frame.
346 * @sci_req: This parameter specifies the task request object being
347 * constructed.
6f231dda 348 *
6f231dda 349 */
f1f52e75
DW		 350static void scu_ssp_task_request_construct_task_context(
351 struct scic_sds_request *sci_req)
6f231dda 352{
f1f52e75 353 struct scu_task_context *task_context;
6f231dda 354
f1f52e75 355 task_context = scic_sds_request_get_task_context(sci_req);
6f231dda 356
f1f52e75 357 scu_ssp_reqeust_construct_task_context(sci_req, task_context);
6f231dda 358
f1f52e75
DW		 359 task_context->control_frame = 1;
360 task_context->priority = SCU_TASK_PRIORITY_HIGH;
361 task_context->task_type = SCU_TASK_TYPE_RAW_FRAME;
362 task_context->transfer_length_bytes = 0;
363 task_context->type.ssp.frame_type = SSP_TASK;
364 task_context->ssp_command_iu_length =
365 sizeof(struct ssp_task_iu) / sizeof(u32);
6f231dda
DW		 366}
367
5dec6f4e
DW		 368/**
369 * This method is will fill in the SCU Task Context for any type of SATA
370 * request. This is called from the various SATA constructors.
371 * @sci_req: The general IO request object which is to be used in
372 * constructing the SCU task context.
373 * @task_context: The buffer pointer for the SCU task context which is being
374 * constructed.
375 *
376 * The general io request construction is complete. The buffer assignment for
377 * the command buffer is complete. none Revisit task context construction to
378 * determine what is common for SSP/SMP/STP task context structures.
379 */
380static void scu_sata_reqeust_construct_task_context(
381 struct scic_sds_request *sci_req,
382 struct scu_task_context *task_context)
383{
384 dma_addr_t dma_addr;
5dec6f4e
DW		 385 struct scic_sds_remote_device *target_device;
386 struct scic_sds_port *target_port;
387
5dec6f4e
DW		 388 target_device = scic_sds_request_get_device(sci_req);
389 target_port = scic_sds_request_get_port(sci_req);
390
391 /* Fill in the TC with the its required data */
392 task_context->abort = 0;
393 task_context->priority = SCU_TASK_PRIORITY_NORMAL;
394 task_context->initiator_request = 1;
395 task_context->connection_rate = target_device->connection_rate;
396 task_context->protocol_engine_index =
397 scic_sds_controller_get_protocol_engine_group(controller);
398 task_context->logical_port_index =
399 scic_sds_port_get_index(target_port);
400 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_STP;
401 task_context->valid = SCU_TASK_CONTEXT_VALID;
402 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
403
404 task_context->remote_node_index =
405 scic_sds_remote_device_get_index(sci_req->target_device);
406 task_context->command_code = 0;
407
408 task_context->link_layer_control = 0;
409 task_context->do_not_dma_ssp_good_response = 1;
410 task_context->strict_ordering = 0;
411 task_context->control_frame = 0;
412 task_context->timeout_enable = 0;
413 task_context->block_guard_enable = 0;
414
415 task_context->address_modifier = 0;
416 task_context->task_phase = 0x01;
417
418 task_context->ssp_command_iu_length =
419 (sizeof(struct host_to_dev_fis) - sizeof(u32)) / sizeof(u32);
420
421 /* Set the first word of the H2D REG FIS */
422 task_context->type.words[0] = *(u32 *)&sci_req->stp.cmd;
423
424 if (sci_req->was_tag_assigned_by_user) {
425 /*
426 * Build the task context now since we have already read
427 * the data
428 */
429 sci_req->post_context =
430 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
431 (scic_sds_controller_get_protocol_engine_group(
432 controller) <<
433 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
434 (scic_sds_port_get_index(target_port) <<
435 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
436 scic_sds_io_tag_get_index(sci_req->io_tag));
437 } else {
438 /*
439 * Build the task context now since we have already read
440 * the data.
441 * I/O tag index is not assigned because we have to wait
442 * until we get a TCi.
443 */
444 sci_req->post_context =
445 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
446 (scic_sds_controller_get_protocol_engine_group(
447 controller) <<
448 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
449 (scic_sds_port_get_index(target_port) <<
450 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT));
451 }
452
453 /*
454 * Copy the physical address for the command buffer to the SCU Task
455 * Context. We must offset the command buffer by 4 bytes because the
456 * first 4 bytes are transfered in the body of the TC.
457 */
458 dma_addr = scic_io_request_get_dma_addr(sci_req,
459 ((char *) &sci_req->stp.cmd) +
460 sizeof(u32));
461
462 task_context->command_iu_upper = upper_32_bits(dma_addr);
463 task_context->command_iu_lower = lower_32_bits(dma_addr);
464
465 /* SATA Requests do not have a response buffer */
466 task_context->response_iu_upper = 0;
467 task_context->response_iu_lower = 0;
468}
469
470
6f231dda 471
f1f52e75 472/**
5dec6f4e
DW		 473 * scu_stp_raw_request_construct_task_context -
474 * @sci_req: This parameter specifies the STP request object for which to
475 * construct a RAW command frame task context.
476 * @task_context: This parameter specifies the SCU specific task context buffer
477 * to construct.
f1f52e75 478 *
5dec6f4e
DW		 479 * This method performs the operations common to all SATA/STP requests
480 * utilizing the raw frame method. none
f1f52e75 481 */
5dec6f4e
DW		 482static void scu_stp_raw_request_construct_task_context(struct scic_sds_stp_request *stp_req,
483 struct scu_task_context *task_context)
484{
485 struct scic_sds_request *sci_req = to_sci_req(stp_req);
486
487 scu_sata_reqeust_construct_task_context(sci_req, task_context);
488
489 task_context->control_frame = 0;
490 task_context->priority = SCU_TASK_PRIORITY_NORMAL;
491 task_context->task_type = SCU_TASK_TYPE_SATA_RAW_FRAME;
492 task_context->type.stp.fis_type = FIS_REGH2D;
493 task_context->transfer_length_bytes = sizeof(struct host_to_dev_fis) - sizeof(u32);
494}
495
496static enum sci_status
497scic_sds_stp_pio_request_construct(struct scic_sds_request *sci_req,
498 bool copy_rx_frame)
499{
500 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
501 struct scic_sds_stp_pio_request *pio = &stp_req->type.pio;
502
503 scu_stp_raw_request_construct_task_context(stp_req,
504 sci_req->task_context_buffer);
505
506 pio->current_transfer_bytes = 0;
507 pio->ending_error = 0;
508 pio->ending_status = 0;
509
510 pio->request_current.sgl_offset = 0;
511 pio->request_current.sgl_set = SCU_SGL_ELEMENT_PAIR_A;
512
513 if (copy_rx_frame) {
514 scic_sds_request_build_sgl(sci_req);
515 /* Since the IO request copy of the TC contains the same data as
516 * the actual TC this pointer is vaild for either.
517 */
518 pio->request_current.sgl_pair = &sci_req->task_context_buffer->sgl_pair_ab;
519 } else {
520 /* The user does not want the data copied to the SGL buffer location */
521 pio->request_current.sgl_pair = NULL;
522 }
6f231dda 523
5dec6f4e
DW		 524 return SCI_SUCCESS;
525}
6f231dda
DW		 526
527/**
6f231dda 528 *
5dec6f4e
DW		 529 * @sci_req: This parameter specifies the request to be constructed as an
530 * optimized request.
531 * @optimized_task_type: This parameter specifies whether the request is to be
532 * an UDMA request or a NCQ request. - A value of 0 indicates UDMA. - A
533 * value of 1 indicates NCQ.
534 *
535 * This method will perform request construction common to all types of STP
536 * requests that are optimized by the silicon (i.e. UDMA, NCQ). This method
537 * returns an indication as to whether the construction was successful.
6f231dda 538 */
5dec6f4e
DW		 539static void scic_sds_stp_optimized_request_construct(struct scic_sds_request *sci_req,
540 u8 optimized_task_type,
541 u32 len,
542 enum dma_data_direction dir)
543{
544 struct scu_task_context *task_context = sci_req->task_context_buffer;
545
546 /* Build the STP task context structure */
547 scu_sata_reqeust_construct_task_context(sci_req, task_context);
548
549 /* Copy over the SGL elements */
550 scic_sds_request_build_sgl(sci_req);
551
552 /* Copy over the number of bytes to be transfered */
553 task_context->transfer_length_bytes = len;
554
555 if (dir == DMA_TO_DEVICE) {
556 /*
557 * The difference between the DMA IN and DMA OUT request task type
558 * values are consistent with the difference between FPDMA READ
559 * and FPDMA WRITE values. Add the supplied task type parameter
560 * to this difference to set the task type properly for this
561 * DATA OUT (WRITE) case. */
562 task_context->task_type = optimized_task_type + (SCU_TASK_TYPE_DMA_OUT
563 - SCU_TASK_TYPE_DMA_IN);
564 } else {
565 /*
566 * For the DATA IN (READ) case, simply save the supplied
567 * optimized task type. */
568 task_context->task_type = optimized_task_type;
569 }
570}
571
572
573
f1f52e75
DW		 574static enum sci_status
575scic_io_request_construct_sata(struct scic_sds_request *sci_req,
576 u32 len,
577 enum dma_data_direction dir,
578 bool copy)
6f231dda 579{
f1f52e75
DW		 580 enum sci_status status = SCI_SUCCESS;
581 struct isci_request *ireq = sci_req_to_ireq(sci_req);
582 struct sas_task *task = isci_request_access_task(ireq);
6f231dda 583
f1f52e75
DW		 584 /* check for management protocols */
585 if (ireq->ttype == tmf_task) {
586 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
6f231dda 587
f1f52e75 588 if (tmf->tmf_code == isci_tmf_sata_srst_high ||
5dec6f4e
DW		 589 tmf->tmf_code == isci_tmf_sata_srst_low) {
590 scu_stp_raw_request_construct_task_context(&sci_req->stp.req,
591 sci_req->task_context_buffer);
592 return SCI_SUCCESS;
593 } else {
f1f52e75
DW		 594 dev_err(scic_to_dev(sci_req->owning_controller),
595 "%s: Request 0x%p received un-handled SAT "
596 "management protocol 0x%x.\n",
597 __func__, sci_req, tmf->tmf_code);
598
599 return SCI_FAILURE;
600 }
6f231dda 601 }
6f231dda 602
f1f52e75
DW		 603 if (!sas_protocol_ata(task->task_proto)) {
604 dev_err(scic_to_dev(sci_req->owning_controller),
605 "%s: Non-ATA protocol in SATA path: 0x%x\n",
606 __func__,
607 task->task_proto);
608 return SCI_FAILURE;
609
610 }
611
612 /* non data */
5dec6f4e
DW		 613 if (task->data_dir == DMA_NONE) {
614 scu_stp_raw_request_construct_task_context(&sci_req->stp.req,
615 sci_req->task_context_buffer);
616 return SCI_SUCCESS;
617 }
f1f52e75
DW		 618
619 /* NCQ */
5dec6f4e
DW		 620 if (task->ata_task.use_ncq) {
621 scic_sds_stp_optimized_request_construct(sci_req,
622 SCU_TASK_TYPE_FPDMAQ_READ,
623 len, dir);
624 return SCI_SUCCESS;
625 }
f1f52e75
DW		 626
627 /* DMA */
5dec6f4e
DW		 628 if (task->ata_task.dma_xfer) {
629 scic_sds_stp_optimized_request_construct(sci_req,
630 SCU_TASK_TYPE_DMA_IN,
631 len, dir);
632 return SCI_SUCCESS;
633 } else /* PIO */
f1f52e75
DW		 634 return scic_sds_stp_pio_request_construct(sci_req, copy);
635
636 return status;
637}
638
639static enum sci_status scic_io_request_construct_basic_ssp(struct scic_sds_request *sci_req)
6f231dda 640{
f1f52e75
DW		 641 struct isci_request *ireq = sci_req_to_ireq(sci_req);
642 struct sas_task *task = isci_request_access_task(ireq);
6f231dda 643
f1f52e75 644 sci_req->protocol = SCIC_SSP_PROTOCOL;
6f231dda 645
f1f52e75
DW		 646 scu_ssp_io_request_construct_task_context(sci_req,
647 task->data_dir,
648 task->total_xfer_len);
6f231dda 649
f1f52e75 650 scic_sds_io_request_build_ssp_command_iu(sci_req);
6f231dda 651
e301370a 652 sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
ce4f75de 653
f1f52e75
DW		 654 return SCI_SUCCESS;
655}
6f231dda 656
f1f52e75
DW		 657enum sci_status scic_task_request_construct_ssp(
658 struct scic_sds_request *sci_req)
659{
660 /* Construct the SSP Task SCU Task Context */
661 scu_ssp_task_request_construct_task_context(sci_req);
6f231dda 662
f1f52e75
DW		 663 /* Fill in the SSP Task IU */
664 scic_sds_task_request_build_ssp_task_iu(sci_req);
c4b9e24c 665
e301370a 666 sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
67ea838d 667
f1f52e75
DW		 668 return SCI_SUCCESS;
669}
67ea838d 670
f1f52e75
DW		 671static enum sci_status scic_io_request_construct_basic_sata(struct scic_sds_request *sci_req)
672{
673 enum sci_status status;
f1f52e75
DW		 674 bool copy = false;
675 struct isci_request *isci_request = sci_req_to_ireq(sci_req);
676 struct sas_task *task = isci_request_access_task(isci_request);
6f231dda 677
f1f52e75 678 sci_req->protocol = SCIC_STP_PROTOCOL;
6f231dda 679
f1f52e75
DW		 680 copy = (task->data_dir == DMA_NONE) ? false : true;
681
682 status = scic_io_request_construct_sata(sci_req,
683 task->total_xfer_len,
684 task->data_dir,
685 copy);
686
687 if (status == SCI_SUCCESS)
e301370a 688 sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
f1f52e75
DW		 689
690 return status;
6f231dda
DW		 691}
692
f1f52e75
DW		 693enum sci_status scic_task_request_construct_sata(struct scic_sds_request *sci_req)
694{
695 enum sci_status status = SCI_SUCCESS;
696 struct isci_request *ireq = sci_req_to_ireq(sci_req);
697
698 /* check for management protocols */
699 if (ireq->ttype == tmf_task) {
700 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
701
702 if (tmf->tmf_code == isci_tmf_sata_srst_high ||
703 tmf->tmf_code == isci_tmf_sata_srst_low) {
5dec6f4e
DW		 704 scu_stp_raw_request_construct_task_context(&sci_req->stp.req,
705 sci_req->task_context_buffer);
f1f52e75
DW		 706 } else {
707 dev_err(scic_to_dev(sci_req->owning_controller),
708 "%s: Request 0x%p received un-handled SAT "
709 "Protocol 0x%x.\n",
710 __func__, sci_req, tmf->tmf_code);
711
712 return SCI_FAILURE;
713 }
714 }
715
5dec6f4e
DW		 716 if (status != SCI_SUCCESS)
717 return status;
e301370a 718 sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
f1f52e75
DW		 719
720 return status;
721}
722
6f231dda 723/**
f1f52e75
DW		 724 * sci_req_tx_bytes - bytes transferred when reply underruns request
725 * @sci_req: request that was terminated early
6f231dda 726 */
f1f52e75
DW		 727#define SCU_TASK_CONTEXT_SRAM 0x200000
728static u32 sci_req_tx_bytes(struct scic_sds_request *sci_req)
6f231dda 729{
f1f52e75
DW		 730 struct scic_sds_controller *scic = sci_req->owning_controller;
731 u32 ret_val = 0;
732
733 if (readl(&scic->smu_registers->address_modifier) == 0) {
734 void __iomem *scu_reg_base = scic->scu_registers;
735
736 /* get the bytes of data from the Address == BAR1 + 20002Ch + (256*TCi) where
737 * BAR1 is the scu_registers
738 * 0x20002C = 0x200000 + 0x2c
739 * = start of task context SRAM + offset of (type.ssp.data_offset)
740 * TCi is the io_tag of struct scic_sds_request
741 */
742 ret_val = readl(scu_reg_base +
743 (SCU_TASK_CONTEXT_SRAM + offsetof(struct scu_task_context, type.ssp.data_offset)) +
744 ((sizeof(struct scu_task_context)) * scic_sds_io_tag_get_index(sci_req->io_tag)));
745 }
746
747 return ret_val;
748}
749
f4636a7b 750enum sci_status scic_sds_request_start(struct scic_sds_request *sci_req)
f1f52e75 751{
f4636a7b
PS		 752 struct scic_sds_controller *scic = sci_req->owning_controller;
753 struct scu_task_context *task_context;
754 enum sci_base_request_states state;
755
756 if (sci_req->device_sequence !=
757 scic_sds_remote_device_get_sequence(sci_req->target_device))
f1f52e75
DW		 758 return SCI_FAILURE;
759
e301370a
EN		 760 state = sci_req->sm.current_state_id;
761 if (state != SCI_REQ_CONSTRUCTED) {
f4636a7b
PS		 762 dev_warn(scic_to_dev(scic),
763 "%s: SCIC IO Request requested to start while in wrong "
764 "state %d\n", __func__, state);
765 return SCI_FAILURE_INVALID_STATE;
766 }
f1f52e75 767
f4636a7b
PS		 768 /* if necessary, allocate a TCi for the io request object and then will,
769 * if necessary, copy the constructed TC data into the actual TC buffer.
770 * If everything is successful the post context field is updated with
771 * the TCi so the controller can post the request to the hardware.
772 */
773 if (sci_req->io_tag == SCI_CONTROLLER_INVALID_IO_TAG)
774 sci_req->io_tag = scic_controller_allocate_io_tag(scic);
f1f52e75 775
f4636a7b
PS		 776 /* Record the IO Tag in the request */
777 if (sci_req->io_tag != SCI_CONTROLLER_INVALID_IO_TAG) {
778 task_context = sci_req->task_context_buffer;
779
780 task_context->task_index = scic_sds_io_tag_get_index(sci_req->io_tag);
781
782 switch (task_context->protocol_type) {
783 case SCU_TASK_CONTEXT_PROTOCOL_SMP:
784 case SCU_TASK_CONTEXT_PROTOCOL_SSP:
785 /* SSP/SMP Frame */
786 task_context->type.ssp.tag = sci_req->io_tag;
787 task_context->type.ssp.target_port_transfer_tag =
788 0xFFFF;
789 break;
790
791 case SCU_TASK_CONTEXT_PROTOCOL_STP:
792 /* STP/SATA Frame
793 * task_context->type.stp.ncq_tag = sci_req->ncq_tag;
794 */
795 break;
796
797 case SCU_TASK_CONTEXT_PROTOCOL_NONE:
798 /* / @todo When do we set no protocol type? */
799 break;
800
801 default:
802 /* This should never happen since we build the IO
803 * requests */
804 break;
805 }
806
807 /*
808 * Check to see if we need to copy the task context buffer
809 * or have been building into the task context buffer */
810 if (sci_req->was_tag_assigned_by_user == false)
811 scic_sds_controller_copy_task_context(scic, sci_req);
812
813 /* Add to the post_context the io tag value */
814 sci_req->post_context |= scic_sds_io_tag_get_index(sci_req->io_tag);
815
816 /* Everything is good go ahead and change state */
e301370a 817 sci_change_state(&sci_req->sm, SCI_REQ_STARTED);
f4636a7b
PS		 818
819 return SCI_SUCCESS;
820 }
821
822 return SCI_FAILURE_INSUFFICIENT_RESOURCES;
f1f52e75
DW		 823}
824
825enum sci_status
f00e6ba4 826scic_sds_io_request_terminate(struct scic_sds_request *sci_req)
f1f52e75 827{
f00e6ba4 828 enum sci_base_request_states state;
f1f52e75 829
e301370a 830 state = sci_req->sm.current_state_id;
f00e6ba4
DW		 831
832 switch (state) {
e301370a 833 case SCI_REQ_CONSTRUCTED:
f00e6ba4
DW		 834 scic_sds_request_set_status(sci_req,
835 SCU_TASK_DONE_TASK_ABORT,
836 SCI_FAILURE_IO_TERMINATED);
837
e301370a 838 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f00e6ba4 839 return SCI_SUCCESS;
e301370a
EN		 840 case SCI_REQ_STARTED:
841 case SCI_REQ_TASK_WAIT_TC_COMP:
842 case SCI_REQ_SMP_WAIT_RESP:
843 case SCI_REQ_SMP_WAIT_TC_COMP:
844 case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
845 case SCI_REQ_STP_UDMA_WAIT_D2H:
846 case SCI_REQ_STP_NON_DATA_WAIT_H2D:
847 case SCI_REQ_STP_NON_DATA_WAIT_D2H:
848 case SCI_REQ_STP_PIO_WAIT_H2D:
849 case SCI_REQ_STP_PIO_WAIT_FRAME:
850 case SCI_REQ_STP_PIO_DATA_IN:
851 case SCI_REQ_STP_PIO_DATA_OUT:
852 case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED:
853 case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG:
854 case SCI_REQ_STP_SOFT_RESET_WAIT_D2H:
855 sci_change_state(&sci_req->sm, SCI_REQ_ABORTING);
f00e6ba4 856 return SCI_SUCCESS;
e301370a
EN		 857 case SCI_REQ_TASK_WAIT_TC_RESP:
858 sci_change_state(&sci_req->sm, SCI_REQ_ABORTING);
859 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f00e6ba4 860 return SCI_SUCCESS;
e301370a
EN		 861 case SCI_REQ_ABORTING:
862 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f00e6ba4 863 return SCI_SUCCESS;
e301370a 864 case SCI_REQ_COMPLETED:
f00e6ba4
DW		 865 default:
866 dev_warn(scic_to_dev(sci_req->owning_controller),
867 "%s: SCIC IO Request requested to abort while in wrong "
868 "state %d\n",
869 __func__,
e301370a 870 sci_req->sm.current_state_id);
f00e6ba4
DW		 871 break;
872 }
6f231dda 873
f1f52e75
DW		 874 return SCI_FAILURE_INVALID_STATE;
875}
6f231dda 876
79e2b6b2 877enum sci_status scic_sds_request_complete(struct scic_sds_request *sci_req)
f1f52e75 878{
79e2b6b2
DW		 879 enum sci_base_request_states state;
880 struct scic_sds_controller *scic = sci_req->owning_controller;
881
e301370a
EN		 882 state = sci_req->sm.current_state_id;
883 if (WARN_ONCE(state != SCI_REQ_COMPLETED,
79e2b6b2
DW		 884 "isci: request completion from wrong state (%d)\n", state))
885 return SCI_FAILURE_INVALID_STATE;
f1f52e75 886
79e2b6b2
DW		 887 if (!sci_req->was_tag_assigned_by_user)
888 scic_controller_free_io_tag(scic, sci_req->io_tag);
f1f52e75 889
79e2b6b2
DW		 890 if (sci_req->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
891 scic_sds_controller_release_frame(scic,
892 sci_req->saved_rx_frame_index);
893
894 /* XXX can we just stop the machine and remove the 'final' state? */
e301370a 895 sci_change_state(&sci_req->sm, SCI_REQ_FINAL);
79e2b6b2
DW		 896 return SCI_SUCCESS;
897}
898
899enum sci_status scic_sds_io_request_event_handler(struct scic_sds_request *sci_req,
900 u32 event_code)
901{
902 enum sci_base_request_states state;
903 struct scic_sds_controller *scic = sci_req->owning_controller;
904
e301370a 905 state = sci_req->sm.current_state_id;
79e2b6b2 906
e301370a 907 if (state != SCI_REQ_STP_PIO_DATA_IN) {
79e2b6b2
DW		 908 dev_warn(scic_to_dev(scic), "%s: (%x) in wrong state %d\n",
909 __func__, event_code, state);
910
911 return SCI_FAILURE_INVALID_STATE;
912 }
913
914 switch (scu_get_event_specifier(event_code)) {
915 case SCU_TASK_DONE_CRC_ERR << SCU_EVENT_SPECIFIC_CODE_SHIFT:
916 /* We are waiting for data and the SCU has R_ERR the data frame.
917 * Go back to waiting for the D2H Register FIS
918 */
e301370a 919 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
79e2b6b2
DW		 920 return SCI_SUCCESS;
921 default:
922 dev_err(scic_to_dev(scic),
923 "%s: pio request unexpected event %#x\n",
924 __func__, event_code);
925
926 /* TODO Should we fail the PIO request when we get an
927 * unexpected event?
928 */
929 return SCI_FAILURE;
930 }
6f231dda
DW		 931}
932
f1f52e75
DW		 933/*
934 * This function copies response data for requests returning response data
935 * instead of sense data.
936 * @sci_req: This parameter specifies the request object for which to copy
937 * the response data.
6f231dda 938 */
f139303d 939static void scic_sds_io_request_copy_response(struct scic_sds_request *sci_req)
6f231dda 940{
f1f52e75
DW		 941 void *resp_buf;
942 u32 len;
943 struct ssp_response_iu *ssp_response;
944 struct isci_request *ireq = sci_req_to_ireq(sci_req);
945 struct isci_tmf *isci_tmf = isci_request_access_tmf(ireq);
6f231dda 946
f1f52e75 947 ssp_response = &sci_req->ssp.rsp;
6f231dda 948
f1f52e75 949 resp_buf = &isci_tmf->resp.resp_iu;
6f231dda 950
f1f52e75
DW		 951 len = min_t(u32,
952 SSP_RESP_IU_MAX_SIZE,
953 be32_to_cpu(ssp_response->response_data_len));
6f231dda 954
f1f52e75
DW		 955 memcpy(resp_buf, ssp_response->resp_data, len);
956}
6f231dda 957
e301370a
EN		 958static enum sci_status
959request_started_state_tc_event(struct scic_sds_request *sci_req,
960 u32 completion_code)
f1f52e75 961{
f1f52e75 962 struct ssp_response_iu *resp_iu;
a7e255a3 963 u8 datapres;
6f231dda 964
a7e255a3
DW		 965 /* TODO: Any SDMA return code of other than 0 is bad decode 0x003C0000
966 * to determine SDMA status
f1f52e75
DW		 967 */
968 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
969 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
970 scic_sds_request_set_status(sci_req,
971 SCU_TASK_DONE_GOOD,
972 SCI_SUCCESS);
6f231dda 973 break;
a7e255a3
DW		 974 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EARLY_RESP): {
975 /* There are times when the SCU hardware will return an early
f1f52e75
DW		 976 * response because the io request specified more data than is
977 * returned by the target device (mode pages, inquiry data,
978 * etc.). We must check the response stats to see if this is
979 * truly a failed request or a good request that just got
980 * completed early.
981 */
982 struct ssp_response_iu *resp = &sci_req->ssp.rsp;
983 ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
984
985 sci_swab32_cpy(&sci_req->ssp.rsp,
986 &sci_req->ssp.rsp,
987 word_cnt);
988
989 if (resp->status == 0) {
a7e255a3
DW		 990 scic_sds_request_set_status(sci_req,
991 SCU_TASK_DONE_GOOD,
992 SCI_SUCCESS_IO_DONE_EARLY);
f1f52e75 993 } else {
a7e255a3
DW		 994 scic_sds_request_set_status(sci_req,
995 SCU_TASK_DONE_CHECK_RESPONSE,
996 SCI_FAILURE_IO_RESPONSE_VALID);
f1f52e75 997 }
a7e255a3 998 break;
f1f52e75 999 }
a7e255a3 1000 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE): {
f1f52e75 1001 ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
6f231dda 1002
f1f52e75
DW		 1003 sci_swab32_cpy(&sci_req->ssp.rsp,
1004 &sci_req->ssp.rsp,
1005 word_cnt);
6f231dda 1006
f1f52e75
DW		 1007 scic_sds_request_set_status(sci_req,
1008 SCU_TASK_DONE_CHECK_RESPONSE,
1009 SCI_FAILURE_IO_RESPONSE_VALID);
6f231dda 1010 break;
f1f52e75 1011 }
6f231dda 1012
f1f52e75 1013 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RESP_LEN_ERR):
a7e255a3 1014 /* TODO With TASK_DONE_RESP_LEN_ERR is the response frame
f1f52e75
DW		 1015 * guaranteed to be received before this completion status is
1016 * posted?
1017 */
1018 resp_iu = &sci_req->ssp.rsp;
1019 datapres = resp_iu->datapres;
1020
a7e255a3
DW		 1021 if (datapres == 1 || datapres == 2) {
1022 scic_sds_request_set_status(sci_req,
1023 SCU_TASK_DONE_CHECK_RESPONSE,
1024 SCI_FAILURE_IO_RESPONSE_VALID);
f1f52e75 1025 } else
a7e255a3
DW		 1026 scic_sds_request_set_status(sci_req,
1027 SCU_TASK_DONE_GOOD,
1028 SCI_SUCCESS);
6f231dda 1029 break;
f1f52e75
DW		 1030 /* only stp device gets suspended. */
1031 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
1032 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_PERR):
1033 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_ERR):
1034 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_DATA_LEN_ERR):
1035 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_ABORT_ERR):
1036 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_WD_LEN):
1037 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
1038 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_RESP):
1039 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
1040 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
1041 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
1042 if (sci_req->protocol == SCIC_STP_PROTOCOL) {
a7e255a3 1043 scic_sds_request_set_status(sci_req,
f1f52e75
DW		 1044 SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1045 SCU_COMPLETION_TL_STATUS_SHIFT,
1046 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED);
1047 } else {
a7e255a3 1048 scic_sds_request_set_status(sci_req,
f1f52e75
DW		 1049 SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1050 SCU_COMPLETION_TL_STATUS_SHIFT,
1051 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
1052 }
6f231dda
DW		 1053 break;
1054
f1f52e75
DW		 1055 /* both stp/ssp device gets suspended */
1056 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LF_ERR):
1057 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_WRONG_DESTINATION):
1058 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1):
1059 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2):
1060 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3):
1061 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_BAD_DESTINATION):
1062 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_ZONE_VIOLATION):
1063 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY):
1064 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED):
1065 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED):
a7e255a3
DW		 1066 scic_sds_request_set_status(sci_req,
1067 SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1068 SCU_COMPLETION_TL_STATUS_SHIFT,
1069 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED);
6f231dda
DW		 1070 break;
1071
f1f52e75
DW		 1072 /* neither ssp nor stp gets suspended. */
1073 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_NAK_CMD_ERR):
1074 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_XR):
1075 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_XR_IU_LEN_ERR):
1076 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDMA_ERR):
1077 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OFFSET_ERR):
1078 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_EXCESS_DATA):
1079 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
1080 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
1081 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
1082 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
1083 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_DATA):
1084 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_OPEN_FAIL):
1085 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_VIIT_ENTRY_NV):
1086 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_IIT_ENTRY_NV):
1087 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND):
6f231dda 1088 default:
f1f52e75
DW		 1089 scic_sds_request_set_status(
1090 sci_req,
1091 SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
1092 SCU_COMPLETION_TL_STATUS_SHIFT,
1093 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
6f231dda
DW		 1094 break;
1095 }
f1f52e75
DW		 1096
1097 /*
1098 * TODO: This is probably wrong for ACK/NAK timeout conditions
1099 */
1100
1101 /* In all cases we will treat this as the completion of the IO req. */
e301370a 1102 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f1f52e75 1103 return SCI_SUCCESS;
6f231dda
DW		 1104}
1105
e301370a
EN		 1106static enum sci_status
1107request_aborting_state_tc_event(struct scic_sds_request *sci_req,
1108 u32 completion_code)
f1f52e75
DW		 1109{
1110 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1111 case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
1112 case (SCU_TASK_DONE_TASK_ABORT << SCU_COMPLETION_TL_STATUS_SHIFT):
a7e255a3
DW		 1113 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_TASK_ABORT,
1114 SCI_FAILURE_IO_TERMINATED);
f1f52e75 1115
e301370a 1116 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f1f52e75
DW		 1117 break;
1118
1119 default:
a7e255a3
DW		 1120 /* Unless we get some strange error wait for the task abort to complete
1121 * TODO: Should there be a state change for this completion?
1122 */
6f231dda
DW		 1123 break;
1124 }
f1f52e75
DW		 1125
1126 return SCI_SUCCESS;
1127}
1128
a7e255a3
DW		 1129static enum sci_status ssp_task_request_await_tc_event(struct scic_sds_request *sci_req,
1130 u32 completion_code)
f139303d
DW		 1131{
1132 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1133 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1134 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
1135 SCI_SUCCESS);
1136
e301370a 1137 sci_change_state(&sci_req->sm, SCI_REQ_TASK_WAIT_TC_RESP);
f139303d 1138 break;
f139303d 1139 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
a7e255a3
DW		 1140 /* Currently, the decision is to simply allow the task request
1141 * to timeout if the task IU wasn't received successfully.
1142 * There is a potential for receiving multiple task responses if
1143 * we decide to send the task IU again.
1144 */
f139303d
DW		 1145 dev_warn(scic_to_dev(sci_req->owning_controller),
1146 "%s: TaskRequest:0x%p CompletionCode:%x - "
a7e255a3 1147 "ACK/NAK timeout\n", __func__, sci_req,
f139303d
DW		 1148 completion_code);
1149
e301370a 1150 sci_change_state(&sci_req->sm, SCI_REQ_TASK_WAIT_TC_RESP);
f139303d 1151 break;
f139303d 1152 default:
e301370a
EN		 1153 /*
1154 * All other completion status cause the IO to be complete.
1155 * If a NAK was received, then it is up to the user to retry
1156 * the request.
a7e255a3
DW		 1157 */
1158 scic_sds_request_set_status(sci_req,
f139303d 1159 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
a7e255a3 1160 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
f139303d 1161
e301370a 1162 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
f139303d
DW		 1163 break;
1164 }
1165
1166 return SCI_SUCCESS;
1167}
1168
e301370a
EN		 1169static enum sci_status
1170smp_request_await_response_tc_event(struct scic_sds_request *sci_req,
1171 u32 completion_code)
c72086e3
DW		 1172{
1173 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1174 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
a7e255a3
DW		 1175 /* In the AWAIT RESPONSE state, any TC completion is
1176 * unexpected. but if the TC has success status, we
1177 * complete the IO anyway.
1178 */
5dec6f4e
DW		 1179 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
1180 SCI_SUCCESS);
c72086e3 1181
e301370a 1182 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
c72086e3
DW		 1183 break;
1184
1185 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
1186 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_UFI_ERR):
1187 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_FRM_TYPE_ERR):
1188 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_LL_RX_ERR):
a7e255a3
DW		 1189 /* These status has been seen in a specific LSI
1190 * expander, which sometimes is not able to send smp
1191 * response within 2 ms. This causes our hardware break
1192 * the connection and set TC completion with one of
1193 * these SMP_XXX_XX_ERR status. For these type of error,
1194 * we ask scic user to retry the request.
1195 */
5dec6f4e
DW		 1196 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_SMP_RESP_TO_ERR,
1197 SCI_FAILURE_RETRY_REQUIRED);
c72086e3 1198
e301370a 1199 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
c72086e3
DW		 1200 break;
1201
1202 default:
a7e255a3
DW		 1203 /* All other completion status cause the IO to be complete. If a NAK
1204 * was received, then it is up to the user to retry the request
1205 */
1206 scic_sds_request_set_status(sci_req,
1207 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1208 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
c72086e3 1209
e301370a 1210 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
c72086e3
DW		 1211 break;
1212 }
1213
1214 return SCI_SUCCESS;
1215}
1216
e301370a
EN		 1217static enum sci_status
1218smp_request_await_tc_event(struct scic_sds_request *sci_req,
1219 u32 completion_code)
5dec6f4e
DW		 1220{
1221 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1222 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1223 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
1224 SCI_SUCCESS);
1225
e301370a 1226 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e 1227 break;
5dec6f4e 1228 default:
a7e255a3
DW		 1229 /* All other completion status cause the IO to be
1230 * complete. If a NAK was received, then it is up to
1231 * the user to retry the request.
1232 */
1233 scic_sds_request_set_status(sci_req,
1234 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1235 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
5dec6f4e 1236
e301370a 1237 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e
DW		 1238 break;
1239 }
1240
1241 return SCI_SUCCESS;
1242}
1243
1244void scic_stp_io_request_set_ncq_tag(struct scic_sds_request *req,
1245 u16 ncq_tag)
1246{
1247 /**
1248 * @note This could be made to return an error to the user if the user
1249 * attempts to set the NCQ tag in the wrong state.
1250 */
1251 req->task_context_buffer->type.stp.ncq_tag = ncq_tag;
1252}
1253
1254/**
1255 *
1256 * @sci_req:
1257 *
1258 * Get the next SGL element from the request. - Check on which SGL element pair
1259 * we are working - if working on SLG pair element A - advance to element B -
1260 * else - check to see if there are more SGL element pairs for this IO request
1261 * - if there are more SGL element pairs - advance to the next pair and return
1262 * element A struct scu_sgl_element*
1263 */
1264static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic_sds_stp_request *stp_req)
1265{
1266 struct scu_sgl_element *current_sgl;
1267 struct scic_sds_request *sci_req = to_sci_req(stp_req);
1268 struct scic_sds_request_pio_sgl *pio_sgl = &stp_req->type.pio.request_current;
1269
1270 if (pio_sgl->sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
1271 if (pio_sgl->sgl_pair->B.address_lower == 0 &&
1272 pio_sgl->sgl_pair->B.address_upper == 0) {
1273 current_sgl = NULL;
1274 } else {
1275 pio_sgl->sgl_set = SCU_SGL_ELEMENT_PAIR_B;
1276 current_sgl = &pio_sgl->sgl_pair->B;
1277 }
1278 } else {
1279 if (pio_sgl->sgl_pair->next_pair_lower == 0 &&
1280 pio_sgl->sgl_pair->next_pair_upper == 0) {
1281 current_sgl = NULL;
1282 } else {
1283 u64 phys_addr;
1284
1285 phys_addr = pio_sgl->sgl_pair->next_pair_upper;
1286 phys_addr <<= 32;
1287 phys_addr |= pio_sgl->sgl_pair->next_pair_lower;
1288
1289 pio_sgl->sgl_pair = scic_request_get_virt_addr(sci_req, phys_addr);
1290 pio_sgl->sgl_set = SCU_SGL_ELEMENT_PAIR_A;
1291 current_sgl = &pio_sgl->sgl_pair->A;
1292 }
1293 }
1294
1295 return current_sgl;
1296}
1297
e301370a
EN		 1298static enum sci_status
1299stp_request_non_data_await_h2d_tc_event(struct scic_sds_request *sci_req,
1300 u32 completion_code)
5dec6f4e
DW		 1301{
1302 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1303 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
a7e255a3
DW		 1304 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
1305 SCI_SUCCESS);
5dec6f4e 1306
e301370a 1307 sci_change_state(&sci_req->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
5dec6f4e
DW		 1308 break;
1309
1310 default:
a7e255a3
DW		 1311 /* All other completion status cause the IO to be
1312 * complete. If a NAK was received, then it is up to
1313 * the user to retry the request.
1314 */
1315 scic_sds_request_set_status(sci_req,
1316 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1317 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
5dec6f4e 1318
e301370a 1319 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e
DW		 1320 break;
1321 }
1322
1323 return SCI_SUCCESS;
1324}
1325
5dec6f4e
DW		 1326#define SCU_MAX_FRAME_BUFFER_SIZE 0x400 /* 1K is the maximum SCU frame data payload */
1327
1328/* transmit DATA_FIS from (current sgl + offset) for input
1329 * parameter length. current sgl and offset is alreay stored in the IO request
1330 */
1331static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
1332 struct scic_sds_request *sci_req,
1333 u32 length)
1334{
1335 struct scic_sds_controller *scic = sci_req->owning_controller;
1336 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1337 struct scu_task_context *task_context;
1338 struct scu_sgl_element *current_sgl;
1339
1340 /* Recycle the TC and reconstruct it for sending out DATA FIS containing
1341 * for the data from current_sgl+offset for the input length
1342 */
1343 task_context = scic_sds_controller_get_task_context_buffer(scic,
1344 sci_req->io_tag);
1345
1346 if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
1347 current_sgl = &stp_req->type.pio.request_current.sgl_pair->A;
1348 else
1349 current_sgl = &stp_req->type.pio.request_current.sgl_pair->B;
1350
1351 /* update the TC */
1352 task_context->command_iu_upper = current_sgl->address_upper;
1353 task_context->command_iu_lower = current_sgl->address_lower;
1354 task_context->transfer_length_bytes = length;
1355 task_context->type.stp.fis_type = FIS_DATA;
1356
1357 /* send the new TC out. */
1358 return scic_controller_continue_io(sci_req);
1359}
1360
1361static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(struct scic_sds_request *sci_req)
1362{
1363
1364 struct scu_sgl_element *current_sgl;
1365 u32 sgl_offset;
1366 u32 remaining_bytes_in_current_sgl = 0;
1367 enum sci_status status = SCI_SUCCESS;
1368 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1369
1370 sgl_offset = stp_req->type.pio.request_current.sgl_offset;
1371
1372 if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
1373 current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
1374 remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->A.length - sgl_offset;
1375 } else {
1376 current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
1377 remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->B.length - sgl_offset;
1378 }
1379
1380
1381 if (stp_req->type.pio.pio_transfer_bytes > 0) {
1382 if (stp_req->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
1383 /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = remaining_bytes_in_current_sgl */
1384 status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, remaining_bytes_in_current_sgl);
1385 if (status == SCI_SUCCESS) {
1386 stp_req->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
1387
1388 /* update the current sgl, sgl_offset and save for future */
1389 current_sgl = scic_sds_stp_request_pio_get_next_sgl(stp_req);
1390 sgl_offset = 0;
1391 }
1392 } else if (stp_req->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
1393 /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = type.pio.pio_transfer_bytes */
1394 scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, stp_req->type.pio.pio_transfer_bytes);
1395
1396 if (status == SCI_SUCCESS) {
1397 /* Sgl offset will be adjusted and saved for future */
1398 sgl_offset += stp_req->type.pio.pio_transfer_bytes;
1399 current_sgl->address_lower += stp_req->type.pio.pio_transfer_bytes;
1400 stp_req->type.pio.pio_transfer_bytes = 0;
1401 }
1402 }
1403 }
1404
1405 if (status == SCI_SUCCESS) {
1406 stp_req->type.pio.request_current.sgl_offset = sgl_offset;
1407 }
1408
1409 return status;
1410}
1411
1412/**
1413 *
1414 * @stp_request: The request that is used for the SGL processing.
1415 * @data_buffer: The buffer of data to be copied.
1416 * @length: The length of the data transfer.
1417 *
1418 * Copy the data from the buffer for the length specified to the IO reqeust SGL
1419 * specified data region. enum sci_status
1420 */
1421static enum sci_status
1422scic_sds_stp_request_pio_data_in_copy_data_buffer(struct scic_sds_stp_request *stp_req,
1423 u8 *data_buf, u32 len)
1424{
1425 struct scic_sds_request *sci_req;
1426 struct isci_request *ireq;
1427 u8 *src_addr;
1428 int copy_len;
1429 struct sas_task *task;
1430 struct scatterlist *sg;
1431 void *kaddr;
1432 int total_len = len;
1433
1434 sci_req = to_sci_req(stp_req);
1435 ireq = sci_req_to_ireq(sci_req);
1436 task = isci_request_access_task(ireq);
1437 src_addr = data_buf;
1438
1439 if (task->num_scatter > 0) {
1440 sg = task->scatter;
1441
1442 while (total_len > 0) {
1443 struct page *page = sg_page(sg);
1444
1445 copy_len = min_t(int, total_len, sg_dma_len(sg));
1446 kaddr = kmap_atomic(page, KM_IRQ0);
1447 memcpy(kaddr + sg->offset, src_addr, copy_len);
1448 kunmap_atomic(kaddr, KM_IRQ0);
1449 total_len -= copy_len;
1450 src_addr += copy_len;
1451 sg = sg_next(sg);
1452 }
1453 } else {
1454 BUG_ON(task->total_xfer_len < total_len);
1455 memcpy(task->scatter, src_addr, total_len);
1456 }
1457
1458 return SCI_SUCCESS;
1459}
1460
1461/**
1462 *
1463 * @sci_req: The PIO DATA IN request that is to receive the data.
1464 * @data_buffer: The buffer to copy from.
1465 *
1466 * Copy the data buffer to the io request data region. enum sci_status
1467 */
1468static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
1469 struct scic_sds_stp_request *sci_req,
1470 u8 *data_buffer)
1471{
1472 enum sci_status status;
1473
1474 /*
1475 * If there is less than 1K remaining in the transfer request
1476 * copy just the data for the transfer */
1477 if (sci_req->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
1478 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
1479 sci_req, data_buffer, sci_req->type.pio.pio_transfer_bytes);
1480
1481 if (status == SCI_SUCCESS)
1482 sci_req->type.pio.pio_transfer_bytes = 0;
1483 } else {
1484 /* We are transfering the whole frame so copy */
1485 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
1486 sci_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
1487
1488 if (status == SCI_SUCCESS)
1489 sci_req->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
1490 }
1491
1492 return status;
1493}
1494
e301370a
EN		 1495static enum sci_status
1496stp_request_pio_await_h2d_completion_tc_event(struct scic_sds_request *sci_req,
1497 u32 completion_code)
5dec6f4e
DW		 1498{
1499 enum sci_status status = SCI_SUCCESS;
1500
1501 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1502 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
e301370a
EN		 1503 scic_sds_request_set_status(sci_req,
1504 SCU_TASK_DONE_GOOD,
1505 SCI_SUCCESS);
5dec6f4e 1506
e301370a 1507 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
5dec6f4e
DW		 1508 break;
1509
1510 default:
a7e255a3
DW		 1511 /* All other completion status cause the IO to be
1512 * complete. If a NAK was received, then it is up to
1513 * the user to retry the request.
1514 */
1515 scic_sds_request_set_status(sci_req,
1516 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
1517 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
5dec6f4e 1518
e301370a 1519 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e
DW		 1520 break;
1521 }
1522
1523 return status;
1524}
1525
e301370a
EN		 1526static enum sci_status
1527pio_data_out_tx_done_tc_event(struct scic_sds_request *sci_req,
1528 u32 completion_code)
5dec6f4e 1529{
d1c637c3
DW		 1530 enum sci_status status = SCI_SUCCESS;
1531 bool all_frames_transferred = false;
5dec6f4e 1532 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
5dec6f4e 1533
d1c637c3
DW		 1534 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
1535 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
1536 /* Transmit data */
1537 if (stp_req->type.pio.pio_transfer_bytes != 0) {
5dec6f4e 1538 status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
d1c637c3
DW		 1539 if (status == SCI_SUCCESS) {
1540 if (stp_req->type.pio.pio_transfer_bytes == 0)
1541 all_frames_transferred = true;
1542 }
1543 } else if (stp_req->type.pio.pio_transfer_bytes == 0) {
1544 /*
1545 * this will happen if the all data is written at the
1546 * first time after the pio setup fis is received
5dec6f4e 1547 */
d1c637c3 1548 all_frames_transferred = true;
5dec6f4e
DW		 1549 }
1550
d1c637c3
DW		 1551 /* all data transferred. */
1552 if (all_frames_transferred) {
1553 /*
e301370a 1554 * Change the state to SCI_REQ_STP_PIO_DATA_IN
d1c637c3 1555 * and wait for PIO_SETUP fis / or D2H REg fis. */
e301370a 1556 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
d1c637c3 1557 }
5dec6f4e 1558 break;
e301370a 1559
5dec6f4e 1560 default:
d1c637c3 1561 /*
e301370a
EN		 1562 * All other completion status cause the IO to be complete.
1563 * If a NAK was received, then it is up to the user to retry
1564 * the request.
1565 */
d1c637c3
DW		 1566 scic_sds_request_set_status(
1567 sci_req,
1568 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
e301370a 1569 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
d1c637c3 1570
e301370a 1571 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e
DW		 1572 break;
1573 }
1574
1575 return status;
1576}
1577
5dec6f4e
DW		 1578static void scic_sds_stp_request_udma_complete_request(
1579 struct scic_sds_request *request,
1580 u32 scu_status,
1581 enum sci_status sci_status)
1582{
1583 scic_sds_request_set_status(request, scu_status, sci_status);
e301370a 1584 sci_change_state(&request->sm, SCI_REQ_COMPLETED);
5dec6f4e
DW		 1585}
1586
1587static enum sci_status scic_sds_stp_request_udma_general_frame_handler(struct scic_sds_request *sci_req,
1588 u32 frame_index)
1589{
1590 struct scic_sds_controller *scic = sci_req->owning_controller;
1591 struct dev_to_host_fis *frame_header;
1592 enum sci_status status;
1593 u32 *frame_buffer;
1594
1595 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1596 frame_index,
1597 (void **)&frame_header);
1598
1599 if ((status == SCI_SUCCESS) &&
1600 (frame_header->fis_type == FIS_REGD2H)) {
1601 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1602 frame_index,
1603 (void **)&frame_buffer);
1604
1605 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
1606 frame_header,
1607 frame_buffer);
1608 }
1609
1610 scic_sds_controller_release_frame(scic, frame_index);
1611
1612 return status;
1613}
1614
e301370a
EN		 1615enum sci_status
1616scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
1617 u32 frame_index)
d1c637c3
DW		 1618{
1619 struct scic_sds_controller *scic = sci_req->owning_controller;
1620 struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
1621 enum sci_base_request_states state;
1622 enum sci_status status;
1623 ssize_t word_cnt;
1624
e301370a 1625 state = sci_req->sm.current_state_id;
d1c637c3 1626 switch (state) {
e301370a 1627 case SCI_REQ_STARTED: {
d1c637c3
DW		 1628 struct ssp_frame_hdr ssp_hdr;
1629 void *frame_header;
1630
1631 scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1632 frame_index,
1633 &frame_header);
1634
1635 word_cnt = sizeof(struct ssp_frame_hdr) / sizeof(u32);
1636 sci_swab32_cpy(&ssp_hdr, frame_header, word_cnt);
1637
1638 if (ssp_hdr.frame_type == SSP_RESPONSE) {
1639 struct ssp_response_iu *resp_iu;
1640 ssize_t word_cnt = SSP_RESP_IU_MAX_SIZE / sizeof(u32);
1641
1642 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1643 frame_index,
1644 (void **)&resp_iu);
1645
1646 sci_swab32_cpy(&sci_req->ssp.rsp, resp_iu, word_cnt);
1647
1648 resp_iu = &sci_req->ssp.rsp;
1649
1650 if (resp_iu->datapres == 0x01 ||
1651 resp_iu->datapres == 0x02) {
1652 scic_sds_request_set_status(sci_req,
1653 SCU_TASK_DONE_CHECK_RESPONSE,
1654 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
1655 } else
1656 scic_sds_request_set_status(sci_req,
1657 SCU_TASK_DONE_GOOD,
1658 SCI_SUCCESS);
1659 } else {
1660 /* not a response frame, why did it get forwarded? */
1661 dev_err(scic_to_dev(scic),
1662 "%s: SCIC IO Request 0x%p received unexpected "
1663 "frame %d type 0x%02x\n", __func__, sci_req,
1664 frame_index, ssp_hdr.frame_type);
1665 }
1666
1667 /*
e301370a
EN		 1668 * In any case we are done with this frame buffer return it to
1669 * the controller
d1c637c3
DW		 1670 */
1671 scic_sds_controller_release_frame(scic, frame_index);
1672
1673 return SCI_SUCCESS;
1674 }
e301370a
EN		 1675
1676 case SCI_REQ_TASK_WAIT_TC_RESP:
d1c637c3 1677 scic_sds_io_request_copy_response(sci_req);
e301370a 1678 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3
DW		 1679 scic_sds_controller_release_frame(scic,frame_index);
1680 return SCI_SUCCESS;
e301370a
EN		 1681
1682 case SCI_REQ_SMP_WAIT_RESP: {
d1c637c3
DW		 1683 struct smp_resp *rsp_hdr = &sci_req->smp.rsp;
1684 void *frame_header;
1685
1686 scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1687 frame_index,
1688 &frame_header);
1689
1690 /* byte swap the header. */
1691 word_cnt = SMP_RESP_HDR_SZ / sizeof(u32);
1692 sci_swab32_cpy(rsp_hdr, frame_header, word_cnt);
1693
1694 if (rsp_hdr->frame_type == SMP_RESPONSE) {
1695 void *smp_resp;
1696
1697 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1698 frame_index,
1699 &smp_resp);
1700
1701 word_cnt = (sizeof(struct smp_req) - SMP_RESP_HDR_SZ) /
1702 sizeof(u32);
1703
1704 sci_swab32_cpy(((u8 *) rsp_hdr) + SMP_RESP_HDR_SZ,
1705 smp_resp, word_cnt);
1706
1707 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
1708 SCI_SUCCESS);
1709
e301370a 1710 sci_change_state(&sci_req->sm, SCI_REQ_SMP_WAIT_TC_COMP);
d1c637c3 1711 } else {
e301370a
EN		 1712 /*
1713 * This was not a response frame why did it get
1714 * forwarded?
1715 */
d1c637c3 1716 dev_err(scic_to_dev(scic),
e301370a
EN		 1717 "%s: SCIC SMP Request 0x%p received unexpected "
1718 "frame %d type 0x%02x\n",
1719 __func__,
1720 sci_req,
1721 frame_index,
1722 rsp_hdr->frame_type);
d1c637c3
DW		 1723
1724 scic_sds_request_set_status(sci_req,
1725 SCU_TASK_DONE_SMP_FRM_TYPE_ERR,
1726 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
1727
e301370a 1728 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3
DW		 1729 }
1730
1731 scic_sds_controller_release_frame(scic, frame_index);
1732
1733 return SCI_SUCCESS;
1734 }
e301370a
EN		 1735
1736 case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
1737 return scic_sds_stp_request_udma_general_frame_handler(sci_req,
1738 frame_index);
1739
1740 case SCI_REQ_STP_UDMA_WAIT_D2H:
d1c637c3 1741 /* Use the general frame handler to copy the resposne data */
e301370a
EN		 1742 status = scic_sds_stp_request_udma_general_frame_handler(sci_req,
1743 frame_index);
d1c637c3
DW		 1744
1745 if (status != SCI_SUCCESS)
1746 return status;
1747
1748 scic_sds_stp_request_udma_complete_request(sci_req,
1749 SCU_TASK_DONE_CHECK_RESPONSE,
1750 SCI_FAILURE_IO_RESPONSE_VALID);
e301370a 1751
d1c637c3 1752 return SCI_SUCCESS;
e301370a
EN		 1753
1754 case SCI_REQ_STP_NON_DATA_WAIT_D2H: {
d1c637c3
DW		 1755 struct dev_to_host_fis *frame_header;
1756 u32 *frame_buffer;
1757
1758 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1759 frame_index,
1760 (void **)&frame_header);
1761
1762 if (status != SCI_SUCCESS) {
1763 dev_err(scic_to_dev(scic),
e301370a
EN		 1764 "%s: SCIC IO Request 0x%p could not get frame "
1765 "header for frame index %d, status %x\n",
1766 __func__,
1767 stp_req,
1768 frame_index,
1769 status);
d1c637c3
DW		 1770
1771 return status;
1772 }
1773
1774 switch (frame_header->fis_type) {
1775 case FIS_REGD2H:
1776 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1777 frame_index,
1778 (void **)&frame_buffer);
1779
1780 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
1781 frame_header,
1782 frame_buffer);
1783
1784 /* The command has completed with error */
1785 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_CHECK_RESPONSE,
1786 SCI_FAILURE_IO_RESPONSE_VALID);
1787 break;
1788
1789 default:
1790 dev_warn(scic_to_dev(scic),
1791 "%s: IO Request:0x%p Frame Id:%d protocol "
1792 "violation occurred\n", __func__, stp_req,
1793 frame_index);
1794
1795 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
1796 SCI_FAILURE_PROTOCOL_VIOLATION);
1797 break;
1798 }
1799
e301370a 1800 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3
DW		 1801
1802 /* Frame has been decoded return it to the controller */
1803 scic_sds_controller_release_frame(scic, frame_index);
1804
1805 return status;
1806 }
e301370a
EN		 1807
1808 case SCI_REQ_STP_PIO_WAIT_FRAME: {
d1c637c3
DW		 1809 struct isci_request *ireq = sci_req_to_ireq(sci_req);
1810 struct sas_task *task = isci_request_access_task(ireq);
1811 struct dev_to_host_fis *frame_header;
1812 u32 *frame_buffer;
1813
1814 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1815 frame_index,
1816 (void **)&frame_header);
1817
1818 if (status != SCI_SUCCESS) {
1819 dev_err(scic_to_dev(scic),
e301370a
EN		 1820 "%s: SCIC IO Request 0x%p could not get frame "
1821 "header for frame index %d, status %x\n",
d1c637c3
DW		 1822 __func__, stp_req, frame_index, status);
1823 return status;
1824 }
1825
1826 switch (frame_header->fis_type) {
1827 case FIS_PIO_SETUP:
1828 /* Get from the frame buffer the PIO Setup Data */
1829 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1830 frame_index,
1831 (void **)&frame_buffer);
1832
e301370a
EN		 1833 /* Get the data from the PIO Setup The SCU Hardware
1834 * returns first word in the frame_header and the rest
1835 * of the data is in the frame buffer so we need to
1836 * back up one dword
d1c637c3
DW		 1837 */
1838
1839 /* transfer_count: first 16bits in the 4th dword */
1840 stp_req->type.pio.pio_transfer_bytes = frame_buffer[3] & 0xffff;
1841
1842 /* ending_status: 4th byte in the 3rd dword */
1843 stp_req->type.pio.ending_status = (frame_buffer[2] >> 24) & 0xff;
1844
1845 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
1846 frame_header,
1847 frame_buffer);
1848
1849 sci_req->stp.rsp.status = stp_req->type.pio.ending_status;
1850
1851 /* The next state is dependent on whether the
1852 * request was PIO Data-in or Data out
1853 */
1854 if (task->data_dir == DMA_FROM_DEVICE) {
e301370a 1855 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_DATA_IN);
d1c637c3
DW		 1856 } else if (task->data_dir == DMA_TO_DEVICE) {
1857 /* Transmit data */
1858 status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
1859 if (status != SCI_SUCCESS)
1860 break;
e301370a 1861 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_DATA_OUT);
d1c637c3
DW		 1862 }
1863 break;
e301370a 1864
d1c637c3 1865 case FIS_SETDEVBITS:
e301370a 1866 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
d1c637c3 1867 break;
e301370a 1868
d1c637c3
DW		 1869 case FIS_REGD2H:
1870 if (frame_header->status & ATA_BUSY) {
e301370a
EN		 1871 /*
1872 * Now why is the drive sending a D2H Register
1873 * FIS when it is still busy? Do nothing since
1874 * we are still in the right state.
d1c637c3
DW		 1875 */
1876 dev_dbg(scic_to_dev(scic),
1877 "%s: SCIC PIO Request 0x%p received "
1878 "D2H Register FIS with BSY status "
e301370a
EN		 1879 "0x%x\n",
1880 __func__,
1881 stp_req,
d1c637c3
DW		 1882 frame_header->status);
1883 break;
1884 }
1885
1886 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1887 frame_index,
1888 (void **)&frame_buffer);
1889
1890 scic_sds_controller_copy_sata_response(&sci_req->stp.req,
1891 frame_header,
1892 frame_buffer);
1893
1894 scic_sds_request_set_status(sci_req,
1895 SCU_TASK_DONE_CHECK_RESPONSE,
1896 SCI_FAILURE_IO_RESPONSE_VALID);
1897
e301370a 1898 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3 1899 break;
e301370a 1900
d1c637c3
DW		 1901 default:
1902 /* FIXME: what do we do here? */
1903 break;
1904 }
1905
1906 /* Frame is decoded return it to the controller */
1907 scic_sds_controller_release_frame(scic, frame_index);
1908
1909 return status;
1910 }
e301370a
EN		 1911
1912 case SCI_REQ_STP_PIO_DATA_IN: {
d1c637c3
DW		 1913 struct dev_to_host_fis *frame_header;
1914 struct sata_fis_data *frame_buffer;
1915
1916 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1917 frame_index,
1918 (void **)&frame_header);
1919
1920 if (status != SCI_SUCCESS) {
1921 dev_err(scic_to_dev(scic),
e301370a
EN		 1922 "%s: SCIC IO Request 0x%p could not get frame "
1923 "header for frame index %d, status %x\n",
1924 __func__,
1925 stp_req,
1926 frame_index,
1927 status);
d1c637c3
DW		 1928 return status;
1929 }
1930
1931 if (frame_header->fis_type != FIS_DATA) {
1932 dev_err(scic_to_dev(scic),
1933 "%s: SCIC PIO Request 0x%p received frame %d "
1934 "with fis type 0x%02x when expecting a data "
e301370a
EN		 1935 "fis.\n",
1936 __func__,
1937 stp_req,
1938 frame_index,
d1c637c3
DW		 1939 frame_header->fis_type);
1940
1941 scic_sds_request_set_status(sci_req,
1942 SCU_TASK_DONE_GOOD,
1943 SCI_FAILURE_IO_REQUIRES_SCSI_ABORT);
1944
e301370a 1945 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3
DW		 1946
1947 /* Frame is decoded return it to the controller */
1948 scic_sds_controller_release_frame(scic, frame_index);
1949 return status;
1950 }
1951
1952 if (stp_req->type.pio.request_current.sgl_pair == NULL) {
1953 sci_req->saved_rx_frame_index = frame_index;
1954 stp_req->type.pio.pio_transfer_bytes = 0;
1955 } else {
1956 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
1957 frame_index,
1958 (void **)&frame_buffer);
1959
1960 status = scic_sds_stp_request_pio_data_in_copy_data(stp_req,
1961 (u8 *)frame_buffer);
1962
1963 /* Frame is decoded return it to the controller */
1964 scic_sds_controller_release_frame(scic, frame_index);
1965 }
1966
1967 /* Check for the end of the transfer, are there more
1968 * bytes remaining for this data transfer
1969 */
1970 if (status != SCI_SUCCESS ||
1971 stp_req->type.pio.pio_transfer_bytes != 0)
1972 return status;
1973
1974 if ((stp_req->type.pio.ending_status & ATA_BUSY) == 0) {
1975 scic_sds_request_set_status(sci_req,
1976 SCU_TASK_DONE_CHECK_RESPONSE,
1977 SCI_FAILURE_IO_RESPONSE_VALID);
1978
e301370a 1979 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3 1980 } else {
e301370a 1981 sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
d1c637c3
DW		 1982 }
1983 return status;
1984 }
e301370a
EN		 1985
1986 case SCI_REQ_STP_SOFT_RESET_WAIT_D2H: {
d1c637c3
DW		 1987 struct dev_to_host_fis *frame_header;
1988 u32 *frame_buffer;
1989
1990 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
1991 frame_index,
1992 (void **)&frame_header);
1993 if (status != SCI_SUCCESS) {
1994 dev_err(scic_to_dev(scic),
e301370a
EN		 1995 "%s: SCIC IO Request 0x%p could not get frame "
1996 "header for frame index %d, status %x\n",
1997 __func__,
1998 stp_req,
1999 frame_index,
2000 status);
d1c637c3
DW		 2001 return status;
2002 }
2003
2004 switch (frame_header->fis_type) {
2005 case FIS_REGD2H:
2006 scic_sds_unsolicited_frame_control_get_buffer(&scic->uf_control,
2007 frame_index,
2008 (void **)&frame_buffer);
2009
2010 scic_sds_controller_copy_sata_response(&sci_req->stp.rsp,
2011 frame_header,
2012 frame_buffer);
2013
2014 /* The command has completed with error */
2015 scic_sds_request_set_status(sci_req,
2016 SCU_TASK_DONE_CHECK_RESPONSE,
2017 SCI_FAILURE_IO_RESPONSE_VALID);
2018 break;
e301370a 2019
d1c637c3
DW		 2020 default:
2021 dev_warn(scic_to_dev(scic),
2022 "%s: IO Request:0x%p Frame Id:%d protocol "
e301370a
EN		 2023 "violation occurred\n",
2024 __func__,
2025 stp_req,
d1c637c3
DW		 2026 frame_index);
2027
e301370a
EN		 2028 scic_sds_request_set_status(sci_req,
2029 SCU_TASK_DONE_UNEXP_FIS,
d1c637c3
DW		 2030 SCI_FAILURE_PROTOCOL_VIOLATION);
2031 break;
2032 }
2033
e301370a 2034 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
d1c637c3
DW		 2035
2036 /* Frame has been decoded return it to the controller */
2037 scic_sds_controller_release_frame(scic, frame_index);
2038
2039 return status;
2040 }
e301370a
EN		 2041 case SCI_REQ_ABORTING:
2042 /*
2043 * TODO: Is it even possible to get an unsolicited frame in the
d1c637c3
DW		 2044 * aborting state?
2045 */
2046 scic_sds_controller_release_frame(scic, frame_index);
2047 return SCI_SUCCESS;
e301370a 2048
d1c637c3
DW		 2049 default:
2050 dev_warn(scic_to_dev(scic),
e301370a
EN		 2051 "%s: SCIC IO Request given unexpected frame %x while "
2052 "in state %d\n",
2053 __func__,
2054 frame_index,
2055 state);
d1c637c3
DW		 2056
2057 scic_sds_controller_release_frame(scic, frame_index);
2058 return SCI_FAILURE_INVALID_STATE;
2059 }
2060}
2061
a7e255a3
DW		 2062static enum sci_status stp_request_udma_await_tc_event(struct scic_sds_request *sci_req,
2063 u32 completion_code)
5dec6f4e
DW		 2064{
2065 enum sci_status status = SCI_SUCCESS;
2066
2067 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2068 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
2069 scic_sds_stp_request_udma_complete_request(sci_req,
2070 SCU_TASK_DONE_GOOD,
2071 SCI_SUCCESS);
2072 break;
2073 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_FIS):
2074 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
a7e255a3
DW		 2075 /* We must check ther response buffer to see if the D2H
2076 * Register FIS was received before we got the TC
2077 * completion.
2078 */
5dec6f4e
DW		 2079 if (sci_req->stp.rsp.fis_type == FIS_REGD2H) {
2080 scic_sds_remote_device_suspend(sci_req->target_device,
2081 SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
2082
2083 scic_sds_stp_request_udma_complete_request(sci_req,
2084 SCU_TASK_DONE_CHECK_RESPONSE,
2085 SCI_FAILURE_IO_RESPONSE_VALID);
2086 } else {
a7e255a3
DW		 2087 /* If we have an error completion status for the
2088 * TC then we can expect a D2H register FIS from
2089 * the device so we must change state to wait
2090 * for it
2091 */
e301370a 2092 sci_change_state(&sci_req->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
5dec6f4e
DW		 2093 }
2094 break;
2095
a7e255a3
DW		 2096 /* TODO Check to see if any of these completion status need to
2097 * wait for the device to host register fis.
2098 */
2099 /* TODO We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR
2100 * - this comes only for B0
2101 */
5dec6f4e
DW		 2102 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_INV_FIS_LEN):
2103 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
2104 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_R_ERR):
2105 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
2106 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
2107 scic_sds_remote_device_suspend(sci_req->target_device,
2108 SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
2109 /* Fall through to the default case */
2110 default:
2111 /* All other completion status cause the IO to be complete. */
2112 scic_sds_stp_request_udma_complete_request(sci_req,
2113 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
2114 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
2115 break;
2116 }
2117
2118 return status;
2119}
2120
e301370a
EN		 2121static enum sci_status
2122stp_request_soft_reset_await_h2d_asserted_tc_event(struct scic_sds_request *sci_req,
2123 u32 completion_code)
5dec6f4e
DW		 2124{
2125 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2126 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
a7e255a3
DW		 2127 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
2128 SCI_SUCCESS);
5dec6f4e 2129
e301370a 2130 sci_change_state(&sci_req->sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG);
5dec6f4e
DW		 2131 break;
2132
2133 default:
2134 /*
e301370a
EN		 2135 * All other completion status cause the IO to be complete.
2136 * If a NAK was received, then it is up to the user to retry
2137 * the request.
2138 */
a7e255a3 2139 scic_sds_request_set_status(sci_req,
e301370a
EN		 2140 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
2141 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
c72086e3 2142
e301370a 2143 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
5dec6f4e 2144 break;
c72086e3
DW		 2145 }
2146
c72086e3
DW		 2147 return SCI_SUCCESS;
2148}
2149
e301370a
EN		 2150static enum sci_status
2151stp_request_soft_reset_await_h2d_diagnostic_tc_event(struct scic_sds_request *sci_req,
2152 u32 completion_code)
c72086e3
DW		 2153{
2154 switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
2155 case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
5dec6f4e
DW		 2156 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
2157 SCI_SUCCESS);
c72086e3 2158
e301370a 2159 sci_change_state(&sci_req->sm, SCI_REQ_STP_SOFT_RESET_WAIT_D2H);
c72086e3
DW		 2160 break;
2161
2162 default:
a7e255a3
DW		 2163 /* All other completion status cause the IO to be complete. If
2164 * a NAK was received, then it is up to the user to retry the
2165 * request.
2166 */
2167 scic_sds_request_set_status(sci_req,
c72086e3 2168 SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
a7e255a3 2169 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
c72086e3 2170
e301370a 2171 sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
c72086e3
DW		 2172 break;
2173 }
2174
2175 return SCI_SUCCESS;
2176}
2177
a7e255a3 2178enum sci_status
e301370a
EN		 2179scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req,
2180 u32 completion_code)
a7e255a3
DW		 2181{
2182 enum sci_base_request_states state;
2183 struct scic_sds_controller *scic = sci_req->owning_controller;
2184
e301370a 2185 state = sci_req->sm.current_state_id;
a7e255a3
DW		 2186
2187 switch (state) {
e301370a
EN		 2188 case SCI_REQ_STARTED:
2189 return request_started_state_tc_event(sci_req, completion_code);
2190
2191 case SCI_REQ_TASK_WAIT_TC_COMP:
2192 return ssp_task_request_await_tc_event(sci_req,
2193 completion_code);
2194
2195 case SCI_REQ_SMP_WAIT_RESP:
2196 return smp_request_await_response_tc_event(sci_req,
2197 completion_code);
2198
2199 case SCI_REQ_SMP_WAIT_TC_COMP:
2200 return smp_request_await_tc_event(sci_req, completion_code);
2201
2202 case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
2203 return stp_request_udma_await_tc_event(sci_req,
2204 completion_code);
2205
2206 case SCI_REQ_STP_NON_DATA_WAIT_H2D:
2207 return stp_request_non_data_await_h2d_tc_event(sci_req,
2208 completion_code);
2209
2210 case SCI_REQ_STP_PIO_WAIT_H2D:
2211 return stp_request_pio_await_h2d_completion_tc_event(sci_req,
2212 completion_code);
2213
2214 case SCI_REQ_STP_PIO_DATA_OUT:
2215 return pio_data_out_tx_done_tc_event(sci_req, completion_code);
2216
2217 case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED:
2218 return stp_request_soft_reset_await_h2d_asserted_tc_event(sci_req,
2219 completion_code);
2220
2221 case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG:
2222 return stp_request_soft_reset_await_h2d_diagnostic_tc_event(sci_req,
2223 completion_code);
2224
2225 case SCI_REQ_ABORTING:
2226 return request_aborting_state_tc_event(sci_req,
2227 completion_code);
2228
2229 default:
2230 dev_warn(scic_to_dev(scic),
2231 "%s: SCIC IO Request given task completion "
2232 "notification %x while in wrong state %d\n",
2233 __func__,
2234 completion_code,
2235 state);
2236 return SCI_FAILURE_INVALID_STATE;
a7e255a3
DW		 2237 }
2238}
2239
6f231dda 2240/**
f1f52e75
DW		 2241 * isci_request_process_response_iu() - This function sets the status and
2242 * response iu, in the task struct, from the request object for the upper
2243 * layer driver.
2244 * @sas_task: This parameter is the task struct from the upper layer driver.
2245 * @resp_iu: This parameter points to the response iu of the completed request.
2246 * @dev: This parameter specifies the linux device struct.
6f231dda
DW		 2247 *
2248 * none.
2249 */
f1f52e75
DW		 2250static void isci_request_process_response_iu(
2251 struct sas_task *task,
2252 struct ssp_response_iu *resp_iu,
2253 struct device *dev)
6f231dda 2254{
f1f52e75
DW		 2255 dev_dbg(dev,
2256 "%s: resp_iu = %p "
2257 "resp_iu->status = 0x%x,\nresp_iu->datapres = %d "
2258 "resp_iu->response_data_len = %x, "
2259 "resp_iu->sense_data_len = %x\nrepsonse data: ",
6f231dda 2260 __func__,
f1f52e75
DW		 2261 resp_iu,
2262 resp_iu->status,
2263 resp_iu->datapres,
2264 resp_iu->response_data_len,
2265 resp_iu->sense_data_len);
6f231dda 2266
f1f52e75 2267 task->task_status.stat = resp_iu->status;
6f231dda 2268
f1f52e75
DW		 2269 /* libsas updates the task status fields based on the response iu. */
2270 sas_ssp_task_response(dev, task, resp_iu);
2271}
6f231dda 2272
f1f52e75
DW		 2273/**
2274 * isci_request_set_open_reject_status() - This function prepares the I/O
2275 * completion for OPEN_REJECT conditions.
2276 * @request: This parameter is the completed isci_request object.
2277 * @response_ptr: This parameter specifies the service response for the I/O.
2278 * @status_ptr: This parameter specifies the exec status for the I/O.
2279 * @complete_to_host_ptr: This parameter specifies the action to be taken by
2280 * the LLDD with respect to completing this request or forcing an abort
2281 * condition on the I/O.
2282 * @open_rej_reason: This parameter specifies the encoded reason for the
2283 * abandon-class reject.
2284 *
2285 * none.
2286 */
2287static void isci_request_set_open_reject_status(
2288 struct isci_request *request,
2289 struct sas_task *task,
2290 enum service_response *response_ptr,
2291 enum exec_status *status_ptr,
2292 enum isci_completion_selection *complete_to_host_ptr,
2293 enum sas_open_rej_reason open_rej_reason)
2294{
2295 /* Task in the target is done. */
2296 request->complete_in_target = true;
2297 *response_ptr = SAS_TASK_UNDELIVERED;
2298 *status_ptr = SAS_OPEN_REJECT;
2299 *complete_to_host_ptr = isci_perform_normal_io_completion;
2300 task->task_status.open_rej_reason = open_rej_reason;
2301}
6f231dda 2302
f1f52e75
DW		 2303/**
2304 * isci_request_handle_controller_specific_errors() - This function decodes
2305 * controller-specific I/O completion error conditions.
2306 * @request: This parameter is the completed isci_request object.
2307 * @response_ptr: This parameter specifies the service response for the I/O.
2308 * @status_ptr: This parameter specifies the exec status for the I/O.
2309 * @complete_to_host_ptr: This parameter specifies the action to be taken by
2310 * the LLDD with respect to completing this request or forcing an abort
2311 * condition on the I/O.
2312 *
2313 * none.
2314 */
2315static void isci_request_handle_controller_specific_errors(
2316 struct isci_remote_device *isci_device,
2317 struct isci_request *request,
2318 struct sas_task *task,
2319 enum service_response *response_ptr,
2320 enum exec_status *status_ptr,
2321 enum isci_completion_selection *complete_to_host_ptr)
2322{
2323 unsigned int cstatus;
6f231dda 2324
f1f52e75 2325 cstatus = request->sci.scu_status;
a5fde225 2326
f1f52e75
DW		 2327 dev_dbg(&request->isci_host->pdev->dev,
2328 "%s: %p SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR "
2329 "- controller status = 0x%x\n",
2330 __func__, request, cstatus);
6f231dda 2331
f1f52e75
DW		 2332 /* Decode the controller-specific errors; most
2333 * important is to recognize those conditions in which
2334 * the target may still have a task outstanding that
2335 * must be aborted.
2336 *
2337 * Note that there are SCU completion codes being
2338 * named in the decode below for which SCIC has already
2339 * done work to handle them in a way other than as
2340 * a controller-specific completion code; these are left
2341 * in the decode below for completeness sake.
2342 */
2343 switch (cstatus) {
2344 case SCU_TASK_DONE_DMASETUP_DIRERR:
2345 /* Also SCU_TASK_DONE_SMP_FRM_TYPE_ERR: */
2346 case SCU_TASK_DONE_XFERCNT_ERR:
2347 /* Also SCU_TASK_DONE_SMP_UFI_ERR: */
2348 if (task->task_proto == SAS_PROTOCOL_SMP) {
2349 /* SCU_TASK_DONE_SMP_UFI_ERR == Task Done. */
2350 *response_ptr = SAS_TASK_COMPLETE;
6f231dda 2351
f1f52e75
DW		 2352 /* See if the device has been/is being stopped. Note
2353 * that we ignore the quiesce state, since we are
6f231dda
DW		 2354 * concerned about the actual device state.
2355 */
f1f52e75
DW		 2356 if ((isci_device->status == isci_stopping) ||
2357 (isci_device->status == isci_stopped))
2358 *status_ptr = SAS_DEVICE_UNKNOWN;
2359 else
2360 *status_ptr = SAS_ABORTED_TASK;
6f231dda 2361
f1f52e75 2362 request->complete_in_target = true;
6f231dda 2363
f1f52e75
DW		 2364 *complete_to_host_ptr =
2365 isci_perform_normal_io_completion;
2366 } else {
2367 /* Task in the target is not done. */
2368 *response_ptr = SAS_TASK_UNDELIVERED;
a5fde225 2369
f1f52e75
DW		 2370 if ((isci_device->status == isci_stopping) ||
2371 (isci_device->status == isci_stopped))
2372 *status_ptr = SAS_DEVICE_UNKNOWN;
2373 else
2374 *status_ptr = SAM_STAT_TASK_ABORTED;
6f231dda 2375
f1f52e75 2376 request->complete_in_target = false;
6f231dda 2377
f1f52e75
DW		 2378 *complete_to_host_ptr =
2379 isci_perform_error_io_completion;
2380 }
2381
2382 break;
2383
2384 case SCU_TASK_DONE_CRC_ERR:
2385 case SCU_TASK_DONE_NAK_CMD_ERR:
2386 case SCU_TASK_DONE_EXCESS_DATA:
2387 case SCU_TASK_DONE_UNEXP_FIS:
2388 /* Also SCU_TASK_DONE_UNEXP_RESP: */
2389 case SCU_TASK_DONE_VIIT_ENTRY_NV: /* TODO - conditions? */
2390 case SCU_TASK_DONE_IIT_ENTRY_NV: /* TODO - conditions? */
2391 case SCU_TASK_DONE_RNCNV_OUTBOUND: /* TODO - conditions? */
2392 /* These are conditions in which the target
2393 * has completed the task, so that no cleanup
2394 * is necessary.
6f231dda 2395 */
f1f52e75 2396 *response_ptr = SAS_TASK_COMPLETE;
6f231dda
DW		 2397
2398 /* See if the device has been/is being stopped. Note
2399 * that we ignore the quiesce state, since we are
2400 * concerned about the actual device state.
2401 */
2402 if ((isci_device->status == isci_stopping) ||
2403 (isci_device->status == isci_stopped))
f1f52e75 2404 *status_ptr = SAS_DEVICE_UNKNOWN;
6f231dda 2405 else
f1f52e75 2406 *status_ptr = SAS_ABORTED_TASK;
6f231dda 2407
f1f52e75 2408 request->complete_in_target = true;
a5fde225 2409
f1f52e75 2410 *complete_to_host_ptr = isci_perform_normal_io_completion;
6f231dda
DW		 2411 break;
2412
6f231dda 2413
f1f52e75
DW		 2414 /* Note that the only open reject completion codes seen here will be
2415 * abandon-class codes; all others are automatically retried in the SCU.
2416 */
2417 case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
a5fde225 2418
f1f52e75
DW		 2419 isci_request_set_open_reject_status(
2420 request, task, response_ptr, status_ptr,
2421 complete_to_host_ptr, SAS_OREJ_WRONG_DEST);
2422 break;
a5fde225 2423
f1f52e75 2424 case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
6f231dda 2425
f1f52e75
DW		 2426 /* Note - the return of AB0 will change when
2427 * libsas implements detection of zone violations.
2428 */
2429 isci_request_set_open_reject_status(
2430 request, task, response_ptr, status_ptr,
2431 complete_to_host_ptr, SAS_OREJ_RESV_AB0);
2432 break;
6f231dda 2433
f1f52e75 2434 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
6f231dda 2435
f1f52e75
DW		 2436 isci_request_set_open_reject_status(
2437 request, task, response_ptr, status_ptr,
2438 complete_to_host_ptr, SAS_OREJ_RESV_AB1);
2439 break;
6f231dda 2440
f1f52e75 2441 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
6f231dda 2442
f1f52e75
DW		 2443 isci_request_set_open_reject_status(
2444 request, task, response_ptr, status_ptr,
2445 complete_to_host_ptr, SAS_OREJ_RESV_AB2);
2446 break;
6f231dda 2447
f1f52e75 2448 case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
6f231dda 2449
f1f52e75
DW		 2450 isci_request_set_open_reject_status(
2451 request, task, response_ptr, status_ptr,
2452 complete_to_host_ptr, SAS_OREJ_RESV_AB3);
2453 break;
6f231dda 2454
f1f52e75 2455 case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
6f231dda 2456
f1f52e75
DW		 2457 isci_request_set_open_reject_status(
2458 request, task, response_ptr, status_ptr,
2459 complete_to_host_ptr, SAS_OREJ_BAD_DEST);
2460 break;
6f231dda 2461
f1f52e75 2462 case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
6f231dda 2463
f1f52e75
DW		 2464 isci_request_set_open_reject_status(
2465 request, task, response_ptr, status_ptr,
2466 complete_to_host_ptr, SAS_OREJ_STP_NORES);
2467 break;
6f231dda 2468
f1f52e75 2469 case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
6f231dda 2470
f1f52e75
DW		 2471 isci_request_set_open_reject_status(
2472 request, task, response_ptr, status_ptr,
2473 complete_to_host_ptr, SAS_OREJ_EPROTO);
2474 break;
6f231dda 2475
f1f52e75 2476 case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
6f231dda 2477
f1f52e75
DW		 2478 isci_request_set_open_reject_status(
2479 request, task, response_ptr, status_ptr,
2480 complete_to_host_ptr, SAS_OREJ_CONN_RATE);
2481 break;
6f231dda 2482
f1f52e75
DW		 2483 case SCU_TASK_DONE_LL_R_ERR:
2484 /* Also SCU_TASK_DONE_ACK_NAK_TO: */
2485 case SCU_TASK_DONE_LL_PERR:
2486 case SCU_TASK_DONE_LL_SY_TERM:
2487 /* Also SCU_TASK_DONE_NAK_ERR:*/
2488 case SCU_TASK_DONE_LL_LF_TERM:
2489 /* Also SCU_TASK_DONE_DATA_LEN_ERR: */
2490 case SCU_TASK_DONE_LL_ABORT_ERR:
2491 case SCU_TASK_DONE_SEQ_INV_TYPE:
2492 /* Also SCU_TASK_DONE_UNEXP_XR: */
2493 case SCU_TASK_DONE_XR_IU_LEN_ERR:
2494 case SCU_TASK_DONE_INV_FIS_LEN:
2495 /* Also SCU_TASK_DONE_XR_WD_LEN: */
2496 case SCU_TASK_DONE_SDMA_ERR:
2497 case SCU_TASK_DONE_OFFSET_ERR:
2498 case SCU_TASK_DONE_MAX_PLD_ERR:
2499 case SCU_TASK_DONE_LF_ERR:
2500 case SCU_TASK_DONE_SMP_RESP_TO_ERR: /* Escalate to dev reset? */
2501 case SCU_TASK_DONE_SMP_LL_RX_ERR:
2502 case SCU_TASK_DONE_UNEXP_DATA:
2503 case SCU_TASK_DONE_UNEXP_SDBFIS:
2504 case SCU_TASK_DONE_REG_ERR:
2505 case SCU_TASK_DONE_SDB_ERR:
2506 case SCU_TASK_DONE_TASK_ABORT:
2507 default:
2508 /* Task in the target is not done. */
2509 *response_ptr = SAS_TASK_UNDELIVERED;
2510 *status_ptr = SAM_STAT_TASK_ABORTED;
6f231dda 2511
cde76fbf
JS		 2512 if (task->task_proto == SAS_PROTOCOL_SMP) {
2513 request->complete_in_target = true;
2514
2515 *complete_to_host_ptr = isci_perform_normal_io_completion;
2516 } else {
2517 request->complete_in_target = false;
2518
2519 *complete_to_host_ptr = isci_perform_error_io_completion;
2520 }
f1f52e75
DW		 2521 break;
2522 }
2523}
6f231dda 2524
f1f52e75
DW		 2525/**
2526 * isci_task_save_for_upper_layer_completion() - This function saves the
2527 * request for later completion to the upper layer driver.
2528 * @host: This parameter is a pointer to the host on which the the request
2529 * should be queued (either as an error or success).
2530 * @request: This parameter is the completed request.
2531 * @response: This parameter is the response code for the completed task.
2532 * @status: This parameter is the status code for the completed task.
2533 *
2534 * none.
2535 */
2536static void isci_task_save_for_upper_layer_completion(
2537 struct isci_host *host,
2538 struct isci_request *request,
2539 enum service_response response,
2540 enum exec_status status,
2541 enum isci_completion_selection task_notification_selection)
2542{
2543 struct sas_task *task = isci_request_access_task(request);
6f231dda 2544
f1f52e75
DW		 2545 task_notification_selection
2546 = isci_task_set_completion_status(task, response, status,
2547 task_notification_selection);
6f231dda 2548
f1f52e75
DW		 2549 /* Tasks aborted specifically by a call to the lldd_abort_task
2550 * function should not be completed to the host in the regular path.
2551 */
2552 switch (task_notification_selection) {
6f231dda 2553
f1f52e75 2554 case isci_perform_normal_io_completion:
6f231dda 2555
f1f52e75
DW		 2556 /* Normal notification (task_done) */
2557 dev_dbg(&host->pdev->dev,
2558 "%s: Normal - task = %p, response=%d (%d), status=%d (%d)\n",
2559 __func__,
2560 task,
2561 task->task_status.resp, response,
2562 task->task_status.stat, status);
2563 /* Add to the completed list. */
2564 list_add(&request->completed_node,
2565 &host->requests_to_complete);
6f231dda 2566
f1f52e75
DW		 2567 /* Take the request off the device's pending request list. */
2568 list_del_init(&request->dev_node);
2569 break;
6f231dda 2570
f1f52e75
DW		 2571 case isci_perform_aborted_io_completion:
2572 /* No notification to libsas because this request is
2573 * already in the abort path.
2574 */
2575 dev_warn(&host->pdev->dev,
2576 "%s: Aborted - task = %p, response=%d (%d), status=%d (%d)\n",
2577 __func__,
2578 task,
2579 task->task_status.resp, response,
2580 task->task_status.stat, status);
6f231dda 2581
f1f52e75
DW		 2582 /* Wake up whatever process was waiting for this
2583 * request to complete.
2584 */
2585 WARN_ON(request->io_request_completion == NULL);
6f231dda 2586
f1f52e75
DW		 2587 if (request->io_request_completion != NULL) {
2588
2589 /* Signal whoever is waiting that this
2590 * request is complete.
2591 */
2592 complete(request->io_request_completion);
2593 }
2594 break;
2595
2596 case isci_perform_error_io_completion:
2597 /* Use sas_task_abort */
2598 dev_warn(&host->pdev->dev,
2599 "%s: Error - task = %p, response=%d (%d), status=%d (%d)\n",
2600 __func__,
2601 task,
2602 task->task_status.resp, response,
2603 task->task_status.stat, status);
2604 /* Add to the aborted list. */
2605 list_add(&request->completed_node,
2606 &host->requests_to_errorback);
2607 break;
2608
2609 default:
2610 dev_warn(&host->pdev->dev,
2611 "%s: Unknown - task = %p, response=%d (%d), status=%d (%d)\n",
2612 __func__,
2613 task,
2614 task->task_status.resp, response,
2615 task->task_status.stat, status);
2616
2617 /* Add to the error to libsas list. */
2618 list_add(&request->completed_node,
2619 &host->requests_to_errorback);
2620 break;
2621 }
2622}
2623
2624static void isci_request_io_request_complete(struct isci_host *isci_host,
2625 struct isci_request *request,
2626 enum sci_io_status completion_status)
2627{
2628 struct sas_task *task = isci_request_access_task(request);
2629 struct ssp_response_iu *resp_iu;
2630 void *resp_buf;
2631 unsigned long task_flags;
2632 struct isci_remote_device *isci_device = request->isci_device;
2633 enum service_response response = SAS_TASK_UNDELIVERED;
2634 enum exec_status status = SAS_ABORTED_TASK;
2635 enum isci_request_status request_status;
2636 enum isci_completion_selection complete_to_host
2637 = isci_perform_normal_io_completion;
2638
2639 dev_dbg(&isci_host->pdev->dev,
2640 "%s: request = %p, task = %p,\n"
2641 "task->data_dir = %d completion_status = 0x%x\n",
2642 __func__,
2643 request,
2644 task,
2645 task->data_dir,
2646 completion_status);
2647
2648 spin_lock(&request->state_lock);
2649 request_status = isci_request_get_state(request);
2650
2651 /* Decode the request status. Note that if the request has been
2652 * aborted by a task management function, we don't care
2653 * what the status is.
2654 */
2655 switch (request_status) {
2656
2657 case aborted:
2658 /* "aborted" indicates that the request was aborted by a task
2659 * management function, since once a task management request is
2660 * perfomed by the device, the request only completes because
2661 * of the subsequent driver terminate.
2662 *
2663 * Aborted also means an external thread is explicitly managing
2664 * this request, so that we do not complete it up the stack.
2665 *
2666 * The target is still there (since the TMF was successful).
2667 */
2668 request->complete_in_target = true;
2669 response = SAS_TASK_COMPLETE;
2670
2671 /* See if the device has been/is being stopped. Note
2672 * that we ignore the quiesce state, since we are
2673 * concerned about the actual device state.
2674 */
2675 if ((isci_device->status == isci_stopping)
2676 || (isci_device->status == isci_stopped)
2677 )
2678 status = SAS_DEVICE_UNKNOWN;
2679 else
2680 status = SAS_ABORTED_TASK;
2681
2682 complete_to_host = isci_perform_aborted_io_completion;
2683 /* This was an aborted request. */
2684
2685 spin_unlock(&request->state_lock);
2686 break;
2687
2688 case aborting:
2689 /* aborting means that the task management function tried and
2690 * failed to abort the request. We need to note the request
2691 * as SAS_TASK_UNDELIVERED, so that the scsi mid layer marks the
2692 * target as down.
2693 *
2694 * Aborting also means an external thread is explicitly managing
2695 * this request, so that we do not complete it up the stack.
2696 */
2697 request->complete_in_target = true;
2698 response = SAS_TASK_UNDELIVERED;
2699
2700 if ((isci_device->status == isci_stopping) ||
2701 (isci_device->status == isci_stopped))
2702 /* The device has been /is being stopped. Note that
2703 * we ignore the quiesce state, since we are
2704 * concerned about the actual device state.
2705 */
2706 status = SAS_DEVICE_UNKNOWN;
2707 else
2708 status = SAS_PHY_DOWN;
2709
2710 complete_to_host = isci_perform_aborted_io_completion;
2711
2712 /* This was an aborted request. */
2713
2714 spin_unlock(&request->state_lock);
2715 break;
2716
2717 case terminating:
2718
2719 /* This was an terminated request. This happens when
2720 * the I/O is being terminated because of an action on
2721 * the device (reset, tear down, etc.), and the I/O needs
2722 * to be completed up the stack.
2723 */
2724 request->complete_in_target = true;
2725 response = SAS_TASK_UNDELIVERED;
2726
2727 /* See if the device has been/is being stopped. Note
2728 * that we ignore the quiesce state, since we are
2729 * concerned about the actual device state.
2730 */
2731 if ((isci_device->status == isci_stopping) ||
2732 (isci_device->status == isci_stopped))
2733 status = SAS_DEVICE_UNKNOWN;
2734 else
2735 status = SAS_ABORTED_TASK;
2736
2737 complete_to_host = isci_perform_aborted_io_completion;
2738
2739 /* This was a terminated request. */
2740
2741 spin_unlock(&request->state_lock);
2742 break;
2743
77c852f3
JS		 2744 case dead:
2745 /* This was a terminated request that timed-out during the
2746 * termination process. There is no task to complete to
2747 * libsas.
2748 */
2749 complete_to_host = isci_perform_normal_io_completion;
2750 spin_unlock(&request->state_lock);
2751 break;
2752
f1f52e75
DW		 2753 default:
2754
2755 /* The request is done from an SCU HW perspective. */
2756 request->status = completed;
2757
2758 spin_unlock(&request->state_lock);
2759
2760 /* This is an active request being completed from the core. */
2761 switch (completion_status) {
2762
2763 case SCI_IO_FAILURE_RESPONSE_VALID:
2764 dev_dbg(&isci_host->pdev->dev,
2765 "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
2766 __func__,
2767 request,
2768 task);
2769
2770 if (sas_protocol_ata(task->task_proto)) {
2771 resp_buf = &request->sci.stp.rsp;
2772 isci_request_process_stp_response(task,
2773 resp_buf);
2774 } else if (SAS_PROTOCOL_SSP == task->task_proto) {
2775
2776 /* crack the iu response buffer. */
2777 resp_iu = &request->sci.ssp.rsp;
2778 isci_request_process_response_iu(task, resp_iu,
2779 &isci_host->pdev->dev);
2780
2781 } else if (SAS_PROTOCOL_SMP == task->task_proto) {
2782
2783 dev_err(&isci_host->pdev->dev,
2784 "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
2785 "SAS_PROTOCOL_SMP protocol\n",
2786 __func__);
2787
2788 } else
2789 dev_err(&isci_host->pdev->dev,
2790 "%s: unknown protocol\n", __func__);
2791
2792 /* use the task status set in the task struct by the
2793 * isci_request_process_response_iu call.
2794 */
2795 request->complete_in_target = true;
2796 response = task->task_status.resp;
2797 status = task->task_status.stat;
2798 break;
2799
2800 case SCI_IO_SUCCESS:
2801 case SCI_IO_SUCCESS_IO_DONE_EARLY:
2802
2803 response = SAS_TASK_COMPLETE;
2804 status = SAM_STAT_GOOD;
2805 request->complete_in_target = true;
2806
2807 if (task->task_proto == SAS_PROTOCOL_SMP) {
2808 void *rsp = &request->sci.smp.rsp;
2809
2810 dev_dbg(&isci_host->pdev->dev,
2811 "%s: SMP protocol completion\n",
2812 __func__);
2813
2814 sg_copy_from_buffer(
2815 &task->smp_task.smp_resp, 1,
2816 rsp, sizeof(struct smp_resp));
2817 } else if (completion_status
2818 == SCI_IO_SUCCESS_IO_DONE_EARLY) {
2819
2820 /* This was an SSP / STP / SATA transfer.
2821 * There is a possibility that less data than
2822 * the maximum was transferred.
2823 */
2824 u32 transferred_length = sci_req_tx_bytes(&request->sci);
2825
2826 task->task_status.residual
2827 = task->total_xfer_len - transferred_length;
2828
2829 /* If there were residual bytes, call this an
2830 * underrun.
2831 */
2832 if (task->task_status.residual != 0)
2833 status = SAS_DATA_UNDERRUN;
2834
2835 dev_dbg(&isci_host->pdev->dev,
2836 "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
2837 __func__,
2838 status);
2839
2840 } else
2841 dev_dbg(&isci_host->pdev->dev,
2842 "%s: SCI_IO_SUCCESS\n",
2843 __func__);
2844
2845 break;
2846
2847 case SCI_IO_FAILURE_TERMINATED:
2848 dev_dbg(&isci_host->pdev->dev,
2849 "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
2850 __func__,
2851 request,
2852 task);
2853
2854 /* The request was terminated explicitly. No handling
2855 * is needed in the SCSI error handler path.
2856 */
2857 request->complete_in_target = true;
2858 response = SAS_TASK_UNDELIVERED;
2859
2860 /* See if the device has been/is being stopped. Note
2861 * that we ignore the quiesce state, since we are
2862 * concerned about the actual device state.
2863 */
2864 if ((isci_device->status == isci_stopping) ||
2865 (isci_device->status == isci_stopped))
2866 status = SAS_DEVICE_UNKNOWN;
2867 else
2868 status = SAS_ABORTED_TASK;
2869
2870 complete_to_host = isci_perform_normal_io_completion;
2871 break;
2872
2873 case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
2874
2875 isci_request_handle_controller_specific_errors(
2876 isci_device, request, task, &response, &status,
2877 &complete_to_host);
2878
2879 break;
2880
2881 case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
2882 /* This is a special case, in that the I/O completion
2883 * is telling us that the device needs a reset.
2884 * In order for the device reset condition to be
2885 * noticed, the I/O has to be handled in the error
2886 * handler. Set the reset flag and cause the
2887 * SCSI error thread to be scheduled.
2888 */
2889 spin_lock_irqsave(&task->task_state_lock, task_flags);
2890 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
6f231dda
DW		 2891 spin_unlock_irqrestore(&task->task_state_lock, task_flags);
2892
f1f52e75
DW		 2893 /* Fail the I/O. */
2894 response = SAS_TASK_UNDELIVERED;
2895 status = SAM_STAT_TASK_ABORTED;
2896
2897 complete_to_host = isci_perform_error_io_completion;
2898 request->complete_in_target = false;
2899 break;
2900
cde76fbf
JS		 2901 case SCI_FAILURE_RETRY_REQUIRED:
2902
2903 /* Fail the I/O so it can be retried. */
2904 response = SAS_TASK_UNDELIVERED;
2905 if ((isci_device->status == isci_stopping) ||
2906 (isci_device->status == isci_stopped))
2907 status = SAS_DEVICE_UNKNOWN;
2908 else
2909 status = SAS_ABORTED_TASK;
2910
2911 complete_to_host = isci_perform_normal_io_completion;
2912 request->complete_in_target = true;
2913 break;
2914
2915
f1f52e75
DW		 2916 default:
2917 /* Catch any otherwise unhandled error codes here. */
2918 dev_warn(&isci_host->pdev->dev,
2919 "%s: invalid completion code: 0x%x - "
2920 "isci_request = %p\n",
2921 __func__, completion_status, request);
2922
2923 response = SAS_TASK_UNDELIVERED;
2924
2925 /* See if the device has been/is being stopped. Note
2926 * that we ignore the quiesce state, since we are
2927 * concerned about the actual device state.
2928 */
2929 if ((isci_device->status == isci_stopping) ||
2930 (isci_device->status == isci_stopped))
2931 status = SAS_DEVICE_UNKNOWN;
2932 else
2933 status = SAS_ABORTED_TASK;
2934
cde76fbf
JS		 2935 if (SAS_PROTOCOL_SMP == task->task_proto) {
2936 request->complete_in_target = true;
2937 complete_to_host = isci_perform_normal_io_completion;
2938 } else {
2939 request->complete_in_target = false;
2940 complete_to_host = isci_perform_error_io_completion;
2941 }
f1f52e75
DW		 2942 break;
2943 }
2944 break;
2945 }
2946
2947 isci_request_unmap_sgl(request, isci_host->pdev);
2948
2949 /* Put the completed request on the correct list */
2950 isci_task_save_for_upper_layer_completion(isci_host, request, response,
2951 status, complete_to_host
2952 );
2953
2954 /* complete the io request to the core. */
2955 scic_controller_complete_io(&isci_host->sci,
2956 &isci_device->sci,
2957 &request->sci);
2958 /* set terminated handle so it cannot be completed or
2959 * terminated again, and to cause any calls into abort
2960 * task to recognize the already completed case.
2961 */
2962 request->terminated = true;
2963
2964 isci_host_can_dequeue(isci_host, 1);
2965}
2966
9269e0e8 2967static void scic_sds_request_started_state_enter(struct sci_base_state_machine *sm)
f1f52e75 2968{
e301370a 2969 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
f139303d
DW		 2970 struct isci_request *ireq = sci_req_to_ireq(sci_req);
2971 struct domain_device *dev = sci_dev_to_domain(sci_req->target_device);
c72086e3
DW		 2972 struct sas_task *task;
2973
2974 /* XXX as hch said always creating an internal sas_task for tmf
2975 * requests would simplify the driver
2976 */
2977 task = ireq->ttype == io_task ? isci_request_access_task(ireq) : NULL;
f1f52e75 2978
5dec6f4e
DW		 2979 /* all unaccelerated request types (non ssp or ncq) handled with
2980 * substates
f139303d 2981 */
c72086e3 2982 if (!task && dev->dev_type == SAS_END_DEV) {
e301370a 2983 sci_change_state(sm, SCI_REQ_TASK_WAIT_TC_COMP);
5dec6f4e
DW		 2984 } else if (!task &&
2985 (isci_request_access_tmf(ireq)->tmf_code == isci_tmf_sata_srst_high ||
2986 isci_request_access_tmf(ireq)->tmf_code == isci_tmf_sata_srst_low)) {
e301370a 2987 sci_change_state(sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED);
c72086e3 2988 } else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
e301370a 2989 sci_change_state(sm, SCI_REQ_SMP_WAIT_RESP);
5dec6f4e
DW		 2990 } else if (task && sas_protocol_ata(task->task_proto) &&
2991 !task->ata_task.use_ncq) {
2992 u32 state;
2993
2994 if (task->data_dir == DMA_NONE)
e301370a 2995 state = SCI_REQ_STP_NON_DATA_WAIT_H2D;
5dec6f4e 2996 else if (task->ata_task.dma_xfer)
e301370a 2997 state = SCI_REQ_STP_UDMA_WAIT_TC_COMP;
5dec6f4e 2998 else /* PIO */
e301370a 2999 state = SCI_REQ_STP_PIO_WAIT_H2D;
5dec6f4e 3000
e301370a 3001 sci_change_state(sm, state);
c72086e3 3002 }
f1f52e75
DW		 3003}
3004
9269e0e8 3005static void scic_sds_request_completed_state_enter(struct sci_base_state_machine *sm)
f1f52e75 3006{
e301370a 3007 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
79e2b6b2 3008 struct scic_sds_controller *scic = sci_req->owning_controller;
f1f52e75
DW		 3009 struct isci_host *ihost = scic_to_ihost(scic);
3010 struct isci_request *ireq = sci_req_to_ireq(sci_req);
3011
f1f52e75
DW		 3012 /* Tell the SCI_USER that the IO request is complete */
3013 if (sci_req->is_task_management_request == false)
3014 isci_request_io_request_complete(ihost, ireq,
3015 sci_req->sci_status);
3016 else
3017 isci_task_request_complete(ihost, ireq, sci_req->sci_status);
3018}
3019
9269e0e8 3020static void scic_sds_request_aborting_state_enter(struct sci_base_state_machine *sm)
f1f52e75 3021{
e301370a 3022 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
f1f52e75
DW		 3023
3024 /* Setting the abort bit in the Task Context is required by the silicon. */
3025 sci_req->task_context_buffer->abort = 1;
c72086e3
DW		 3026}
3027
9269e0e8 3028static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(struct sci_base_state_machine *sm)
5dec6f4e 3029{
e301370a 3030 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
5dec6f4e 3031
79e2b6b2
DW		 3032 scic_sds_remote_device_set_working_request(sci_req->target_device,
3033 sci_req);
5dec6f4e
DW		 3034}
3035
9269e0e8 3036static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(struct sci_base_state_machine *sm)
5dec6f4e 3037{
e301370a 3038 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
5dec6f4e 3039
79e2b6b2
DW		 3040 scic_sds_remote_device_set_working_request(sci_req->target_device,
3041 sci_req);
5dec6f4e
DW		 3042}
3043
9269e0e8 3044static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(struct sci_base_state_machine *sm)
5dec6f4e 3045{
e301370a 3046 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
5dec6f4e 3047
79e2b6b2
DW		 3048 scic_sds_remote_device_set_working_request(sci_req->target_device,
3049 sci_req);
5dec6f4e
DW		 3050}
3051
9269e0e8 3052static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(struct sci_base_state_machine *sm)
5dec6f4e 3053{
e301370a 3054 struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
5dec6f4e
DW		 3055 struct scu_task_context *task_context;
3056 struct host_to_dev_fis *h2d_fis;
3057 enum sci_status status;
3058
3059 /* Clear the SRST bit */
3060 h2d_fis = &sci_req->stp.cmd;
3061 h2d_fis->control = 0;
3062
3063 /* Clear the TC control bit */
3064 task_context = scic_sds_controller_get_task_context_buffer(
3065 sci_req->owning_controller, sci_req->io_tag);
3066 task_context->control_frame = 0;
3067
3068 status = scic_controller_continue_io(sci_req);
79e2b6b2 3069 WARN_ONCE(status != SCI_SUCCESS, "isci: continue io failure\n");
5dec6f4e
DW		 3070}
3071
f1f52e75 3072static const struct sci_base_state scic_sds_request_state_table[] = {
e301370a
EN		 3073 [SCI_REQ_INIT] = { },
3074 [SCI_REQ_CONSTRUCTED] = { },
3075 [SCI_REQ_STARTED] = {
f1f52e75 3076 .enter_state = scic_sds_request_started_state_enter,
5dec6f4e 3077 },
e301370a 3078 [SCI_REQ_STP_NON_DATA_WAIT_H2D] = {
5dec6f4e
DW		 3079 .enter_state = scic_sds_stp_request_started_non_data_await_h2d_completion_enter,
3080 },
e301370a
EN		 3081 [SCI_REQ_STP_NON_DATA_WAIT_D2H] = { },
3082 [SCI_REQ_STP_PIO_WAIT_H2D] = {
5dec6f4e
DW		 3083 .enter_state = scic_sds_stp_request_started_pio_await_h2d_completion_enter,
3084 },
e301370a
EN		 3085 [SCI_REQ_STP_PIO_WAIT_FRAME] = { },
3086 [SCI_REQ_STP_PIO_DATA_IN] = { },
3087 [SCI_REQ_STP_PIO_DATA_OUT] = { },
3088 [SCI_REQ_STP_UDMA_WAIT_TC_COMP] = { },
3089 [SCI_REQ_STP_UDMA_WAIT_D2H] = { },
3090 [SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED] = {
5dec6f4e
DW		 3091 .enter_state = scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter,
3092 },
e301370a 3093 [SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG] = {
5dec6f4e
DW		 3094 .enter_state = scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter,
3095 },
e301370a
EN		 3096 [SCI_REQ_STP_SOFT_RESET_WAIT_D2H] = { },
3097 [SCI_REQ_TASK_WAIT_TC_COMP] = { },
3098 [SCI_REQ_TASK_WAIT_TC_RESP] = { },
3099 [SCI_REQ_SMP_WAIT_RESP] = { },
3100 [SCI_REQ_SMP_WAIT_TC_COMP] = { },
3101 [SCI_REQ_COMPLETED] = {
f1f52e75
DW		 3102 .enter_state = scic_sds_request_completed_state_enter,
3103 },
e301370a 3104 [SCI_REQ_ABORTING] = {
f1f52e75
DW		 3105 .enter_state = scic_sds_request_aborting_state_enter,
3106 },
e301370a 3107 [SCI_REQ_FINAL] = { },
f1f52e75
DW		 3108};
3109
e301370a
EN		 3110static void
3111scic_sds_general_request_construct(struct scic_sds_controller *scic,
3112 struct scic_sds_remote_device *sci_dev,
3113 u16 io_tag,
3114 struct scic_sds_request *sci_req)
f1f52e75 3115{
12ef6544 3116 sci_init_sm(&sci_req->sm, scic_sds_request_state_table, SCI_REQ_INIT);
f1f52e75
DW		 3117
3118 sci_req->io_tag = io_tag;
3119 sci_req->owning_controller = scic;
3120 sci_req->target_device = sci_dev;
f1f52e75
DW		 3121 sci_req->protocol = SCIC_NO_PROTOCOL;
3122 sci_req->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
3123 sci_req->device_sequence = scic_sds_remote_device_get_sequence(sci_dev);
3124
3125 sci_req->sci_status = SCI_SUCCESS;
3126 sci_req->scu_status = 0;
3127 sci_req->post_context = 0xFFFFFFFF;
3128
3129 sci_req->is_task_management_request = false;
3130
3131 if (io_tag == SCI_CONTROLLER_INVALID_IO_TAG) {
3132 sci_req->was_tag_assigned_by_user = false;
c72086e3 3133 sci_req->task_context_buffer = &sci_req->tc;
f1f52e75
DW		 3134 } else {
3135 sci_req->was_tag_assigned_by_user = true;
3136
3137 sci_req->task_context_buffer =
3138 scic_sds_controller_get_task_context_buffer(scic, io_tag);
3139 }
3140}
3141
3142static enum sci_status
3143scic_io_request_construct(struct scic_sds_controller *scic,
3144 struct scic_sds_remote_device *sci_dev,
3145 u16 io_tag, struct scic_sds_request *sci_req)
3146{
3147 struct domain_device *dev = sci_dev_to_domain(sci_dev);
3148 enum sci_status status = SCI_SUCCESS;
3149
3150 /* Build the common part of the request */
3151 scic_sds_general_request_construct(scic, sci_dev, io_tag, sci_req);
3152
c72086e3 3153 if (sci_dev->rnc.remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
f1f52e75
DW		 3154 return SCI_FAILURE_INVALID_REMOTE_DEVICE;
3155
3156 if (dev->dev_type == SAS_END_DEV)
c72086e3
DW		 3157 /* pass */;
3158 else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))
f1f52e75 3159 memset(&sci_req->stp.cmd, 0, sizeof(sci_req->stp.cmd));
c72086e3 3160 else if (dev_is_expander(dev))
f1f52e75 3161 memset(&sci_req->smp.cmd, 0, sizeof(sci_req->smp.cmd));
c72086e3
DW		 3162 else
3163 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
f1f52e75 3164
c72086e3
DW		 3165 memset(sci_req->task_context_buffer, 0,
3166 offsetof(struct scu_task_context, sgl_pair_ab));
f1f52e75
DW		 3167
3168 return status;
3169}
3170
3171enum sci_status scic_task_request_construct(struct scic_sds_controller *scic,
3172 struct scic_sds_remote_device *sci_dev,
3173 u16 io_tag, struct scic_sds_request *sci_req)
3174{
3175 struct domain_device *dev = sci_dev_to_domain(sci_dev);
3176 enum sci_status status = SCI_SUCCESS;
3177
3178 /* Build the common part of the request */
3179 scic_sds_general_request_construct(scic, sci_dev, io_tag, sci_req);
3180
c72086e3
DW		 3181 if (dev->dev_type == SAS_END_DEV ||
3182 dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
f1f52e75
DW		 3183 sci_req->is_task_management_request = true;
3184 memset(sci_req->task_context_buffer, 0, sizeof(struct scu_task_context));
c72086e3
DW		 3185 } else
3186 status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
f1f52e75
DW		 3187
3188 return status;
3189}
3190
3191static enum sci_status isci_request_ssp_request_construct(
3192 struct isci_request *request)
3193{
3194 enum sci_status status;
3195
3196 dev_dbg(&request->isci_host->pdev->dev,
3197 "%s: request = %p\n",
3198 __func__,
3199 request);
3200 status = scic_io_request_construct_basic_ssp(&request->sci);
3201 return status;
3202}
3203
3204static enum sci_status isci_request_stp_request_construct(
3205 struct isci_request *request)
3206{
3207 struct sas_task *task = isci_request_access_task(request);
3208 enum sci_status status;
3209 struct host_to_dev_fis *register_fis;
3210
3211 dev_dbg(&request->isci_host->pdev->dev,
3212 "%s: request = %p\n",
3213 __func__,
3214 request);
3215
3216 /* Get the host_to_dev_fis from the core and copy
3217 * the fis from the task into it.
3218 */
3219 register_fis = isci_sata_task_to_fis_copy(task);
3220
3221 status = scic_io_request_construct_basic_sata(&request->sci);
3222
3223 /* Set the ncq tag in the fis, from the queue
3224 * command in the task.
3225 */
3226 if (isci_sata_is_task_ncq(task)) {
3227
3228 isci_sata_set_ncq_tag(
3229 register_fis,
3230 task
3231 );
3232 }
3233
3234 return status;
3235}
3236
c72086e3
DW		 3237/*
3238 * This function will fill in the SCU Task Context for a SMP request. The
3239 * following important settings are utilized: -# task_type ==
3240 * SCU_TASK_TYPE_SMP. This simply indicates that a normal request type
3241 * (i.e. non-raw frame) is being utilized to perform task management. -#
3242 * control_frame == 1. This ensures that the proper endianess is set so
3243 * that the bytes are transmitted in the right order for a smp request frame.
3244 * @sci_req: This parameter specifies the smp request object being
3245 * constructed.
3246 *
3247 */
3248static void
3249scu_smp_request_construct_task_context(struct scic_sds_request *sci_req,
77d67385 3250 ssize_t req_len)
c72086e3
DW		 3251{
3252 dma_addr_t dma_addr;
c72086e3
DW		 3253 struct scic_sds_remote_device *sci_dev;
3254 struct scic_sds_port *sci_port;
3255 struct scu_task_context *task_context;
3256 ssize_t word_cnt = sizeof(struct smp_req) / sizeof(u32);
3257
3258 /* byte swap the smp request. */
77d67385 3259 sci_swab32_cpy(&sci_req->smp.cmd, &sci_req->smp.cmd,
c72086e3
DW		 3260 word_cnt);
3261
3262 task_context = scic_sds_request_get_task_context(sci_req);
3263
c72086e3
DW		 3264 sci_dev = scic_sds_request_get_device(sci_req);
3265 sci_port = scic_sds_request_get_port(sci_req);
3266
3267 /*
3268 * Fill in the TC with the its required data
3269 * 00h
3270 */
3271 task_context->priority = 0;
3272 task_context->initiator_request = 1;
3273 task_context->connection_rate = sci_dev->connection_rate;
3274 task_context->protocol_engine_index =
3275 scic_sds_controller_get_protocol_engine_group(scic);
3276 task_context->logical_port_index = scic_sds_port_get_index(sci_port);
3277 task_context->protocol_type = SCU_TASK_CONTEXT_PROTOCOL_SMP;
3278 task_context->abort = 0;
3279 task_context->valid = SCU_TASK_CONTEXT_VALID;
3280 task_context->context_type = SCU_TASK_CONTEXT_TYPE;
3281
3282 /* 04h */
3283 task_context->remote_node_index = sci_dev->rnc.remote_node_index;
3284 task_context->command_code = 0;
3285 task_context->task_type = SCU_TASK_TYPE_SMP_REQUEST;
3286
3287 /* 08h */
3288 task_context->link_layer_control = 0;
3289 task_context->do_not_dma_ssp_good_response = 1;
3290 task_context->strict_ordering = 0;
3291 task_context->control_frame = 1;
3292 task_context->timeout_enable = 0;
3293 task_context->block_guard_enable = 0;
3294
3295 /* 0ch */
3296 task_context->address_modifier = 0;
3297
3298 /* 10h */
77d67385 3299 task_context->ssp_command_iu_length = req_len;
c72086e3
DW		 3300
3301 /* 14h */
3302 task_context->transfer_length_bytes = 0;
3303
3304 /*
3305 * 18h ~ 30h, protocol specific
3306 * since commandIU has been build by framework at this point, we just
3307 * copy the frist DWord from command IU to this location. */
3308 memcpy(&task_context->type.smp, &sci_req->smp.cmd, sizeof(u32));
3309
3310 /*
3311 * 40h
3312 * "For SMP you could program it to zero. We would prefer that way
3313 * so that done code will be consistent." - Venki
3314 */
3315 task_context->task_phase = 0;
3316
3317 if (sci_req->was_tag_assigned_by_user) {
3318 /*
3319 * Build the task context now since we have already read
3320 * the data
3321 */
3322 sci_req->post_context =
3323 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3324 (scic_sds_controller_get_protocol_engine_group(scic) <<
3325 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
3326 (scic_sds_port_get_index(sci_port) <<
3327 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
3328 scic_sds_io_tag_get_index(sci_req->io_tag));
3329 } else {
3330 /*
3331 * Build the task context now since we have already read
3332 * the data.
3333 * I/O tag index is not assigned because we have to wait
3334 * until we get a TCi.
3335 */
3336 sci_req->post_context =
3337 (SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC |
3338 (scic_sds_controller_get_protocol_engine_group(scic) <<
3339 SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
3340 (scic_sds_port_get_index(sci_port) <<
3341 SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT));
3342 }
3343
3344 /*
3345 * Copy the physical address for the command buffer to the SCU Task
3346 * Context command buffer should not contain command header.
3347 */
3348 dma_addr = scic_io_request_get_dma_addr(sci_req,
3349 ((char *) &sci_req->smp.cmd) +
3350 sizeof(u32));
3351
3352 task_context->command_iu_upper = upper_32_bits(dma_addr);
3353 task_context->command_iu_lower = lower_32_bits(dma_addr);
3354
3355 /* SMP response comes as UF, so no need to set response IU address. */
3356 task_context->response_iu_upper = 0;
3357 task_context->response_iu_lower = 0;
3358}
3359
77d67385
DJ		 3360static enum sci_status
3361scic_io_request_construct_smp(struct scic_sds_request *sci_req)
c72086e3 3362{
77d67385 3363 struct smp_req *smp_req = &sci_req->smp.cmd;
c72086e3
DW		 3364
3365 sci_req->protocol = SCIC_SMP_PROTOCOL;
3366
c72086e3
DW		 3367 /*
3368 * Look at the SMP requests' header fields; for certain SAS 1.x SMP
3369 * functions under SAS 2.0, a zero request length really indicates
77d67385
DJ		 3370 * a non-zero default length.
3371 */
c72086e3
DW		 3372 if (smp_req->req_len == 0) {
3373 switch (smp_req->func) {
3374 case SMP_DISCOVER:
3375 case SMP_REPORT_PHY_ERR_LOG:
3376 case SMP_REPORT_PHY_SATA:
3377 case SMP_REPORT_ROUTE_INFO:
3378 smp_req->req_len = 2;
3379 break;
3380 case SMP_CONF_ROUTE_INFO:
3381 case SMP_PHY_CONTROL:
3382 case SMP_PHY_TEST_FUNCTION:
3383 smp_req->req_len = 9;
3384 break;
3385 /* Default - zero is a valid default for 2.0. */
3386 }
3387 }
3388
77d67385 3389 scu_smp_request_construct_task_context(sci_req, smp_req->req_len);
c72086e3 3390
e301370a 3391 sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
c72086e3
DW		 3392
3393 return SCI_SUCCESS;
3394}
3395
f1f52e75
DW		 3396/*
3397 * isci_smp_request_build() - This function builds the smp request.
3398 * @ireq: This parameter points to the isci_request allocated in the
3399 * request construct function.
3400 *
3401 * SCI_SUCCESS on successfull completion, or specific failure code.
3402 */
3403static enum sci_status isci_smp_request_build(struct isci_request *ireq)
3404{
3405 enum sci_status status = SCI_FAILURE;
3406 struct sas_task *task = isci_request_access_task(ireq);
3407 struct scic_sds_request *sci_req = &ireq->sci;
3408
3409 dev_dbg(&ireq->isci_host->pdev->dev,
3410 "%s: request = %p\n", __func__, ireq);
3411
3412 dev_dbg(&ireq->isci_host->pdev->dev,
3413 "%s: smp_req len = %d\n",
3414 __func__,
3415 task->smp_task.smp_req.length);
3416
3417 /* copy the smp_command to the address; */
3418 sg_copy_to_buffer(&task->smp_task.smp_req, 1,
3419 &sci_req->smp.cmd,
3420 sizeof(struct smp_req));
3421
3422 status = scic_io_request_construct_smp(sci_req);
3423 if (status != SCI_SUCCESS)
3424 dev_warn(&ireq->isci_host->pdev->dev,
3425 "%s: failed with status = %d\n",
3426 __func__,
3427 status);
3428
3429 return status;
3430}
3431
3432/**
3433 * isci_io_request_build() - This function builds the io request object.
3434 * @isci_host: This parameter specifies the ISCI host object
3435 * @request: This parameter points to the isci_request object allocated in the
3436 * request construct function.
3437 * @sci_device: This parameter is the handle for the sci core's remote device
3438 * object that is the destination for this request.
3439 *
3440 * SCI_SUCCESS on successfull completion, or specific failure code.
3441 */
3442static enum sci_status isci_io_request_build(
3443 struct isci_host *isci_host,
3444 struct isci_request *request,
3445 struct isci_remote_device *isci_device)
3446{
3447 enum sci_status status = SCI_SUCCESS;
3448 struct sas_task *task = isci_request_access_task(request);
3449 struct scic_sds_remote_device *sci_device = &isci_device->sci;
3450
3451 dev_dbg(&isci_host->pdev->dev,
3452 "%s: isci_device = 0x%p; request = %p, "
3453 "num_scatter = %d\n",
3454 __func__,
3455 isci_device,
3456 request,
3457 task->num_scatter);
3458
3459 /* map the sgl addresses, if present.
3460 * libata does the mapping for sata devices
3461 * before we get the request.
3462 */
3463 if (task->num_scatter &&
3464 !sas_protocol_ata(task->task_proto) &&
3465 !(SAS_PROTOCOL_SMP & task->task_proto)) {
3466
3467 request->num_sg_entries = dma_map_sg(
3468 &isci_host->pdev->dev,
3469 task->scatter,
3470 task->num_scatter,
3471 task->data_dir
3472 );
3473
3474 if (request->num_sg_entries == 0)
3475 return SCI_FAILURE_INSUFFICIENT_RESOURCES;
3476 }
3477
3478 /* build the common request object. For now,
3479 * we will let the core allocate the IO tag.
3480 */
3481 status = scic_io_request_construct(&isci_host->sci, sci_device,
3482 SCI_CONTROLLER_INVALID_IO_TAG,
3483 &request->sci);
3484
3485 if (status != SCI_SUCCESS) {
3486 dev_warn(&isci_host->pdev->dev,
3487 "%s: failed request construct\n",
3488 __func__);
3489 return SCI_FAILURE;
3490 }
3491
3492 switch (task->task_proto) {
3493 case SAS_PROTOCOL_SMP:
3494 status = isci_smp_request_build(request);
3495 break;
3496 case SAS_PROTOCOL_SSP:
3497 status = isci_request_ssp_request_construct(request);
3498 break;
3499 case SAS_PROTOCOL_SATA:
3500 case SAS_PROTOCOL_STP:
3501 case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
3502 status = isci_request_stp_request_construct(request);
3503 break;
3504 default:
3505 dev_warn(&isci_host->pdev->dev,
3506 "%s: unknown protocol\n", __func__);
3507 return SCI_FAILURE;
3508 }
3509
3510 return SCI_SUCCESS;
3511}
3512
3513/**
3514 * isci_request_alloc_core() - This function gets the request object from the
3515 * isci_host dma cache.
3516 * @isci_host: This parameter specifies the ISCI host object
3517 * @isci_request: This parameter will contain the pointer to the new
3518 * isci_request object.
3519 * @isci_device: This parameter is the pointer to the isci remote device object
3520 * that is the destination for this request.
3521 * @gfp_flags: This parameter specifies the os allocation flags.
3522 *
3523 * SCI_SUCCESS on successfull completion, or specific failure code.
3524 */
3525static int isci_request_alloc_core(
3526 struct isci_host *isci_host,
3527 struct isci_request **isci_request,
3528 struct isci_remote_device *isci_device,
3529 gfp_t gfp_flags)
3530{
3531 int ret = 0;
3532 dma_addr_t handle;
3533 struct isci_request *request;
3534
aa145102 3535
f1f52e75
DW		 3536 /* get pointer to dma memory. This actually points
3537 * to both the isci_remote_device object and the
3538 * sci object. The isci object is at the beginning
3539 * of the memory allocated here.
3540 */
3541 request = dma_pool_alloc(isci_host->dma_pool, gfp_flags, &handle);
3542 if (!request) {
3543 dev_warn(&isci_host->pdev->dev,
3544 "%s: dma_pool_alloc returned NULL\n", __func__);
3545 return -ENOMEM;
3546 }
6f231dda 3547
f1f52e75
DW		 3548 /* initialize the request object. */
3549 spin_lock_init(&request->state_lock);
3550 request->request_daddr = handle;
3551 request->isci_host = isci_host;
3552 request->isci_device = isci_device;
3553 request->io_request_completion = NULL;
3554 request->terminated = false;
6f231dda 3555
f1f52e75 3556 request->num_sg_entries = 0;
6f231dda 3557
f1f52e75 3558 request->complete_in_target = false;
6f231dda 3559
f1f52e75
DW		 3560 INIT_LIST_HEAD(&request->completed_node);
3561 INIT_LIST_HEAD(&request->dev_node);
3562
3563 *isci_request = request;
3564 isci_request_change_state(request, allocated);
3565
3566 return ret;
3567}
3568
3569static int isci_request_alloc_io(
3570 struct isci_host *isci_host,
3571 struct sas_task *task,
3572 struct isci_request **isci_request,
3573 struct isci_remote_device *isci_device,
3574 gfp_t gfp_flags)
3575{
3576 int retval = isci_request_alloc_core(isci_host, isci_request,
3577 isci_device, gfp_flags);
3578
3579 if (!retval) {
3580 (*isci_request)->ttype_ptr.io_task_ptr = task;
3581 (*isci_request)->ttype = io_task;
3582
3583 task->lldd_task = *isci_request;
6f231dda 3584 }
f1f52e75
DW		 3585 return retval;
3586}
6f231dda 3587
f1f52e75
DW		 3588/**
3589 * isci_request_alloc_tmf() - This function gets the request object from the
3590 * isci_host dma cache and initializes the relevant fields as a sas_task.
3591 * @isci_host: This parameter specifies the ISCI host object
3592 * @sas_task: This parameter is the task struct from the upper layer driver.
3593 * @isci_request: This parameter will contain the pointer to the new
3594 * isci_request object.
3595 * @isci_device: This parameter is the pointer to the isci remote device object
3596 * that is the destination for this request.
3597 * @gfp_flags: This parameter specifies the os allocation flags.
3598 *
3599 * SCI_SUCCESS on successfull completion, or specific failure code.
3600 */
3601int isci_request_alloc_tmf(
3602 struct isci_host *isci_host,
3603 struct isci_tmf *isci_tmf,
3604 struct isci_request **isci_request,
3605 struct isci_remote_device *isci_device,
3606 gfp_t gfp_flags)
3607{
3608 int retval = isci_request_alloc_core(isci_host, isci_request,
3609 isci_device, gfp_flags);
6f231dda 3610
f1f52e75 3611 if (!retval) {
6f231dda 3612
f1f52e75
DW		 3613 (*isci_request)->ttype_ptr.tmf_task_ptr = isci_tmf;
3614 (*isci_request)->ttype = tmf_task;
3615 }
3616 return retval;
3617}
3618
3619/**
3620 * isci_request_execute() - This function allocates the isci_request object,
3621 * all fills in some common fields.
3622 * @isci_host: This parameter specifies the ISCI host object
3623 * @sas_task: This parameter is the task struct from the upper layer driver.
3624 * @isci_request: This parameter will contain the pointer to the new
3625 * isci_request object.
3626 * @gfp_flags: This parameter specifies the os allocation flags.
3627 *
3628 * SCI_SUCCESS on successfull completion, or specific failure code.
3629 */
3630int isci_request_execute(
3631 struct isci_host *isci_host,
3632 struct sas_task *task,
3633 struct isci_request **isci_request,
3634 gfp_t gfp_flags)
3635{
3636 int ret = 0;
3637 struct scic_sds_remote_device *sci_device;
3638 enum sci_status status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
3639 struct isci_remote_device *isci_device;
3640 struct isci_request *request;
3641 unsigned long flags;
3642
3643 isci_device = task->dev->lldd_dev;
3644 sci_device = &isci_device->sci;
3645
3646 /* do common allocation and init of request object. */
3647 ret = isci_request_alloc_io(
3648 isci_host,
3649 task,
3650 &request,
3651 isci_device,
3652 gfp_flags
3653 );
3654
3655 if (ret)
3656 goto out;
3657
3658 status = isci_io_request_build(isci_host, request, isci_device);
3659 if (status != SCI_SUCCESS) {
3660 dev_warn(&isci_host->pdev->dev,
3661 "%s: request_construct failed - status = 0x%x\n",
3662 __func__,
3663 status);
3664 goto out;
3665 }
3666
3667 spin_lock_irqsave(&isci_host->scic_lock, flags);
3668
3669 /* send the request, let the core assign the IO TAG. */
3670 status = scic_controller_start_io(&isci_host->sci, sci_device,
3671 &request->sci,
3672 SCI_CONTROLLER_INVALID_IO_TAG);
3673 if (status != SCI_SUCCESS &&
3674 status != SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
3675 dev_warn(&isci_host->pdev->dev,
3676 "%s: failed request start (0x%x)\n",
3677 __func__, status);
3678 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
3679 goto out;
3680 }
3681
3682 /* Either I/O started OK, or the core has signaled that
3683 * the device needs a target reset.
3684 *
3685 * In either case, hold onto the I/O for later.
3686 *
3687 * Update it's status and add it to the list in the
3688 * remote device object.
6f231dda 3689 */
f1f52e75 3690 list_add(&request->dev_node, &isci_device->reqs_in_process);
6f231dda 3691
f1f52e75
DW		 3692 if (status == SCI_SUCCESS) {
3693 /* Save the tag for possible task mgmt later. */
3694 request->io_tag = request->sci.io_tag;
f53a3a32 3695 isci_request_change_state(request, started);
f1f52e75
DW		 3696 } else {
3697 /* The request did not really start in the
3698 * hardware, so clear the request handle
3699 * here so no terminations will be done.
3700 */
3701 request->terminated = true;
f53a3a32 3702 isci_request_change_state(request, completed);
f1f52e75
DW		 3703 }
3704 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
3705
3706 if (status ==
3707 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
3708 /* Signal libsas that we need the SCSI error
3709 * handler thread to work on this I/O and that
3710 * we want a device reset.
3711 */
3712 spin_lock_irqsave(&task->task_state_lock, flags);
3713 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
3714 spin_unlock_irqrestore(&task->task_state_lock, flags);
3715
3716 /* Cause this task to be scheduled in the SCSI error
3717 * handler thread.
3718 */
3719 isci_execpath_callback(isci_host, task,
3720 sas_task_abort);
3721
3722 /* Change the status, since we are holding
3723 * the I/O until it is managed by the SCSI
3724 * error handler.
3725 */
3726 status = SCI_SUCCESS;
3727 }
3728
3729 out:
3730 if (status != SCI_SUCCESS) {
3731 /* release dma memory on failure. */
3732 isci_request_free(isci_host, request);
3733 request = NULL;
3734 ret = SCI_FAILURE;
3735 }
3736
3737 *isci_request = request;
3738 return ret;
6f231dda 3739}
Linux kernel - Deliverables
This page took 0.226812 seconds and 5 git commands to generate.