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#include <scsi/sas.h>
56#include <linux/bitops.h>
57#include "isci.h"
58#include "port.h"
59#include "remote_device.h"
60#include "request.h"
61#include "remote_node_context.h"
62#include "scu_event_codes.h"
63#include "task.h"
64
65#undef C
66#define C(a) (#a)
67const char *dev_state_name(enum sci_remote_device_states state)
68{
69 static const char * const strings[] = REMOTE_DEV_STATES;
70
71 return strings[state];
72}
73#undef C
74
75enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
76 enum sci_remote_node_suspension_reasons reason)
77{
78 return sci_remote_node_context_suspend(&idev->rnc, reason,
79 SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT);
80}
81
82
83
84
85
86
87
88
89
90static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
91{
92 dev_dbg(&ihost->pdev->dev,
93 "%s: idev = %p\n", __func__, idev);
94
95 clear_bit(IDEV_IO_NCQERROR, &idev->flags);
96 set_bit(IDEV_IO_READY, &idev->flags);
97 if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
98 wake_up(&ihost->eventq);
99}
100
101static enum sci_status sci_remote_device_terminate_req(
102 struct isci_host *ihost,
103 struct isci_remote_device *idev,
104 int check_abort,
105 struct isci_request *ireq)
106{
107 if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
108 (ireq->target_device != idev) ||
109 (check_abort && !test_bit(IREQ_PENDING_ABORT, &ireq->flags)))
110 return SCI_SUCCESS;
111
112 dev_dbg(&ihost->pdev->dev,
113 "%s: idev=%p; flags=%lx; req=%p; req target=%p\n",
114 __func__, idev, idev->flags, ireq, ireq->target_device);
115
116 set_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
117
118 return sci_controller_terminate_request(ihost, idev, ireq);
119}
120
121static enum sci_status sci_remote_device_terminate_reqs_checkabort(
122 struct isci_remote_device *idev,
123 int chk)
124{
125 struct isci_host *ihost = idev->owning_port->owning_controller;
126 enum sci_status status = SCI_SUCCESS;
127 u32 i;
128
129 for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
130 struct isci_request *ireq = ihost->reqs[i];
131 enum sci_status s;
132
133 s = sci_remote_device_terminate_req(ihost, idev, chk, ireq);
134 if (s != SCI_SUCCESS)
135 status = s;
136 }
137 return status;
138}
139
140static bool isci_compare_suspendcount(
141 struct isci_remote_device *idev,
142 u32 localcount)
143{
144 smp_rmb();
145
146
147
148
149 return (localcount != idev->rnc.suspend_count)
150 || sci_remote_node_context_is_being_destroyed(&idev->rnc);
151}
152
153static bool isci_check_reqterm(
154 struct isci_host *ihost,
155 struct isci_remote_device *idev,
156 struct isci_request *ireq,
157 u32 localcount)
158{
159 unsigned long flags;
160 bool res;
161
162 spin_lock_irqsave(&ihost->scic_lock, flags);
163 res = isci_compare_suspendcount(idev, localcount)
164 && !test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
165 spin_unlock_irqrestore(&ihost->scic_lock, flags);
166
167 return res;
168}
169
170static bool isci_check_devempty(
171 struct isci_host *ihost,
172 struct isci_remote_device *idev,
173 u32 localcount)
174{
175 unsigned long flags;
176 bool res;
177
178 spin_lock_irqsave(&ihost->scic_lock, flags);
179 res = isci_compare_suspendcount(idev, localcount)
180 && idev->started_request_count == 0;
181 spin_unlock_irqrestore(&ihost->scic_lock, flags);
182
183 return res;
184}
185
186enum sci_status isci_remote_device_terminate_requests(
187 struct isci_host *ihost,
188 struct isci_remote_device *idev,
189 struct isci_request *ireq)
190{
191 enum sci_status status = SCI_SUCCESS;
192 unsigned long flags;
193 u32 rnc_suspend_count;
194
195 spin_lock_irqsave(&ihost->scic_lock, flags);
196
197 if (isci_get_device(idev) == NULL) {
198 dev_dbg(&ihost->pdev->dev, "%s: failed isci_get_device(idev=%p)\n",
199 __func__, idev);
200 spin_unlock_irqrestore(&ihost->scic_lock, flags);
201 status = SCI_FAILURE;
202 } else {
203
204 smp_rmb();
205 rnc_suspend_count
206 = sci_remote_node_context_is_suspended(&idev->rnc)
207 ? 0 : idev->rnc.suspend_count;
208
209 dev_dbg(&ihost->pdev->dev,
210 "%s: idev=%p, ireq=%p; started_request_count=%d, "
211 "rnc_suspend_count=%d, rnc.suspend_count=%d"
212 "about to wait\n",
213 __func__, idev, ireq, idev->started_request_count,
214 rnc_suspend_count, idev->rnc.suspend_count);
215
216 #define MAX_SUSPEND_MSECS 10000
217 if (ireq) {
218
219 set_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
220 sci_remote_device_terminate_req(ihost, idev, 0, ireq);
221 spin_unlock_irqrestore(&ihost->scic_lock, flags);
222 if (!wait_event_timeout(ihost->eventq,
223 isci_check_reqterm(ihost, idev, ireq,
224 rnc_suspend_count),
225 msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
226
227 dev_warn(&ihost->pdev->dev, "%s host%d timeout single\n",
228 __func__, ihost->id);
229 dev_dbg(&ihost->pdev->dev,
230 "%s: ******* Timeout waiting for "
231 "suspend; idev=%p, current state %s; "
232 "started_request_count=%d, flags=%lx\n\t"
233 "rnc_suspend_count=%d, rnc.suspend_count=%d "
234 "RNC: current state %s, current "
235 "suspend_type %x dest state %d;\n"
236 "ireq=%p, ireq->flags = %lx\n",
237 __func__, idev,
238 dev_state_name(idev->sm.current_state_id),
239 idev->started_request_count, idev->flags,
240 rnc_suspend_count, idev->rnc.suspend_count,
241 rnc_state_name(idev->rnc.sm.current_state_id),
242 idev->rnc.suspend_type,
243 idev->rnc.destination_state,
244 ireq, ireq->flags);
245 }
246 spin_lock_irqsave(&ihost->scic_lock, flags);
247 clear_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
248 if (!test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
249 isci_free_tag(ihost, ireq->io_tag);
250 spin_unlock_irqrestore(&ihost->scic_lock, flags);
251 } else {
252
253 sci_remote_device_terminate_requests(idev);
254 spin_unlock_irqrestore(&ihost->scic_lock, flags);
255 if (!wait_event_timeout(ihost->eventq,
256 isci_check_devempty(ihost, idev,
257 rnc_suspend_count),
258 msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
259
260 dev_warn(&ihost->pdev->dev, "%s host%d timeout all\n",
261 __func__, ihost->id);
262 dev_dbg(&ihost->pdev->dev,
263 "%s: ******* Timeout waiting for "
264 "suspend; idev=%p, current state %s; "
265 "started_request_count=%d, flags=%lx\n\t"
266 "rnc_suspend_count=%d, "
267 "RNC: current state %s, "
268 "rnc.suspend_count=%d, current "
269 "suspend_type %x dest state %d\n",
270 __func__, idev,
271 dev_state_name(idev->sm.current_state_id),
272 idev->started_request_count, idev->flags,
273 rnc_suspend_count,
274 rnc_state_name(idev->rnc.sm.current_state_id),
275 idev->rnc.suspend_count,
276 idev->rnc.suspend_type,
277 idev->rnc.destination_state);
278 }
279 }
280 dev_dbg(&ihost->pdev->dev, "%s: idev=%p, wait done\n",
281 __func__, idev);
282 isci_put_device(idev);
283 }
284 return status;
285}
286
287
288
289
290
291
292
293
294
295
296
297static void isci_remote_device_not_ready(struct isci_host *ihost,
298 struct isci_remote_device *idev,
299 u32 reason)
300{
301 dev_dbg(&ihost->pdev->dev,
302 "%s: isci_device = %p; reason = %d\n", __func__, idev, reason);
303
304 switch (reason) {
305 case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
306 set_bit(IDEV_IO_NCQERROR, &idev->flags);
307
308
309 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
310
311
312 sci_remote_device_terminate_requests(idev);
313
314 fallthrough;
315 default:
316 clear_bit(IDEV_IO_READY, &idev->flags);
317 break;
318 }
319}
320
321
322
323
324static void rnc_destruct_done(void *_dev)
325{
326 struct isci_remote_device *idev = _dev;
327
328 BUG_ON(idev->started_request_count != 0);
329 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
330}
331
332enum sci_status sci_remote_device_terminate_requests(
333 struct isci_remote_device *idev)
334{
335 return sci_remote_device_terminate_reqs_checkabort(idev, 0);
336}
337
338enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
339 u32 timeout)
340{
341 struct sci_base_state_machine *sm = &idev->sm;
342 enum sci_remote_device_states state = sm->current_state_id;
343
344 switch (state) {
345 case SCI_DEV_INITIAL:
346 case SCI_DEV_FAILED:
347 case SCI_DEV_FINAL:
348 default:
349 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
350 __func__, dev_state_name(state));
351 return SCI_FAILURE_INVALID_STATE;
352 case SCI_DEV_STOPPED:
353 return SCI_SUCCESS;
354 case SCI_DEV_STARTING:
355
356 BUG_ON(idev->started_request_count != 0);
357 sci_remote_node_context_destruct(&idev->rnc,
358 rnc_destruct_done, idev);
359
360
361
362 sci_change_state(sm, SCI_DEV_STOPPING);
363 return SCI_SUCCESS;
364 case SCI_DEV_READY:
365 case SCI_STP_DEV_IDLE:
366 case SCI_STP_DEV_CMD:
367 case SCI_STP_DEV_NCQ:
368 case SCI_STP_DEV_NCQ_ERROR:
369 case SCI_STP_DEV_AWAIT_RESET:
370 case SCI_SMP_DEV_IDLE:
371 case SCI_SMP_DEV_CMD:
372 sci_change_state(sm, SCI_DEV_STOPPING);
373 if (idev->started_request_count == 0)
374 sci_remote_node_context_destruct(&idev->rnc,
375 rnc_destruct_done,
376 idev);
377 else {
378 sci_remote_device_suspend(
379 idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
380 sci_remote_device_terminate_requests(idev);
381 }
382 return SCI_SUCCESS;
383 case SCI_DEV_STOPPING:
384
385
386
387
388 return sci_remote_device_terminate_requests(idev);
389 case SCI_DEV_RESETTING:
390 sci_change_state(sm, SCI_DEV_STOPPING);
391 return SCI_SUCCESS;
392 }
393}
394
395enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
396{
397 struct sci_base_state_machine *sm = &idev->sm;
398 enum sci_remote_device_states state = sm->current_state_id;
399
400 switch (state) {
401 case SCI_DEV_INITIAL:
402 case SCI_DEV_STOPPED:
403 case SCI_DEV_STARTING:
404 case SCI_SMP_DEV_IDLE:
405 case SCI_SMP_DEV_CMD:
406 case SCI_DEV_STOPPING:
407 case SCI_DEV_FAILED:
408 case SCI_DEV_RESETTING:
409 case SCI_DEV_FINAL:
410 default:
411 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
412 __func__, dev_state_name(state));
413 return SCI_FAILURE_INVALID_STATE;
414 case SCI_DEV_READY:
415 case SCI_STP_DEV_IDLE:
416 case SCI_STP_DEV_CMD:
417 case SCI_STP_DEV_NCQ:
418 case SCI_STP_DEV_NCQ_ERROR:
419 case SCI_STP_DEV_AWAIT_RESET:
420 sci_change_state(sm, SCI_DEV_RESETTING);
421 return SCI_SUCCESS;
422 }
423}
424
425enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev)
426{
427 struct sci_base_state_machine *sm = &idev->sm;
428 enum sci_remote_device_states state = sm->current_state_id;
429
430 if (state != SCI_DEV_RESETTING) {
431 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
432 __func__, dev_state_name(state));
433 return SCI_FAILURE_INVALID_STATE;
434 }
435
436 sci_change_state(sm, SCI_DEV_READY);
437 return SCI_SUCCESS;
438}
439
440enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
441 u32 frame_index)
442{
443 struct sci_base_state_machine *sm = &idev->sm;
444 enum sci_remote_device_states state = sm->current_state_id;
445 struct isci_host *ihost = idev->owning_port->owning_controller;
446 enum sci_status status;
447
448 switch (state) {
449 case SCI_DEV_INITIAL:
450 case SCI_DEV_STOPPED:
451 case SCI_DEV_STARTING:
452 case SCI_STP_DEV_IDLE:
453 case SCI_SMP_DEV_IDLE:
454 case SCI_DEV_FINAL:
455 default:
456 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
457 __func__, dev_state_name(state));
458
459 sci_controller_release_frame(ihost, frame_index);
460 return SCI_FAILURE_INVALID_STATE;
461 case SCI_DEV_READY:
462 case SCI_STP_DEV_NCQ_ERROR:
463 case SCI_STP_DEV_AWAIT_RESET:
464 case SCI_DEV_STOPPING:
465 case SCI_DEV_FAILED:
466 case SCI_DEV_RESETTING: {
467 struct isci_request *ireq;
468 struct ssp_frame_hdr hdr;
469 void *frame_header;
470 ssize_t word_cnt;
471
472 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
473 frame_index,
474 &frame_header);
475 if (status != SCI_SUCCESS)
476 return status;
477
478 word_cnt = sizeof(hdr) / sizeof(u32);
479 sci_swab32_cpy(&hdr, frame_header, word_cnt);
480
481 ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag));
482 if (ireq && ireq->target_device == idev) {
483
484 status = sci_io_request_frame_handler(ireq, frame_index);
485 } else {
486
487
488
489 sci_controller_release_frame(ihost, frame_index);
490 }
491 break;
492 }
493 case SCI_STP_DEV_NCQ: {
494 struct dev_to_host_fis *hdr;
495
496 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
497 frame_index,
498 (void **)&hdr);
499 if (status != SCI_SUCCESS)
500 return status;
501
502 if (hdr->fis_type == FIS_SETDEVBITS &&
503 (hdr->status & ATA_ERR)) {
504 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
505
506
507 sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
508 } else if (hdr->fis_type == FIS_REGD2H &&
509 (hdr->status & ATA_ERR)) {
510
511
512
513
514 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
515 sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
516 } else
517 status = SCI_FAILURE;
518
519 sci_controller_release_frame(ihost, frame_index);
520 break;
521 }
522 case SCI_STP_DEV_CMD:
523 case SCI_SMP_DEV_CMD:
524
525
526
527
528 status = sci_io_request_frame_handler(idev->working_request, frame_index);
529 break;
530 }
531
532 return status;
533}
534
535static bool is_remote_device_ready(struct isci_remote_device *idev)
536{
537
538 struct sci_base_state_machine *sm = &idev->sm;
539 enum sci_remote_device_states state = sm->current_state_id;
540
541 switch (state) {
542 case SCI_DEV_READY:
543 case SCI_STP_DEV_IDLE:
544 case SCI_STP_DEV_CMD:
545 case SCI_STP_DEV_NCQ:
546 case SCI_STP_DEV_NCQ_ERROR:
547 case SCI_STP_DEV_AWAIT_RESET:
548 case SCI_SMP_DEV_IDLE:
549 case SCI_SMP_DEV_CMD:
550 return true;
551 default:
552 return false;
553 }
554}
555
556
557
558
559
560static void atapi_remote_device_resume_done(void *_dev)
561{
562 struct isci_remote_device *idev = _dev;
563 struct isci_request *ireq = idev->working_request;
564
565 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
566}
567
568enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
569 u32 event_code)
570{
571 enum sci_status status;
572 struct sci_base_state_machine *sm = &idev->sm;
573 enum sci_remote_device_states state = sm->current_state_id;
574
575 switch (scu_get_event_type(event_code)) {
576 case SCU_EVENT_TYPE_RNC_OPS_MISC:
577 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
578 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
579 status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
580 break;
581 case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
582 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
583 status = SCI_SUCCESS;
584
585
586 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
587
588 dev_dbg(scirdev_to_dev(idev),
589 "%s: device: %p event code: %x: %s\n",
590 __func__, idev, event_code,
591 is_remote_device_ready(idev)
592 ? "I_T_Nexus_Timeout event"
593 : "I_T_Nexus_Timeout event in wrong state");
594
595 break;
596 }
597 fallthrough;
598 default:
599 dev_dbg(scirdev_to_dev(idev),
600 "%s: device: %p event code: %x: %s\n",
601 __func__, idev, event_code,
602 is_remote_device_ready(idev)
603 ? "unexpected event"
604 : "unexpected event in wrong state");
605 status = SCI_FAILURE_INVALID_STATE;
606 break;
607 }
608
609 if (status != SCI_SUCCESS)
610 return status;
611
612
613
614
615
616 if (state == SCI_STP_DEV_ATAPI_ERROR) {
617
618 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
619 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
620 return sci_remote_node_context_resume(&idev->rnc,
621 atapi_remote_device_resume_done,
622 idev);
623 }
624 }
625
626 if (state == SCI_STP_DEV_IDLE) {
627
628
629
630
631 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
632 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
633 status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
634 }
635
636 return status;
637}
638
639static void sci_remote_device_start_request(struct isci_remote_device *idev,
640 struct isci_request *ireq,
641 enum sci_status status)
642{
643 struct isci_port *iport = idev->owning_port;
644
645
646 if (status != SCI_SUCCESS)
647 sci_port_complete_io(iport, idev, ireq);
648 else {
649 kref_get(&idev->kref);
650 idev->started_request_count++;
651 }
652}
653
654enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
655 struct isci_remote_device *idev,
656 struct isci_request *ireq)
657{
658 struct sci_base_state_machine *sm = &idev->sm;
659 enum sci_remote_device_states state = sm->current_state_id;
660 struct isci_port *iport = idev->owning_port;
661 enum sci_status status;
662
663 switch (state) {
664 case SCI_DEV_INITIAL:
665 case SCI_DEV_STOPPED:
666 case SCI_DEV_STARTING:
667 case SCI_STP_DEV_NCQ_ERROR:
668 case SCI_DEV_STOPPING:
669 case SCI_DEV_FAILED:
670 case SCI_DEV_RESETTING:
671 case SCI_DEV_FINAL:
672 default:
673 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
674 __func__, dev_state_name(state));
675 return SCI_FAILURE_INVALID_STATE;
676 case SCI_DEV_READY:
677
678
679
680
681
682 status = sci_port_start_io(iport, idev, ireq);
683 if (status != SCI_SUCCESS)
684 return status;
685
686 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
687 if (status != SCI_SUCCESS)
688 break;
689
690 status = sci_request_start(ireq);
691 break;
692 case SCI_STP_DEV_IDLE: {
693
694
695
696
697
698
699
700
701 enum sci_remote_device_states new_state;
702 struct sas_task *task = isci_request_access_task(ireq);
703
704 status = sci_port_start_io(iport, idev, ireq);
705 if (status != SCI_SUCCESS)
706 return status;
707
708 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
709 if (status != SCI_SUCCESS)
710 break;
711
712 status = sci_request_start(ireq);
713 if (status != SCI_SUCCESS)
714 break;
715
716 if (task->ata_task.use_ncq)
717 new_state = SCI_STP_DEV_NCQ;
718 else {
719 idev->working_request = ireq;
720 new_state = SCI_STP_DEV_CMD;
721 }
722 sci_change_state(sm, new_state);
723 break;
724 }
725 case SCI_STP_DEV_NCQ: {
726 struct sas_task *task = isci_request_access_task(ireq);
727
728 if (task->ata_task.use_ncq) {
729 status = sci_port_start_io(iport, idev, ireq);
730 if (status != SCI_SUCCESS)
731 return status;
732
733 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
734 if (status != SCI_SUCCESS)
735 break;
736
737 status = sci_request_start(ireq);
738 } else
739 return SCI_FAILURE_INVALID_STATE;
740 break;
741 }
742 case SCI_STP_DEV_AWAIT_RESET:
743 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
744 case SCI_SMP_DEV_IDLE:
745 status = sci_port_start_io(iport, idev, ireq);
746 if (status != SCI_SUCCESS)
747 return status;
748
749 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
750 if (status != SCI_SUCCESS)
751 break;
752
753 status = sci_request_start(ireq);
754 if (status != SCI_SUCCESS)
755 break;
756
757 idev->working_request = ireq;
758 sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
759 break;
760 case SCI_STP_DEV_CMD:
761 case SCI_SMP_DEV_CMD:
762
763
764
765 return SCI_FAILURE_INVALID_STATE;
766 }
767
768 sci_remote_device_start_request(idev, ireq, status);
769 return status;
770}
771
772static enum sci_status common_complete_io(struct isci_port *iport,
773 struct isci_remote_device *idev,
774 struct isci_request *ireq)
775{
776 enum sci_status status;
777
778 status = sci_request_complete(ireq);
779 if (status != SCI_SUCCESS)
780 return status;
781
782 status = sci_port_complete_io(iport, idev, ireq);
783 if (status != SCI_SUCCESS)
784 return status;
785
786 sci_remote_device_decrement_request_count(idev);
787 return status;
788}
789
790enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
791 struct isci_remote_device *idev,
792 struct isci_request *ireq)
793{
794 struct sci_base_state_machine *sm = &idev->sm;
795 enum sci_remote_device_states state = sm->current_state_id;
796 struct isci_port *iport = idev->owning_port;
797 enum sci_status status;
798
799 switch (state) {
800 case SCI_DEV_INITIAL:
801 case SCI_DEV_STOPPED:
802 case SCI_DEV_STARTING:
803 case SCI_STP_DEV_IDLE:
804 case SCI_SMP_DEV_IDLE:
805 case SCI_DEV_FAILED:
806 case SCI_DEV_FINAL:
807 default:
808 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
809 __func__, dev_state_name(state));
810 return SCI_FAILURE_INVALID_STATE;
811 case SCI_DEV_READY:
812 case SCI_STP_DEV_AWAIT_RESET:
813 case SCI_DEV_RESETTING:
814 status = common_complete_io(iport, idev, ireq);
815 break;
816 case SCI_STP_DEV_CMD:
817 case SCI_STP_DEV_NCQ:
818 case SCI_STP_DEV_NCQ_ERROR:
819 case SCI_STP_DEV_ATAPI_ERROR:
820 status = common_complete_io(iport, idev, ireq);
821 if (status != SCI_SUCCESS)
822 break;
823
824 if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
825
826
827
828
829
830 sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
831 } else if (idev->started_request_count == 0)
832 sci_change_state(sm, SCI_STP_DEV_IDLE);
833 break;
834 case SCI_SMP_DEV_CMD:
835 status = common_complete_io(iport, idev, ireq);
836 if (status != SCI_SUCCESS)
837 break;
838 sci_change_state(sm, SCI_SMP_DEV_IDLE);
839 break;
840 case SCI_DEV_STOPPING:
841 status = common_complete_io(iport, idev, ireq);
842 if (status != SCI_SUCCESS)
843 break;
844
845 if (idev->started_request_count == 0)
846 sci_remote_node_context_destruct(&idev->rnc,
847 rnc_destruct_done,
848 idev);
849 break;
850 }
851
852 if (status != SCI_SUCCESS)
853 dev_err(scirdev_to_dev(idev),
854 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
855 "could not complete\n", __func__, iport,
856 idev, ireq, status);
857 else
858 isci_put_device(idev);
859
860 return status;
861}
862
863static void sci_remote_device_continue_request(void *dev)
864{
865 struct isci_remote_device *idev = dev;
866
867
868 if (idev->working_request)
869 sci_controller_continue_io(idev->working_request);
870}
871
872enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
873 struct isci_remote_device *idev,
874 struct isci_request *ireq)
875{
876 struct sci_base_state_machine *sm = &idev->sm;
877 enum sci_remote_device_states state = sm->current_state_id;
878 struct isci_port *iport = idev->owning_port;
879 enum sci_status status;
880
881 switch (state) {
882 case SCI_DEV_INITIAL:
883 case SCI_DEV_STOPPED:
884 case SCI_DEV_STARTING:
885 case SCI_SMP_DEV_IDLE:
886 case SCI_SMP_DEV_CMD:
887 case SCI_DEV_STOPPING:
888 case SCI_DEV_FAILED:
889 case SCI_DEV_RESETTING:
890 case SCI_DEV_FINAL:
891 default:
892 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
893 __func__, dev_state_name(state));
894 return SCI_FAILURE_INVALID_STATE;
895 case SCI_STP_DEV_IDLE:
896 case SCI_STP_DEV_CMD:
897 case SCI_STP_DEV_NCQ:
898 case SCI_STP_DEV_NCQ_ERROR:
899 case SCI_STP_DEV_AWAIT_RESET:
900 status = sci_port_start_io(iport, idev, ireq);
901 if (status != SCI_SUCCESS)
902 return status;
903
904 status = sci_request_start(ireq);
905 if (status != SCI_SUCCESS)
906 goto out;
907
908
909
910
911
912 idev->working_request = ireq;
913 sci_change_state(sm, SCI_STP_DEV_CMD);
914
915
916
917
918
919
920
921
922 sci_remote_device_suspend(idev,
923 SCI_SW_SUSPEND_LINKHANG_DETECT);
924
925 status = sci_remote_node_context_start_task(&idev->rnc, ireq,
926 sci_remote_device_continue_request, idev);
927
928 out:
929 sci_remote_device_start_request(idev, ireq, status);
930
931
932
933
934 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
935 case SCI_DEV_READY:
936 status = sci_port_start_io(iport, idev, ireq);
937 if (status != SCI_SUCCESS)
938 return status;
939
940
941 status = sci_remote_node_context_start_task(&idev->rnc, ireq,
942 NULL, NULL);
943 if (status != SCI_SUCCESS)
944 break;
945
946 status = sci_request_start(ireq);
947 break;
948 }
949 sci_remote_device_start_request(idev, ireq, status);
950
951 return status;
952}
953
954void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
955{
956 struct isci_port *iport = idev->owning_port;
957 u32 context;
958
959 context = request |
960 (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
961 (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
962 idev->rnc.remote_node_index;
963
964 sci_controller_post_request(iport->owning_controller, context);
965}
966
967
968
969
970
971static void remote_device_resume_done(void *_dev)
972{
973 struct isci_remote_device *idev = _dev;
974
975 if (is_remote_device_ready(idev))
976 return;
977
978
979 sci_change_state(&idev->sm, SCI_DEV_READY);
980}
981
982static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
983{
984 struct isci_remote_device *idev = _dev;
985 struct isci_host *ihost = idev->owning_port->owning_controller;
986
987
988
989
990 if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
991 isci_remote_device_ready(ihost, idev);
992}
993
994static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
995{
996 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
997
998
999 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
1000}
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
1016{
1017 struct sci_base_state_machine *sm = &idev->sm;
1018 enum sci_remote_device_states state = sm->current_state_id;
1019 struct isci_host *ihost;
1020
1021 if (state != SCI_DEV_STOPPED) {
1022 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1023 __func__, dev_state_name(state));
1024 return SCI_FAILURE_INVALID_STATE;
1025 }
1026
1027 ihost = idev->owning_port->owning_controller;
1028 sci_controller_free_remote_node_context(ihost, idev,
1029 idev->rnc.remote_node_index);
1030 idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
1031 sci_change_state(sm, SCI_DEV_FINAL);
1032
1033 return SCI_SUCCESS;
1034}
1035
1036
1037
1038
1039
1040
1041
1042static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
1043{
1044 dev_dbg(&ihost->pdev->dev,
1045 "%s: isci_device = %p\n", __func__, idev);
1046
1047
1048
1049
1050
1051 BUG_ON(idev->started_request_count > 0);
1052
1053 sci_remote_device_destruct(idev);
1054 list_del_init(&idev->node);
1055 isci_put_device(idev);
1056}
1057
1058static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
1059{
1060 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1061 struct isci_host *ihost = idev->owning_port->owning_controller;
1062 u32 prev_state;
1063
1064
1065
1066
1067 prev_state = idev->sm.previous_state_id;
1068 if (prev_state == SCI_DEV_STOPPING)
1069 isci_remote_device_deconstruct(ihost, idev);
1070
1071 sci_controller_remote_device_stopped(ihost, idev);
1072}
1073
1074static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
1075{
1076 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1077 struct isci_host *ihost = idev->owning_port->owning_controller;
1078
1079 isci_remote_device_not_ready(ihost, idev,
1080 SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
1081}
1082
1083static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
1084{
1085 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1086 struct isci_host *ihost = idev->owning_port->owning_controller;
1087 struct domain_device *dev = idev->domain_dev;
1088
1089 if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
1090 sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
1091 } else if (dev_is_expander(dev->dev_type)) {
1092 sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
1093 } else
1094 isci_remote_device_ready(ihost, idev);
1095}
1096
1097static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
1098{
1099 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1100 struct domain_device *dev = idev->domain_dev;
1101
1102 if (dev->dev_type == SAS_END_DEVICE) {
1103 struct isci_host *ihost = idev->owning_port->owning_controller;
1104
1105 isci_remote_device_not_ready(ihost, idev,
1106 SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
1107 }
1108}
1109
1110static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
1111{
1112 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1113 struct isci_host *ihost = idev->owning_port->owning_controller;
1114
1115 dev_dbg(&ihost->pdev->dev,
1116 "%s: isci_device = %p\n", __func__, idev);
1117
1118 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1119}
1120
1121static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
1122{
1123 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1124 struct isci_host *ihost = idev->owning_port->owning_controller;
1125
1126 dev_dbg(&ihost->pdev->dev,
1127 "%s: isci_device = %p\n", __func__, idev);
1128
1129 sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
1130}
1131
1132static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1133{
1134 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1135
1136 idev->working_request = NULL;
1137 if (sci_remote_node_context_is_ready(&idev->rnc)) {
1138
1139
1140
1141 sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
1142 } else {
1143 sci_remote_node_context_resume(&idev->rnc,
1144 sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
1145 idev);
1146 }
1147}
1148
1149static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1150{
1151 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1152 struct isci_host *ihost = idev->owning_port->owning_controller;
1153
1154 BUG_ON(idev->working_request == NULL);
1155
1156 isci_remote_device_not_ready(ihost, idev,
1157 SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1158}
1159
1160static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
1161{
1162 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1163 struct isci_host *ihost = idev->owning_port->owning_controller;
1164
1165 if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1166 isci_remote_device_not_ready(ihost, idev,
1167 idev->not_ready_reason);
1168}
1169
1170static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1171{
1172 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1173 struct isci_host *ihost = idev->owning_port->owning_controller;
1174
1175 isci_remote_device_ready(ihost, idev);
1176}
1177
1178static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1179{
1180 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1181 struct isci_host *ihost = idev->owning_port->owning_controller;
1182
1183 BUG_ON(idev->working_request == NULL);
1184
1185 isci_remote_device_not_ready(ihost, idev,
1186 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1187}
1188
1189static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1190{
1191 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1192
1193 idev->working_request = NULL;
1194}
1195
1196static const struct sci_base_state sci_remote_device_state_table[] = {
1197 [SCI_DEV_INITIAL] = {
1198 .enter_state = sci_remote_device_initial_state_enter,
1199 },
1200 [SCI_DEV_STOPPED] = {
1201 .enter_state = sci_remote_device_stopped_state_enter,
1202 },
1203 [SCI_DEV_STARTING] = {
1204 .enter_state = sci_remote_device_starting_state_enter,
1205 },
1206 [SCI_DEV_READY] = {
1207 .enter_state = sci_remote_device_ready_state_enter,
1208 .exit_state = sci_remote_device_ready_state_exit
1209 },
1210 [SCI_STP_DEV_IDLE] = {
1211 .enter_state = sci_stp_remote_device_ready_idle_substate_enter,
1212 },
1213 [SCI_STP_DEV_CMD] = {
1214 .enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
1215 },
1216 [SCI_STP_DEV_NCQ] = { },
1217 [SCI_STP_DEV_NCQ_ERROR] = {
1218 .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
1219 },
1220 [SCI_STP_DEV_ATAPI_ERROR] = { },
1221 [SCI_STP_DEV_AWAIT_RESET] = { },
1222 [SCI_SMP_DEV_IDLE] = {
1223 .enter_state = sci_smp_remote_device_ready_idle_substate_enter,
1224 },
1225 [SCI_SMP_DEV_CMD] = {
1226 .enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
1227 .exit_state = sci_smp_remote_device_ready_cmd_substate_exit,
1228 },
1229 [SCI_DEV_STOPPING] = { },
1230 [SCI_DEV_FAILED] = { },
1231 [SCI_DEV_RESETTING] = {
1232 .enter_state = sci_remote_device_resetting_state_enter,
1233 .exit_state = sci_remote_device_resetting_state_exit
1234 },
1235 [SCI_DEV_FINAL] = { },
1236};
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248static void sci_remote_device_construct(struct isci_port *iport,
1249 struct isci_remote_device *idev)
1250{
1251 idev->owning_port = iport;
1252 idev->started_request_count = 0;
1253
1254 sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL);
1255
1256 sci_remote_node_context_construct(&idev->rnc,
1257 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1258}
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
1275 struct isci_remote_device *idev)
1276{
1277 enum sci_status status;
1278 struct sci_port_properties properties;
1279
1280 sci_remote_device_construct(iport, idev);
1281
1282 sci_port_get_properties(iport, &properties);
1283
1284 idev->device_port_width = hweight32(properties.phy_mask);
1285
1286 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1287 idev,
1288 &idev->rnc.remote_node_index);
1289
1290 if (status != SCI_SUCCESS)
1291 return status;
1292
1293 idev->connection_rate = sci_port_get_max_allowed_speed(iport);
1294
1295 return SCI_SUCCESS;
1296}
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
1311 struct isci_remote_device *idev)
1312{
1313 struct domain_device *dev = idev->domain_dev;
1314 enum sci_status status;
1315
1316 sci_remote_device_construct(iport, idev);
1317
1318 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1319 idev,
1320 &idev->rnc.remote_node_index);
1321 if (status != SCI_SUCCESS)
1322 return status;
1323
1324
1325
1326
1327
1328
1329
1330
1331 idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
1332 dev->linkrate);
1333
1334
1335 idev->device_port_width = 1;
1336
1337 return SCI_SUCCESS;
1338}
1339
1340enum sci_status sci_remote_device_resume(
1341 struct isci_remote_device *idev,
1342 scics_sds_remote_node_context_callback cb_fn,
1343 void *cb_p)
1344{
1345 enum sci_status status;
1346
1347 status = sci_remote_node_context_resume(&idev->rnc, cb_fn, cb_p);
1348 if (status != SCI_SUCCESS)
1349 dev_dbg(scirdev_to_dev(idev), "%s: failed to resume: %d\n",
1350 __func__, status);
1351 return status;
1352}
1353
1354static void isci_remote_device_resume_from_abort_complete(void *cbparam)
1355{
1356 struct isci_remote_device *idev = cbparam;
1357 struct isci_host *ihost = idev->owning_port->owning_controller;
1358 scics_sds_remote_node_context_callback abort_resume_cb =
1359 idev->abort_resume_cb;
1360
1361 dev_dbg(scirdev_to_dev(idev), "%s: passing-along resume: %p\n",
1362 __func__, abort_resume_cb);
1363
1364 if (abort_resume_cb != NULL) {
1365 idev->abort_resume_cb = NULL;
1366 abort_resume_cb(idev->abort_resume_cbparam);
1367 }
1368 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1369 wake_up(&ihost->eventq);
1370}
1371
1372static bool isci_remote_device_test_resume_done(
1373 struct isci_host *ihost,
1374 struct isci_remote_device *idev)
1375{
1376 unsigned long flags;
1377 bool done;
1378
1379 spin_lock_irqsave(&ihost->scic_lock, flags);
1380 done = !test_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags)
1381 || test_bit(IDEV_STOP_PENDING, &idev->flags)
1382 || sci_remote_node_context_is_being_destroyed(&idev->rnc);
1383 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1384
1385 return done;
1386}
1387
1388static void isci_remote_device_wait_for_resume_from_abort(
1389 struct isci_host *ihost,
1390 struct isci_remote_device *idev)
1391{
1392 dev_dbg(&ihost->pdev->dev, "%s: starting resume wait: %p\n",
1393 __func__, idev);
1394
1395 #define MAX_RESUME_MSECS 10000
1396 if (!wait_event_timeout(ihost->eventq,
1397 isci_remote_device_test_resume_done(ihost, idev),
1398 msecs_to_jiffies(MAX_RESUME_MSECS))) {
1399
1400 dev_warn(&ihost->pdev->dev, "%s: #### Timeout waiting for "
1401 "resume: %p\n", __func__, idev);
1402 }
1403 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1404
1405 dev_dbg(&ihost->pdev->dev, "%s: resume wait done: %p\n",
1406 __func__, idev);
1407}
1408
1409enum sci_status isci_remote_device_resume_from_abort(
1410 struct isci_host *ihost,
1411 struct isci_remote_device *idev)
1412{
1413 unsigned long flags;
1414 enum sci_status status = SCI_SUCCESS;
1415 int destroyed;
1416
1417 spin_lock_irqsave(&ihost->scic_lock, flags);
1418
1419
1420
1421 idev->abort_resume_cb = idev->rnc.user_callback;
1422 idev->abort_resume_cbparam = idev->rnc.user_cookie;
1423 set_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1424 clear_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1425 destroyed = sci_remote_node_context_is_being_destroyed(&idev->rnc);
1426 if (!destroyed)
1427 status = sci_remote_device_resume(
1428 idev, isci_remote_device_resume_from_abort_complete,
1429 idev);
1430 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1431 if (!destroyed && (status == SCI_SUCCESS))
1432 isci_remote_device_wait_for_resume_from_abort(ihost, idev);
1433 else
1434 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1435
1436 return status;
1437}
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
1453 u32 timeout)
1454{
1455 struct sci_base_state_machine *sm = &idev->sm;
1456 enum sci_remote_device_states state = sm->current_state_id;
1457 enum sci_status status;
1458
1459 if (state != SCI_DEV_STOPPED) {
1460 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1461 __func__, dev_state_name(state));
1462 return SCI_FAILURE_INVALID_STATE;
1463 }
1464
1465 status = sci_remote_device_resume(idev, remote_device_resume_done,
1466 idev);
1467 if (status != SCI_SUCCESS)
1468 return status;
1469
1470 sci_change_state(sm, SCI_DEV_STARTING);
1471
1472 return SCI_SUCCESS;
1473}
1474
1475static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1476 struct isci_remote_device *idev)
1477{
1478 struct isci_host *ihost = iport->isci_host;
1479 struct domain_device *dev = idev->domain_dev;
1480 enum sci_status status;
1481
1482 if (dev->parent && dev_is_expander(dev->parent->dev_type))
1483 status = sci_remote_device_ea_construct(iport, idev);
1484 else
1485 status = sci_remote_device_da_construct(iport, idev);
1486
1487 if (status != SCI_SUCCESS) {
1488 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1489 __func__, status);
1490
1491 return status;
1492 }
1493
1494
1495 status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1496
1497 if (status != SCI_SUCCESS)
1498 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1499 status);
1500
1501 return status;
1502}
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513static struct isci_remote_device *
1514isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1515{
1516 struct isci_remote_device *idev;
1517 int i;
1518
1519 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1520 idev = &ihost->devices[i];
1521 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1522 break;
1523 }
1524
1525 if (i >= SCI_MAX_REMOTE_DEVICES) {
1526 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1527 return NULL;
1528 }
1529 if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1530 return NULL;
1531
1532 return idev;
1533}
1534
1535void isci_remote_device_release(struct kref *kref)
1536{
1537 struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
1538 struct isci_host *ihost = idev->isci_port->isci_host;
1539
1540 idev->domain_dev = NULL;
1541 idev->isci_port = NULL;
1542 clear_bit(IDEV_START_PENDING, &idev->flags);
1543 clear_bit(IDEV_STOP_PENDING, &idev->flags);
1544 clear_bit(IDEV_IO_READY, &idev->flags);
1545 clear_bit(IDEV_GONE, &idev->flags);
1546 smp_mb__before_atomic();
1547 clear_bit(IDEV_ALLOCATED, &idev->flags);
1548 wake_up(&ihost->eventq);
1549}
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1560{
1561 enum sci_status status;
1562 unsigned long flags;
1563
1564 dev_dbg(&ihost->pdev->dev,
1565 "%s: isci_device = %p\n", __func__, idev);
1566
1567 spin_lock_irqsave(&ihost->scic_lock, flags);
1568 idev->domain_dev->lldd_dev = NULL;
1569 set_bit(IDEV_GONE, &idev->flags);
1570
1571 set_bit(IDEV_STOP_PENDING, &idev->flags);
1572 status = sci_remote_device_stop(idev, 50);
1573 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1574
1575
1576 if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
1577 ;
1578 else
1579 wait_for_device_stop(ihost, idev);
1580
1581 dev_dbg(&ihost->pdev->dev,
1582 "%s: isci_device = %p, waiting done.\n", __func__, idev);
1583
1584 return status;
1585}
1586
1587
1588
1589
1590
1591
1592void isci_remote_device_gone(struct domain_device *dev)
1593{
1594 struct isci_host *ihost = dev_to_ihost(dev);
1595 struct isci_remote_device *idev = dev->lldd_dev;
1596
1597 dev_dbg(&ihost->pdev->dev,
1598 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1599 __func__, dev, idev, idev->isci_port);
1600
1601 isci_remote_device_stop(ihost, idev);
1602}
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614int isci_remote_device_found(struct domain_device *dev)
1615{
1616 struct isci_host *isci_host = dev_to_ihost(dev);
1617 struct isci_port *isci_port = dev->port->lldd_port;
1618 struct isci_remote_device *isci_device;
1619 enum sci_status status;
1620
1621 dev_dbg(&isci_host->pdev->dev,
1622 "%s: domain_device = %p\n", __func__, dev);
1623
1624 if (!isci_port)
1625 return -ENODEV;
1626
1627 isci_device = isci_remote_device_alloc(isci_host, isci_port);
1628 if (!isci_device)
1629 return -ENODEV;
1630
1631 kref_init(&isci_device->kref);
1632 INIT_LIST_HEAD(&isci_device->node);
1633
1634 spin_lock_irq(&isci_host->scic_lock);
1635 isci_device->domain_dev = dev;
1636 isci_device->isci_port = isci_port;
1637 list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1638
1639 set_bit(IDEV_START_PENDING, &isci_device->flags);
1640 status = isci_remote_device_construct(isci_port, isci_device);
1641
1642 dev_dbg(&isci_host->pdev->dev,
1643 "%s: isci_device = %p\n",
1644 __func__, isci_device);
1645
1646 if (status == SCI_SUCCESS) {
1647
1648 dev->lldd_dev = isci_device;
1649 } else
1650 isci_put_device(isci_device);
1651 spin_unlock_irq(&isci_host->scic_lock);
1652
1653
1654 wait_for_device_start(isci_host, isci_device);
1655
1656 return status == SCI_SUCCESS ? 0 : -ENODEV;
1657}
1658
1659enum sci_status isci_remote_device_suspend_terminate(
1660 struct isci_host *ihost,
1661 struct isci_remote_device *idev,
1662 struct isci_request *ireq)
1663{
1664 unsigned long flags;
1665 enum sci_status status;
1666
1667
1668 spin_lock_irqsave(&ihost->scic_lock, flags);
1669 set_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1670 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1671 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1672
1673
1674 status = isci_remote_device_terminate_requests(ihost, idev, ireq);
1675 if (status != SCI_SUCCESS)
1676 dev_dbg(&ihost->pdev->dev,
1677 "%s: isci_remote_device_terminate_requests(%p) "
1678 "returned %d!\n",
1679 __func__, idev, status);
1680
1681
1682 return status;
1683}
1684
1685int isci_remote_device_is_safe_to_abort(
1686 struct isci_remote_device *idev)
1687{
1688 return sci_remote_node_context_is_safe_to_abort(&idev->rnc);
1689}
1690
1691enum sci_status sci_remote_device_abort_requests_pending_abort(
1692 struct isci_remote_device *idev)
1693{
1694 return sci_remote_device_terminate_reqs_checkabort(idev, 1);
1695}
1696
1697enum sci_status isci_remote_device_reset_complete(
1698 struct isci_host *ihost,
1699 struct isci_remote_device *idev)
1700{
1701 unsigned long flags;
1702 enum sci_status status;
1703
1704 spin_lock_irqsave(&ihost->scic_lock, flags);
1705 status = sci_remote_device_reset_complete(idev);
1706 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1707
1708 return status;
1709}
1710
1711void isci_dev_set_hang_detection_timeout(
1712 struct isci_remote_device *idev,
1713 u32 timeout)
1714{
1715 if (dev_is_sata(idev->domain_dev)) {
1716 if (timeout) {
1717 if (test_and_set_bit(IDEV_RNC_LLHANG_ENABLED,
1718 &idev->flags))
1719 return;
1720 } else if (!test_and_clear_bit(IDEV_RNC_LLHANG_ENABLED,
1721 &idev->flags))
1722 return;
1723
1724 sci_port_set_hang_detection_timeout(idev->owning_port,
1725 timeout);
1726 }
1727}
1728