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