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