Loading...
1/*
2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
4 *
5 * GPL LICENSE SUMMARY
6 *
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
23 *
24 * BSD LICENSE
25 *
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
28 *
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
31 * are met:
32 *
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
38 * distribution.
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55#include <scsi/sas.h>
56#include "isci.h"
57#include "port.h"
58#include "remote_device.h"
59#include "request.h"
60#include "remote_node_context.h"
61#include "scu_event_codes.h"
62#include "task.h"
63
64/**
65 * isci_remote_device_not_ready() - This function is called by the ihost when
66 * the remote device is not ready. We mark the isci device as ready (not
67 * "ready_for_io") and signal the waiting proccess.
68 * @isci_host: This parameter specifies the isci host object.
69 * @isci_device: This parameter specifies the remote device
70 *
71 * sci_lock is held on entrance to this function.
72 */
73static void isci_remote_device_not_ready(struct isci_host *ihost,
74 struct isci_remote_device *idev, u32 reason)
75{
76 struct isci_request *ireq;
77
78 dev_dbg(&ihost->pdev->dev,
79 "%s: isci_device = %p\n", __func__, idev);
80
81 switch (reason) {
82 case SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED:
83 set_bit(IDEV_GONE, &idev->flags);
84 break;
85 case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
86 set_bit(IDEV_IO_NCQERROR, &idev->flags);
87
88 /* Kill all outstanding requests for the device. */
89 list_for_each_entry(ireq, &idev->reqs_in_process, dev_node) {
90
91 dev_dbg(&ihost->pdev->dev,
92 "%s: isci_device = %p request = %p\n",
93 __func__, idev, ireq);
94
95 sci_controller_terminate_request(ihost,
96 idev,
97 ireq);
98 }
99 /* Fall through into the default case... */
100 default:
101 clear_bit(IDEV_IO_READY, &idev->flags);
102 break;
103 }
104}
105
106/**
107 * isci_remote_device_ready() - This function is called by the ihost when the
108 * remote device is ready. We mark the isci device as ready and signal the
109 * waiting proccess.
110 * @ihost: our valid isci_host
111 * @idev: remote device
112 *
113 */
114static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
115{
116 dev_dbg(&ihost->pdev->dev,
117 "%s: idev = %p\n", __func__, idev);
118
119 clear_bit(IDEV_IO_NCQERROR, &idev->flags);
120 set_bit(IDEV_IO_READY, &idev->flags);
121 if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
122 wake_up(&ihost->eventq);
123}
124
125/* called once the remote node context is ready to be freed.
126 * The remote device can now report that its stop operation is complete. none
127 */
128static void rnc_destruct_done(void *_dev)
129{
130 struct isci_remote_device *idev = _dev;
131
132 BUG_ON(idev->started_request_count != 0);
133 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
134}
135
136static enum sci_status sci_remote_device_terminate_requests(struct isci_remote_device *idev)
137{
138 struct isci_host *ihost = idev->owning_port->owning_controller;
139 enum sci_status status = SCI_SUCCESS;
140 u32 i;
141
142 for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
143 struct isci_request *ireq = ihost->reqs[i];
144 enum sci_status s;
145
146 if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
147 ireq->target_device != idev)
148 continue;
149
150 s = sci_controller_terminate_request(ihost, idev, ireq);
151 if (s != SCI_SUCCESS)
152 status = s;
153 }
154
155 return status;
156}
157
158enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
159 u32 timeout)
160{
161 struct sci_base_state_machine *sm = &idev->sm;
162 enum sci_remote_device_states state = sm->current_state_id;
163
164 switch (state) {
165 case SCI_DEV_INITIAL:
166 case SCI_DEV_FAILED:
167 case SCI_DEV_FINAL:
168 default:
169 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
170 __func__, state);
171 return SCI_FAILURE_INVALID_STATE;
172 case SCI_DEV_STOPPED:
173 return SCI_SUCCESS;
174 case SCI_DEV_STARTING:
175 /* device not started so there had better be no requests */
176 BUG_ON(idev->started_request_count != 0);
177 sci_remote_node_context_destruct(&idev->rnc,
178 rnc_destruct_done, idev);
179 /* Transition to the stopping state and wait for the
180 * remote node to complete being posted and invalidated.
181 */
182 sci_change_state(sm, SCI_DEV_STOPPING);
183 return SCI_SUCCESS;
184 case SCI_DEV_READY:
185 case SCI_STP_DEV_IDLE:
186 case SCI_STP_DEV_CMD:
187 case SCI_STP_DEV_NCQ:
188 case SCI_STP_DEV_NCQ_ERROR:
189 case SCI_STP_DEV_AWAIT_RESET:
190 case SCI_SMP_DEV_IDLE:
191 case SCI_SMP_DEV_CMD:
192 sci_change_state(sm, SCI_DEV_STOPPING);
193 if (idev->started_request_count == 0) {
194 sci_remote_node_context_destruct(&idev->rnc,
195 rnc_destruct_done, idev);
196 return SCI_SUCCESS;
197 } else
198 return sci_remote_device_terminate_requests(idev);
199 break;
200 case SCI_DEV_STOPPING:
201 /* All requests should have been terminated, but if there is an
202 * attempt to stop a device already in the stopping state, then
203 * try again to terminate.
204 */
205 return sci_remote_device_terminate_requests(idev);
206 case SCI_DEV_RESETTING:
207 sci_change_state(sm, SCI_DEV_STOPPING);
208 return SCI_SUCCESS;
209 }
210}
211
212enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
213{
214 struct sci_base_state_machine *sm = &idev->sm;
215 enum sci_remote_device_states state = sm->current_state_id;
216
217 switch (state) {
218 case SCI_DEV_INITIAL:
219 case SCI_DEV_STOPPED:
220 case SCI_DEV_STARTING:
221 case SCI_SMP_DEV_IDLE:
222 case SCI_SMP_DEV_CMD:
223 case SCI_DEV_STOPPING:
224 case SCI_DEV_FAILED:
225 case SCI_DEV_RESETTING:
226 case SCI_DEV_FINAL:
227 default:
228 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
229 __func__, state);
230 return SCI_FAILURE_INVALID_STATE;
231 case SCI_DEV_READY:
232 case SCI_STP_DEV_IDLE:
233 case SCI_STP_DEV_CMD:
234 case SCI_STP_DEV_NCQ:
235 case SCI_STP_DEV_NCQ_ERROR:
236 case SCI_STP_DEV_AWAIT_RESET:
237 sci_change_state(sm, SCI_DEV_RESETTING);
238 return SCI_SUCCESS;
239 }
240}
241
242enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev)
243{
244 struct sci_base_state_machine *sm = &idev->sm;
245 enum sci_remote_device_states state = sm->current_state_id;
246
247 if (state != SCI_DEV_RESETTING) {
248 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
249 __func__, state);
250 return SCI_FAILURE_INVALID_STATE;
251 }
252
253 sci_change_state(sm, SCI_DEV_READY);
254 return SCI_SUCCESS;
255}
256
257enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
258 u32 suspend_type)
259{
260 struct sci_base_state_machine *sm = &idev->sm;
261 enum sci_remote_device_states state = sm->current_state_id;
262
263 if (state != SCI_STP_DEV_CMD) {
264 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
265 __func__, state);
266 return SCI_FAILURE_INVALID_STATE;
267 }
268
269 return sci_remote_node_context_suspend(&idev->rnc,
270 suspend_type, NULL, NULL);
271}
272
273enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
274 u32 frame_index)
275{
276 struct sci_base_state_machine *sm = &idev->sm;
277 enum sci_remote_device_states state = sm->current_state_id;
278 struct isci_host *ihost = idev->owning_port->owning_controller;
279 enum sci_status status;
280
281 switch (state) {
282 case SCI_DEV_INITIAL:
283 case SCI_DEV_STOPPED:
284 case SCI_DEV_STARTING:
285 case SCI_STP_DEV_IDLE:
286 case SCI_SMP_DEV_IDLE:
287 case SCI_DEV_FINAL:
288 default:
289 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
290 __func__, state);
291 /* Return the frame back to the controller */
292 sci_controller_release_frame(ihost, frame_index);
293 return SCI_FAILURE_INVALID_STATE;
294 case SCI_DEV_READY:
295 case SCI_STP_DEV_NCQ_ERROR:
296 case SCI_STP_DEV_AWAIT_RESET:
297 case SCI_DEV_STOPPING:
298 case SCI_DEV_FAILED:
299 case SCI_DEV_RESETTING: {
300 struct isci_request *ireq;
301 struct ssp_frame_hdr hdr;
302 void *frame_header;
303 ssize_t word_cnt;
304
305 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
306 frame_index,
307 &frame_header);
308 if (status != SCI_SUCCESS)
309 return status;
310
311 word_cnt = sizeof(hdr) / sizeof(u32);
312 sci_swab32_cpy(&hdr, frame_header, word_cnt);
313
314 ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag));
315 if (ireq && ireq->target_device == idev) {
316 /* The IO request is now in charge of releasing the frame */
317 status = sci_io_request_frame_handler(ireq, frame_index);
318 } else {
319 /* We could not map this tag to a valid IO
320 * request Just toss the frame and continue
321 */
322 sci_controller_release_frame(ihost, frame_index);
323 }
324 break;
325 }
326 case SCI_STP_DEV_NCQ: {
327 struct dev_to_host_fis *hdr;
328
329 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
330 frame_index,
331 (void **)&hdr);
332 if (status != SCI_SUCCESS)
333 return status;
334
335 if (hdr->fis_type == FIS_SETDEVBITS &&
336 (hdr->status & ATA_ERR)) {
337 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
338
339 /* TODO Check sactive and complete associated IO if any. */
340 sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
341 } else if (hdr->fis_type == FIS_REGD2H &&
342 (hdr->status & ATA_ERR)) {
343 /*
344 * Some devices return D2H FIS when an NCQ error is detected.
345 * Treat this like an SDB error FIS ready reason.
346 */
347 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
348 sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
349 } else
350 status = SCI_FAILURE;
351
352 sci_controller_release_frame(ihost, frame_index);
353 break;
354 }
355 case SCI_STP_DEV_CMD:
356 case SCI_SMP_DEV_CMD:
357 /* The device does not process any UF received from the hardware while
358 * in this state. All unsolicited frames are forwarded to the io request
359 * object.
360 */
361 status = sci_io_request_frame_handler(idev->working_request, frame_index);
362 break;
363 }
364
365 return status;
366}
367
368static bool is_remote_device_ready(struct isci_remote_device *idev)
369{
370
371 struct sci_base_state_machine *sm = &idev->sm;
372 enum sci_remote_device_states state = sm->current_state_id;
373
374 switch (state) {
375 case SCI_DEV_READY:
376 case SCI_STP_DEV_IDLE:
377 case SCI_STP_DEV_CMD:
378 case SCI_STP_DEV_NCQ:
379 case SCI_STP_DEV_NCQ_ERROR:
380 case SCI_STP_DEV_AWAIT_RESET:
381 case SCI_SMP_DEV_IDLE:
382 case SCI_SMP_DEV_CMD:
383 return true;
384 default:
385 return false;
386 }
387}
388
389enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
390 u32 event_code)
391{
392 struct sci_base_state_machine *sm = &idev->sm;
393 enum sci_remote_device_states state = sm->current_state_id;
394 enum sci_status status;
395
396 switch (scu_get_event_type(event_code)) {
397 case SCU_EVENT_TYPE_RNC_OPS_MISC:
398 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
399 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
400 status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
401 break;
402 case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
403 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
404 status = SCI_SUCCESS;
405
406 /* Suspend the associated RNC */
407 sci_remote_node_context_suspend(&idev->rnc,
408 SCI_SOFTWARE_SUSPENSION,
409 NULL, NULL);
410
411 dev_dbg(scirdev_to_dev(idev),
412 "%s: device: %p event code: %x: %s\n",
413 __func__, idev, event_code,
414 is_remote_device_ready(idev)
415 ? "I_T_Nexus_Timeout event"
416 : "I_T_Nexus_Timeout event in wrong state");
417
418 break;
419 }
420 /* Else, fall through and treat as unhandled... */
421 default:
422 dev_dbg(scirdev_to_dev(idev),
423 "%s: device: %p event code: %x: %s\n",
424 __func__, idev, event_code,
425 is_remote_device_ready(idev)
426 ? "unexpected event"
427 : "unexpected event in wrong state");
428 status = SCI_FAILURE_INVALID_STATE;
429 break;
430 }
431
432 if (status != SCI_SUCCESS)
433 return status;
434
435 if (state == SCI_STP_DEV_IDLE) {
436
437 /* We pick up suspension events to handle specifically to this
438 * state. We resume the RNC right away.
439 */
440 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
441 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
442 status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
443 }
444
445 return status;
446}
447
448static void sci_remote_device_start_request(struct isci_remote_device *idev,
449 struct isci_request *ireq,
450 enum sci_status status)
451{
452 struct isci_port *iport = idev->owning_port;
453
454 /* cleanup requests that failed after starting on the port */
455 if (status != SCI_SUCCESS)
456 sci_port_complete_io(iport, idev, ireq);
457 else {
458 kref_get(&idev->kref);
459 idev->started_request_count++;
460 }
461}
462
463enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
464 struct isci_remote_device *idev,
465 struct isci_request *ireq)
466{
467 struct sci_base_state_machine *sm = &idev->sm;
468 enum sci_remote_device_states state = sm->current_state_id;
469 struct isci_port *iport = idev->owning_port;
470 enum sci_status status;
471
472 switch (state) {
473 case SCI_DEV_INITIAL:
474 case SCI_DEV_STOPPED:
475 case SCI_DEV_STARTING:
476 case SCI_STP_DEV_NCQ_ERROR:
477 case SCI_DEV_STOPPING:
478 case SCI_DEV_FAILED:
479 case SCI_DEV_RESETTING:
480 case SCI_DEV_FINAL:
481 default:
482 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
483 __func__, state);
484 return SCI_FAILURE_INVALID_STATE;
485 case SCI_DEV_READY:
486 /* attempt to start an io request for this device object. The remote
487 * device object will issue the start request for the io and if
488 * successful it will start the request for the port object then
489 * increment its own request count.
490 */
491 status = sci_port_start_io(iport, idev, ireq);
492 if (status != SCI_SUCCESS)
493 return status;
494
495 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
496 if (status != SCI_SUCCESS)
497 break;
498
499 status = sci_request_start(ireq);
500 break;
501 case SCI_STP_DEV_IDLE: {
502 /* handle the start io operation for a sata device that is in
503 * the command idle state. - Evalute the type of IO request to
504 * be started - If its an NCQ request change to NCQ substate -
505 * If its any other command change to the CMD substate
506 *
507 * If this is a softreset we may want to have a different
508 * substate.
509 */
510 enum sci_remote_device_states new_state;
511 struct sas_task *task = isci_request_access_task(ireq);
512
513 status = sci_port_start_io(iport, idev, ireq);
514 if (status != SCI_SUCCESS)
515 return status;
516
517 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
518 if (status != SCI_SUCCESS)
519 break;
520
521 status = sci_request_start(ireq);
522 if (status != SCI_SUCCESS)
523 break;
524
525 if (task->ata_task.use_ncq)
526 new_state = SCI_STP_DEV_NCQ;
527 else {
528 idev->working_request = ireq;
529 new_state = SCI_STP_DEV_CMD;
530 }
531 sci_change_state(sm, new_state);
532 break;
533 }
534 case SCI_STP_DEV_NCQ: {
535 struct sas_task *task = isci_request_access_task(ireq);
536
537 if (task->ata_task.use_ncq) {
538 status = sci_port_start_io(iport, idev, ireq);
539 if (status != SCI_SUCCESS)
540 return status;
541
542 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
543 if (status != SCI_SUCCESS)
544 break;
545
546 status = sci_request_start(ireq);
547 } else
548 return SCI_FAILURE_INVALID_STATE;
549 break;
550 }
551 case SCI_STP_DEV_AWAIT_RESET:
552 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
553 case SCI_SMP_DEV_IDLE:
554 status = sci_port_start_io(iport, idev, ireq);
555 if (status != SCI_SUCCESS)
556 return status;
557
558 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
559 if (status != SCI_SUCCESS)
560 break;
561
562 status = sci_request_start(ireq);
563 if (status != SCI_SUCCESS)
564 break;
565
566 idev->working_request = ireq;
567 sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
568 break;
569 case SCI_STP_DEV_CMD:
570 case SCI_SMP_DEV_CMD:
571 /* device is already handling a command it can not accept new commands
572 * until this one is complete.
573 */
574 return SCI_FAILURE_INVALID_STATE;
575 }
576
577 sci_remote_device_start_request(idev, ireq, status);
578 return status;
579}
580
581static enum sci_status common_complete_io(struct isci_port *iport,
582 struct isci_remote_device *idev,
583 struct isci_request *ireq)
584{
585 enum sci_status status;
586
587 status = sci_request_complete(ireq);
588 if (status != SCI_SUCCESS)
589 return status;
590
591 status = sci_port_complete_io(iport, idev, ireq);
592 if (status != SCI_SUCCESS)
593 return status;
594
595 sci_remote_device_decrement_request_count(idev);
596 return status;
597}
598
599enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
600 struct isci_remote_device *idev,
601 struct isci_request *ireq)
602{
603 struct sci_base_state_machine *sm = &idev->sm;
604 enum sci_remote_device_states state = sm->current_state_id;
605 struct isci_port *iport = idev->owning_port;
606 enum sci_status status;
607
608 switch (state) {
609 case SCI_DEV_INITIAL:
610 case SCI_DEV_STOPPED:
611 case SCI_DEV_STARTING:
612 case SCI_STP_DEV_IDLE:
613 case SCI_SMP_DEV_IDLE:
614 case SCI_DEV_FAILED:
615 case SCI_DEV_FINAL:
616 default:
617 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
618 __func__, state);
619 return SCI_FAILURE_INVALID_STATE;
620 case SCI_DEV_READY:
621 case SCI_STP_DEV_AWAIT_RESET:
622 case SCI_DEV_RESETTING:
623 status = common_complete_io(iport, idev, ireq);
624 break;
625 case SCI_STP_DEV_CMD:
626 case SCI_STP_DEV_NCQ:
627 case SCI_STP_DEV_NCQ_ERROR:
628 status = common_complete_io(iport, idev, ireq);
629 if (status != SCI_SUCCESS)
630 break;
631
632 if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
633 /* This request causes hardware error, device needs to be Lun Reset.
634 * So here we force the state machine to IDLE state so the rest IOs
635 * can reach RNC state handler, these IOs will be completed by RNC with
636 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
637 */
638 sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
639 } else if (idev->started_request_count == 0)
640 sci_change_state(sm, SCI_STP_DEV_IDLE);
641 break;
642 case SCI_SMP_DEV_CMD:
643 status = common_complete_io(iport, idev, ireq);
644 if (status != SCI_SUCCESS)
645 break;
646 sci_change_state(sm, SCI_SMP_DEV_IDLE);
647 break;
648 case SCI_DEV_STOPPING:
649 status = common_complete_io(iport, idev, ireq);
650 if (status != SCI_SUCCESS)
651 break;
652
653 if (idev->started_request_count == 0)
654 sci_remote_node_context_destruct(&idev->rnc,
655 rnc_destruct_done,
656 idev);
657 break;
658 }
659
660 if (status != SCI_SUCCESS)
661 dev_err(scirdev_to_dev(idev),
662 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
663 "could not complete\n", __func__, iport,
664 idev, ireq, status);
665 else
666 isci_put_device(idev);
667
668 return status;
669}
670
671static void sci_remote_device_continue_request(void *dev)
672{
673 struct isci_remote_device *idev = dev;
674
675 /* we need to check if this request is still valid to continue. */
676 if (idev->working_request)
677 sci_controller_continue_io(idev->working_request);
678}
679
680enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
681 struct isci_remote_device *idev,
682 struct isci_request *ireq)
683{
684 struct sci_base_state_machine *sm = &idev->sm;
685 enum sci_remote_device_states state = sm->current_state_id;
686 struct isci_port *iport = idev->owning_port;
687 enum sci_status status;
688
689 switch (state) {
690 case SCI_DEV_INITIAL:
691 case SCI_DEV_STOPPED:
692 case SCI_DEV_STARTING:
693 case SCI_SMP_DEV_IDLE:
694 case SCI_SMP_DEV_CMD:
695 case SCI_DEV_STOPPING:
696 case SCI_DEV_FAILED:
697 case SCI_DEV_RESETTING:
698 case SCI_DEV_FINAL:
699 default:
700 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
701 __func__, state);
702 return SCI_FAILURE_INVALID_STATE;
703 case SCI_STP_DEV_IDLE:
704 case SCI_STP_DEV_CMD:
705 case SCI_STP_DEV_NCQ:
706 case SCI_STP_DEV_NCQ_ERROR:
707 case SCI_STP_DEV_AWAIT_RESET:
708 status = sci_port_start_io(iport, idev, ireq);
709 if (status != SCI_SUCCESS)
710 return status;
711
712 status = sci_remote_node_context_start_task(&idev->rnc, ireq);
713 if (status != SCI_SUCCESS)
714 goto out;
715
716 status = sci_request_start(ireq);
717 if (status != SCI_SUCCESS)
718 goto out;
719
720 /* Note: If the remote device state is not IDLE this will
721 * replace the request that probably resulted in the task
722 * management request.
723 */
724 idev->working_request = ireq;
725 sci_change_state(sm, SCI_STP_DEV_CMD);
726
727 /* The remote node context must cleanup the TCi to NCQ mapping
728 * table. The only way to do this correctly is to either write
729 * to the TLCR register or to invalidate and repost the RNC. In
730 * either case the remote node context state machine will take
731 * the correct action when the remote node context is suspended
732 * and later resumed.
733 */
734 sci_remote_node_context_suspend(&idev->rnc,
735 SCI_SOFTWARE_SUSPENSION, NULL, NULL);
736 sci_remote_node_context_resume(&idev->rnc,
737 sci_remote_device_continue_request,
738 idev);
739
740 out:
741 sci_remote_device_start_request(idev, ireq, status);
742 /* We need to let the controller start request handler know that
743 * it can't post TC yet. We will provide a callback function to
744 * post TC when RNC gets resumed.
745 */
746 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
747 case SCI_DEV_READY:
748 status = sci_port_start_io(iport, idev, ireq);
749 if (status != SCI_SUCCESS)
750 return status;
751
752 status = sci_remote_node_context_start_task(&idev->rnc, ireq);
753 if (status != SCI_SUCCESS)
754 break;
755
756 status = sci_request_start(ireq);
757 break;
758 }
759 sci_remote_device_start_request(idev, ireq, status);
760
761 return status;
762}
763
764void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
765{
766 struct isci_port *iport = idev->owning_port;
767 u32 context;
768
769 context = request |
770 (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
771 (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
772 idev->rnc.remote_node_index;
773
774 sci_controller_post_request(iport->owning_controller, context);
775}
776
777/* called once the remote node context has transisitioned to a
778 * ready state. This is the indication that the remote device object can also
779 * transition to ready.
780 */
781static void remote_device_resume_done(void *_dev)
782{
783 struct isci_remote_device *idev = _dev;
784
785 if (is_remote_device_ready(idev))
786 return;
787
788 /* go 'ready' if we are not already in a ready state */
789 sci_change_state(&idev->sm, SCI_DEV_READY);
790}
791
792static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
793{
794 struct isci_remote_device *idev = _dev;
795 struct isci_host *ihost = idev->owning_port->owning_controller;
796
797 /* For NCQ operation we do not issue a isci_remote_device_not_ready().
798 * As a result, avoid sending the ready notification.
799 */
800 if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
801 isci_remote_device_ready(ihost, idev);
802}
803
804static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
805{
806 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
807
808 /* Initial state is a transitional state to the stopped state */
809 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
810}
811
812/**
813 * sci_remote_device_destruct() - free remote node context and destruct
814 * @remote_device: This parameter specifies the remote device to be destructed.
815 *
816 * Remote device objects are a limited resource. As such, they must be
817 * protected. Thus calls to construct and destruct are mutually exclusive and
818 * non-reentrant. The return value shall indicate if the device was
819 * successfully destructed or if some failure occurred. enum sci_status This value
820 * is returned if the device is successfully destructed.
821 * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
822 * device isn't valid (e.g. it's already been destoryed, the handle isn't
823 * valid, etc.).
824 */
825static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
826{
827 struct sci_base_state_machine *sm = &idev->sm;
828 enum sci_remote_device_states state = sm->current_state_id;
829 struct isci_host *ihost;
830
831 if (state != SCI_DEV_STOPPED) {
832 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
833 __func__, state);
834 return SCI_FAILURE_INVALID_STATE;
835 }
836
837 ihost = idev->owning_port->owning_controller;
838 sci_controller_free_remote_node_context(ihost, idev,
839 idev->rnc.remote_node_index);
840 idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
841 sci_change_state(sm, SCI_DEV_FINAL);
842
843 return SCI_SUCCESS;
844}
845
846/**
847 * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
848 * @ihost: This parameter specifies the isci host object.
849 * @idev: This parameter specifies the remote device to be freed.
850 *
851 */
852static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
853{
854 dev_dbg(&ihost->pdev->dev,
855 "%s: isci_device = %p\n", __func__, idev);
856
857 /* There should not be any outstanding io's. All paths to
858 * here should go through isci_remote_device_nuke_requests.
859 * If we hit this condition, we will need a way to complete
860 * io requests in process */
861 BUG_ON(!list_empty(&idev->reqs_in_process));
862
863 sci_remote_device_destruct(idev);
864 list_del_init(&idev->node);
865 isci_put_device(idev);
866}
867
868static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
869{
870 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
871 struct isci_host *ihost = idev->owning_port->owning_controller;
872 u32 prev_state;
873
874 /* If we are entering from the stopping state let the SCI User know that
875 * the stop operation has completed.
876 */
877 prev_state = idev->sm.previous_state_id;
878 if (prev_state == SCI_DEV_STOPPING)
879 isci_remote_device_deconstruct(ihost, idev);
880
881 sci_controller_remote_device_stopped(ihost, idev);
882}
883
884static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
885{
886 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
887 struct isci_host *ihost = idev->owning_port->owning_controller;
888
889 isci_remote_device_not_ready(ihost, idev,
890 SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
891}
892
893static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
894{
895 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
896 struct isci_host *ihost = idev->owning_port->owning_controller;
897 struct domain_device *dev = idev->domain_dev;
898
899 if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
900 sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
901 } else if (dev_is_expander(dev)) {
902 sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
903 } else
904 isci_remote_device_ready(ihost, idev);
905}
906
907static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
908{
909 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
910 struct domain_device *dev = idev->domain_dev;
911
912 if (dev->dev_type == SAS_END_DEV) {
913 struct isci_host *ihost = idev->owning_port->owning_controller;
914
915 isci_remote_device_not_ready(ihost, idev,
916 SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
917 }
918}
919
920static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
921{
922 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
923
924 sci_remote_node_context_suspend(
925 &idev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
926}
927
928static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
929{
930 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
931
932 sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
933}
934
935static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
936{
937 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
938
939 idev->working_request = NULL;
940 if (sci_remote_node_context_is_ready(&idev->rnc)) {
941 /*
942 * Since the RNC is ready, it's alright to finish completion
943 * processing (e.g. signal the remote device is ready). */
944 sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
945 } else {
946 sci_remote_node_context_resume(&idev->rnc,
947 sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
948 idev);
949 }
950}
951
952static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
953{
954 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
955 struct isci_host *ihost = idev->owning_port->owning_controller;
956
957 BUG_ON(idev->working_request == NULL);
958
959 isci_remote_device_not_ready(ihost, idev,
960 SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
961}
962
963static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
964{
965 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
966 struct isci_host *ihost = idev->owning_port->owning_controller;
967
968 if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
969 isci_remote_device_not_ready(ihost, idev,
970 idev->not_ready_reason);
971}
972
973static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
974{
975 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
976 struct isci_host *ihost = idev->owning_port->owning_controller;
977
978 isci_remote_device_ready(ihost, idev);
979}
980
981static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
982{
983 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
984 struct isci_host *ihost = idev->owning_port->owning_controller;
985
986 BUG_ON(idev->working_request == NULL);
987
988 isci_remote_device_not_ready(ihost, idev,
989 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
990}
991
992static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
993{
994 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
995
996 idev->working_request = NULL;
997}
998
999static const struct sci_base_state sci_remote_device_state_table[] = {
1000 [SCI_DEV_INITIAL] = {
1001 .enter_state = sci_remote_device_initial_state_enter,
1002 },
1003 [SCI_DEV_STOPPED] = {
1004 .enter_state = sci_remote_device_stopped_state_enter,
1005 },
1006 [SCI_DEV_STARTING] = {
1007 .enter_state = sci_remote_device_starting_state_enter,
1008 },
1009 [SCI_DEV_READY] = {
1010 .enter_state = sci_remote_device_ready_state_enter,
1011 .exit_state = sci_remote_device_ready_state_exit
1012 },
1013 [SCI_STP_DEV_IDLE] = {
1014 .enter_state = sci_stp_remote_device_ready_idle_substate_enter,
1015 },
1016 [SCI_STP_DEV_CMD] = {
1017 .enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
1018 },
1019 [SCI_STP_DEV_NCQ] = { },
1020 [SCI_STP_DEV_NCQ_ERROR] = {
1021 .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
1022 },
1023 [SCI_STP_DEV_AWAIT_RESET] = { },
1024 [SCI_SMP_DEV_IDLE] = {
1025 .enter_state = sci_smp_remote_device_ready_idle_substate_enter,
1026 },
1027 [SCI_SMP_DEV_CMD] = {
1028 .enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
1029 .exit_state = sci_smp_remote_device_ready_cmd_substate_exit,
1030 },
1031 [SCI_DEV_STOPPING] = { },
1032 [SCI_DEV_FAILED] = { },
1033 [SCI_DEV_RESETTING] = {
1034 .enter_state = sci_remote_device_resetting_state_enter,
1035 .exit_state = sci_remote_device_resetting_state_exit
1036 },
1037 [SCI_DEV_FINAL] = { },
1038};
1039
1040/**
1041 * sci_remote_device_construct() - common construction
1042 * @sci_port: SAS/SATA port through which this device is accessed.
1043 * @sci_dev: remote device to construct
1044 *
1045 * This routine just performs benign initialization and does not
1046 * allocate the remote_node_context which is left to
1047 * sci_remote_device_[de]a_construct(). sci_remote_device_destruct()
1048 * frees the remote_node_context(s) for the device.
1049 */
1050static void sci_remote_device_construct(struct isci_port *iport,
1051 struct isci_remote_device *idev)
1052{
1053 idev->owning_port = iport;
1054 idev->started_request_count = 0;
1055
1056 sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL);
1057
1058 sci_remote_node_context_construct(&idev->rnc,
1059 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1060}
1061
1062/**
1063 * sci_remote_device_da_construct() - construct direct attached device.
1064 *
1065 * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1066 * the device is known to the SCI Core since it is contained in the
1067 * sci_phy object. Remote node context(s) is/are a global resource
1068 * allocated by this routine, freed by sci_remote_device_destruct().
1069 *
1070 * Returns:
1071 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1072 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1073 * sata-only controller instance.
1074 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1075 */
1076static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
1077 struct isci_remote_device *idev)
1078{
1079 enum sci_status status;
1080 struct domain_device *dev = idev->domain_dev;
1081
1082 sci_remote_device_construct(iport, idev);
1083
1084 /*
1085 * This information is request to determine how many remote node context
1086 * entries will be needed to store the remote node.
1087 */
1088 idev->is_direct_attached = true;
1089 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1090 idev,
1091 &idev->rnc.remote_node_index);
1092
1093 if (status != SCI_SUCCESS)
1094 return status;
1095
1096 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1097 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1098 /* pass */;
1099 else
1100 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1101
1102 idev->connection_rate = sci_port_get_max_allowed_speed(iport);
1103
1104 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1105 idev->device_port_width = 1;
1106
1107 return SCI_SUCCESS;
1108}
1109
1110/**
1111 * sci_remote_device_ea_construct() - construct expander attached device
1112 *
1113 * Remote node context(s) is/are a global resource allocated by this
1114 * routine, freed by sci_remote_device_destruct().
1115 *
1116 * Returns:
1117 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1118 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1119 * sata-only controller instance.
1120 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1121 */
1122static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
1123 struct isci_remote_device *idev)
1124{
1125 struct domain_device *dev = idev->domain_dev;
1126 enum sci_status status;
1127
1128 sci_remote_device_construct(iport, idev);
1129
1130 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1131 idev,
1132 &idev->rnc.remote_node_index);
1133 if (status != SCI_SUCCESS)
1134 return status;
1135
1136 if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
1137 (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
1138 /* pass */;
1139 else
1140 return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
1141
1142 /*
1143 * For SAS-2 the physical link rate is actually a logical link
1144 * rate that incorporates multiplexing. The SCU doesn't
1145 * incorporate multiplexing and for the purposes of the
1146 * connection the logical link rate is that same as the
1147 * physical. Furthermore, the SAS-2 and SAS-1.1 fields overlay
1148 * one another, so this code works for both situations. */
1149 idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
1150 dev->linkrate);
1151
1152 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1153 idev->device_port_width = 1;
1154
1155 return SCI_SUCCESS;
1156}
1157
1158/**
1159 * sci_remote_device_start() - This method will start the supplied remote
1160 * device. This method enables normal IO requests to flow through to the
1161 * remote device.
1162 * @remote_device: This parameter specifies the device to be started.
1163 * @timeout: This parameter specifies the number of milliseconds in which the
1164 * start operation should complete.
1165 *
1166 * An indication of whether the device was successfully started. SCI_SUCCESS
1167 * This value is returned if the device was successfully started.
1168 * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1169 * the device when there have been no phys added to it.
1170 */
1171static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
1172 u32 timeout)
1173{
1174 struct sci_base_state_machine *sm = &idev->sm;
1175 enum sci_remote_device_states state = sm->current_state_id;
1176 enum sci_status status;
1177
1178 if (state != SCI_DEV_STOPPED) {
1179 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
1180 __func__, state);
1181 return SCI_FAILURE_INVALID_STATE;
1182 }
1183
1184 status = sci_remote_node_context_resume(&idev->rnc,
1185 remote_device_resume_done,
1186 idev);
1187 if (status != SCI_SUCCESS)
1188 return status;
1189
1190 sci_change_state(sm, SCI_DEV_STARTING);
1191
1192 return SCI_SUCCESS;
1193}
1194
1195static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1196 struct isci_remote_device *idev)
1197{
1198 struct isci_host *ihost = iport->isci_host;
1199 struct domain_device *dev = idev->domain_dev;
1200 enum sci_status status;
1201
1202 if (dev->parent && dev_is_expander(dev->parent))
1203 status = sci_remote_device_ea_construct(iport, idev);
1204 else
1205 status = sci_remote_device_da_construct(iport, idev);
1206
1207 if (status != SCI_SUCCESS) {
1208 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1209 __func__, status);
1210
1211 return status;
1212 }
1213
1214 /* start the device. */
1215 status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1216
1217 if (status != SCI_SUCCESS)
1218 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1219 status);
1220
1221 return status;
1222}
1223
1224void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
1225{
1226 DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
1227
1228 dev_dbg(&ihost->pdev->dev,
1229 "%s: idev = %p\n", __func__, idev);
1230
1231 /* Cleanup all requests pending for this device. */
1232 isci_terminate_pending_requests(ihost, idev);
1233
1234 dev_dbg(&ihost->pdev->dev,
1235 "%s: idev = %p, done\n", __func__, idev);
1236}
1237
1238/**
1239 * This function builds the isci_remote_device when a libsas dev_found message
1240 * is received.
1241 * @isci_host: This parameter specifies the isci host object.
1242 * @port: This parameter specifies the isci_port conected to this device.
1243 *
1244 * pointer to new isci_remote_device.
1245 */
1246static struct isci_remote_device *
1247isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1248{
1249 struct isci_remote_device *idev;
1250 int i;
1251
1252 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1253 idev = &ihost->devices[i];
1254 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1255 break;
1256 }
1257
1258 if (i >= SCI_MAX_REMOTE_DEVICES) {
1259 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1260 return NULL;
1261 }
1262
1263 if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
1264 return NULL;
1265
1266 if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1267 return NULL;
1268
1269 return idev;
1270}
1271
1272void isci_remote_device_release(struct kref *kref)
1273{
1274 struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
1275 struct isci_host *ihost = idev->isci_port->isci_host;
1276
1277 idev->domain_dev = NULL;
1278 idev->isci_port = NULL;
1279 clear_bit(IDEV_START_PENDING, &idev->flags);
1280 clear_bit(IDEV_STOP_PENDING, &idev->flags);
1281 clear_bit(IDEV_IO_READY, &idev->flags);
1282 clear_bit(IDEV_GONE, &idev->flags);
1283 clear_bit(IDEV_EH, &idev->flags);
1284 smp_mb__before_clear_bit();
1285 clear_bit(IDEV_ALLOCATED, &idev->flags);
1286 wake_up(&ihost->eventq);
1287}
1288
1289/**
1290 * isci_remote_device_stop() - This function is called internally to stop the
1291 * remote device.
1292 * @isci_host: This parameter specifies the isci host object.
1293 * @isci_device: This parameter specifies the remote device.
1294 *
1295 * The status of the ihost request to stop.
1296 */
1297enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1298{
1299 enum sci_status status;
1300 unsigned long flags;
1301
1302 dev_dbg(&ihost->pdev->dev,
1303 "%s: isci_device = %p\n", __func__, idev);
1304
1305 spin_lock_irqsave(&ihost->scic_lock, flags);
1306 idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
1307 set_bit(IDEV_GONE, &idev->flags);
1308 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1309
1310 /* Kill all outstanding requests. */
1311 isci_remote_device_nuke_requests(ihost, idev);
1312
1313 set_bit(IDEV_STOP_PENDING, &idev->flags);
1314
1315 spin_lock_irqsave(&ihost->scic_lock, flags);
1316 status = sci_remote_device_stop(idev, 50);
1317 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1318
1319 /* Wait for the stop complete callback. */
1320 if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
1321 /* nothing to wait for */;
1322 else
1323 wait_for_device_stop(ihost, idev);
1324
1325 return status;
1326}
1327
1328/**
1329 * isci_remote_device_gone() - This function is called by libsas when a domain
1330 * device is removed.
1331 * @domain_device: This parameter specifies the libsas domain device.
1332 *
1333 */
1334void isci_remote_device_gone(struct domain_device *dev)
1335{
1336 struct isci_host *ihost = dev_to_ihost(dev);
1337 struct isci_remote_device *idev = dev->lldd_dev;
1338
1339 dev_dbg(&ihost->pdev->dev,
1340 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1341 __func__, dev, idev, idev->isci_port);
1342
1343 isci_remote_device_stop(ihost, idev);
1344}
1345
1346
1347/**
1348 * isci_remote_device_found() - This function is called by libsas when a remote
1349 * device is discovered. A remote device object is created and started. the
1350 * function then sleeps until the sci core device started message is
1351 * received.
1352 * @domain_device: This parameter specifies the libsas domain device.
1353 *
1354 * status, zero indicates success.
1355 */
1356int isci_remote_device_found(struct domain_device *domain_dev)
1357{
1358 struct isci_host *isci_host = dev_to_ihost(domain_dev);
1359 struct isci_port *isci_port;
1360 struct isci_phy *isci_phy;
1361 struct asd_sas_port *sas_port;
1362 struct asd_sas_phy *sas_phy;
1363 struct isci_remote_device *isci_device;
1364 enum sci_status status;
1365
1366 dev_dbg(&isci_host->pdev->dev,
1367 "%s: domain_device = %p\n", __func__, domain_dev);
1368
1369 wait_for_start(isci_host);
1370
1371 sas_port = domain_dev->port;
1372 sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
1373 port_phy_el);
1374 isci_phy = to_iphy(sas_phy);
1375 isci_port = isci_phy->isci_port;
1376
1377 /* we are being called for a device on this port,
1378 * so it has to come up eventually
1379 */
1380 wait_for_completion(&isci_port->start_complete);
1381
1382 if ((isci_stopping == isci_port_get_state(isci_port)) ||
1383 (isci_stopped == isci_port_get_state(isci_port)))
1384 return -ENODEV;
1385
1386 isci_device = isci_remote_device_alloc(isci_host, isci_port);
1387 if (!isci_device)
1388 return -ENODEV;
1389
1390 kref_init(&isci_device->kref);
1391 INIT_LIST_HEAD(&isci_device->node);
1392
1393 spin_lock_irq(&isci_host->scic_lock);
1394 isci_device->domain_dev = domain_dev;
1395 isci_device->isci_port = isci_port;
1396 list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1397
1398 set_bit(IDEV_START_PENDING, &isci_device->flags);
1399 status = isci_remote_device_construct(isci_port, isci_device);
1400
1401 dev_dbg(&isci_host->pdev->dev,
1402 "%s: isci_device = %p\n",
1403 __func__, isci_device);
1404
1405 if (status == SCI_SUCCESS) {
1406 /* device came up, advertise it to the world */
1407 domain_dev->lldd_dev = isci_device;
1408 } else
1409 isci_put_device(isci_device);
1410 spin_unlock_irq(&isci_host->scic_lock);
1411
1412 /* wait for the device ready callback. */
1413 wait_for_device_start(isci_host, isci_device);
1414
1415 return status == SCI_SUCCESS ? 0 : -ENODEV;
1416}
1417/**
1418 * isci_device_is_reset_pending() - This function will check if there is any
1419 * pending reset condition on the device.
1420 * @request: This parameter is the isci_device object.
1421 *
1422 * true if there is a reset pending for the device.
1423 */
1424bool isci_device_is_reset_pending(
1425 struct isci_host *isci_host,
1426 struct isci_remote_device *isci_device)
1427{
1428 struct isci_request *isci_request;
1429 struct isci_request *tmp_req;
1430 bool reset_is_pending = false;
1431 unsigned long flags;
1432
1433 dev_dbg(&isci_host->pdev->dev,
1434 "%s: isci_device = %p\n", __func__, isci_device);
1435
1436 spin_lock_irqsave(&isci_host->scic_lock, flags);
1437
1438 /* Check for reset on all pending requests. */
1439 list_for_each_entry_safe(isci_request, tmp_req,
1440 &isci_device->reqs_in_process, dev_node) {
1441 dev_dbg(&isci_host->pdev->dev,
1442 "%s: isci_device = %p request = %p\n",
1443 __func__, isci_device, isci_request);
1444
1445 if (isci_request->ttype == io_task) {
1446 struct sas_task *task = isci_request_access_task(
1447 isci_request);
1448
1449 spin_lock(&task->task_state_lock);
1450 if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
1451 reset_is_pending = true;
1452 spin_unlock(&task->task_state_lock);
1453 }
1454 }
1455
1456 spin_unlock_irqrestore(&isci_host->scic_lock, flags);
1457
1458 dev_dbg(&isci_host->pdev->dev,
1459 "%s: isci_device = %p reset_is_pending = %d\n",
1460 __func__, isci_device, reset_is_pending);
1461
1462 return reset_is_pending;
1463}
1464
1465/**
1466 * isci_device_clear_reset_pending() - This function will clear if any pending
1467 * reset condition flags on the device.
1468 * @request: This parameter is the isci_device object.
1469 *
1470 * true if there is a reset pending for the device.
1471 */
1472void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
1473{
1474 struct isci_request *isci_request;
1475 struct isci_request *tmp_req;
1476 unsigned long flags = 0;
1477
1478 dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
1479 __func__, idev, ihost);
1480
1481 spin_lock_irqsave(&ihost->scic_lock, flags);
1482
1483 /* Clear reset pending on all pending requests. */
1484 list_for_each_entry_safe(isci_request, tmp_req,
1485 &idev->reqs_in_process, dev_node) {
1486 dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
1487 __func__, idev, isci_request);
1488
1489 if (isci_request->ttype == io_task) {
1490
1491 unsigned long flags2;
1492 struct sas_task *task = isci_request_access_task(
1493 isci_request);
1494
1495 spin_lock_irqsave(&task->task_state_lock, flags2);
1496 task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
1497 spin_unlock_irqrestore(&task->task_state_lock, flags2);
1498 }
1499 }
1500 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1501}
1/*
2 * This file is provided under a dual BSD/GPLv2 license. When using or
3 * redistributing this file, you may do so under either license.
4 *
5 * GPL LICENSE SUMMARY
6 *
7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
23 *
24 * BSD LICENSE
25 *
26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
27 * All rights reserved.
28 *
29 * Redistribution and use in source and binary forms, with or without
30 * modification, are permitted provided that the following conditions
31 * are met:
32 *
33 * * Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * * Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in
37 * the documentation and/or other materials provided with the
38 * distribution.
39 * * Neither the name of Intel Corporation nor the names of its
40 * contributors may be used to endorse or promote products derived
41 * from this software without specific prior written permission.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
54 */
55#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 * isci_remote_device_ready() - This function is called by the ihost when the
84 * remote device is ready. We mark the isci device as ready and signal the
85 * waiting proccess.
86 * @ihost: our valid isci_host
87 * @idev: remote device
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 /* Check for a change in the suspend count, or the RNC
147 * being destroyed.
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 /* If already suspended, don't wait for another suspension. */
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 /* Terminate a specific TC. */
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 /* Terminate all TCs. */
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* isci_remote_device_not_ready() - This function is called by the ihost when
289* the remote device is not ready. We mark the isci device as ready (not
290* "ready_for_io") and signal the waiting proccess.
291* @isci_host: This parameter specifies the isci host object.
292* @isci_device: This parameter specifies the remote device
293*
294* sci_lock is held on entrance to this function.
295*/
296static void isci_remote_device_not_ready(struct isci_host *ihost,
297 struct isci_remote_device *idev,
298 u32 reason)
299{
300 dev_dbg(&ihost->pdev->dev,
301 "%s: isci_device = %p; reason = %d\n", __func__, idev, reason);
302
303 switch (reason) {
304 case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
305 set_bit(IDEV_IO_NCQERROR, &idev->flags);
306
307 /* Suspend the remote device so the I/O can be terminated. */
308 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
309
310 /* Kill all outstanding requests for the device. */
311 sci_remote_device_terminate_requests(idev);
312
313 fallthrough; /* into the default case */
314 default:
315 clear_bit(IDEV_IO_READY, &idev->flags);
316 break;
317 }
318}
319
320/* called once the remote node context is ready to be freed.
321 * The remote device can now report that its stop operation is complete. none
322 */
323static void rnc_destruct_done(void *_dev)
324{
325 struct isci_remote_device *idev = _dev;
326
327 BUG_ON(idev->started_request_count != 0);
328 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
329}
330
331enum sci_status sci_remote_device_terminate_requests(
332 struct isci_remote_device *idev)
333{
334 return sci_remote_device_terminate_reqs_checkabort(idev, 0);
335}
336
337enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
338 u32 timeout)
339{
340 struct sci_base_state_machine *sm = &idev->sm;
341 enum sci_remote_device_states state = sm->current_state_id;
342
343 switch (state) {
344 case SCI_DEV_INITIAL:
345 case SCI_DEV_FAILED:
346 case SCI_DEV_FINAL:
347 default:
348 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
349 __func__, dev_state_name(state));
350 return SCI_FAILURE_INVALID_STATE;
351 case SCI_DEV_STOPPED:
352 return SCI_SUCCESS;
353 case SCI_DEV_STARTING:
354 /* device not started so there had better be no requests */
355 BUG_ON(idev->started_request_count != 0);
356 sci_remote_node_context_destruct(&idev->rnc,
357 rnc_destruct_done, idev);
358 /* Transition to the stopping state and wait for the
359 * remote node to complete being posted and invalidated.
360 */
361 sci_change_state(sm, SCI_DEV_STOPPING);
362 return SCI_SUCCESS;
363 case SCI_DEV_READY:
364 case SCI_STP_DEV_IDLE:
365 case SCI_STP_DEV_CMD:
366 case SCI_STP_DEV_NCQ:
367 case SCI_STP_DEV_NCQ_ERROR:
368 case SCI_STP_DEV_AWAIT_RESET:
369 case SCI_SMP_DEV_IDLE:
370 case SCI_SMP_DEV_CMD:
371 sci_change_state(sm, SCI_DEV_STOPPING);
372 if (idev->started_request_count == 0)
373 sci_remote_node_context_destruct(&idev->rnc,
374 rnc_destruct_done,
375 idev);
376 else {
377 sci_remote_device_suspend(
378 idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
379 sci_remote_device_terminate_requests(idev);
380 }
381 return SCI_SUCCESS;
382 case SCI_DEV_STOPPING:
383 /* All requests should have been terminated, but if there is an
384 * attempt to stop a device already in the stopping state, then
385 * try again to terminate.
386 */
387 return sci_remote_device_terminate_requests(idev);
388 case SCI_DEV_RESETTING:
389 sci_change_state(sm, SCI_DEV_STOPPING);
390 return SCI_SUCCESS;
391 }
392}
393
394enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
395{
396 struct sci_base_state_machine *sm = &idev->sm;
397 enum sci_remote_device_states state = sm->current_state_id;
398
399 switch (state) {
400 case SCI_DEV_INITIAL:
401 case SCI_DEV_STOPPED:
402 case SCI_DEV_STARTING:
403 case SCI_SMP_DEV_IDLE:
404 case SCI_SMP_DEV_CMD:
405 case SCI_DEV_STOPPING:
406 case SCI_DEV_FAILED:
407 case SCI_DEV_RESETTING:
408 case SCI_DEV_FINAL:
409 default:
410 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
411 __func__, dev_state_name(state));
412 return SCI_FAILURE_INVALID_STATE;
413 case SCI_DEV_READY:
414 case SCI_STP_DEV_IDLE:
415 case SCI_STP_DEV_CMD:
416 case SCI_STP_DEV_NCQ:
417 case SCI_STP_DEV_NCQ_ERROR:
418 case SCI_STP_DEV_AWAIT_RESET:
419 sci_change_state(sm, SCI_DEV_RESETTING);
420 return SCI_SUCCESS;
421 }
422}
423
424enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev)
425{
426 struct sci_base_state_machine *sm = &idev->sm;
427 enum sci_remote_device_states state = sm->current_state_id;
428
429 if (state != SCI_DEV_RESETTING) {
430 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
431 __func__, dev_state_name(state));
432 return SCI_FAILURE_INVALID_STATE;
433 }
434
435 sci_change_state(sm, SCI_DEV_READY);
436 return SCI_SUCCESS;
437}
438
439enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
440 u32 frame_index)
441{
442 struct sci_base_state_machine *sm = &idev->sm;
443 enum sci_remote_device_states state = sm->current_state_id;
444 struct isci_host *ihost = idev->owning_port->owning_controller;
445 enum sci_status status;
446
447 switch (state) {
448 case SCI_DEV_INITIAL:
449 case SCI_DEV_STOPPED:
450 case SCI_DEV_STARTING:
451 case SCI_STP_DEV_IDLE:
452 case SCI_SMP_DEV_IDLE:
453 case SCI_DEV_FINAL:
454 default:
455 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
456 __func__, dev_state_name(state));
457 /* Return the frame back to the controller */
458 sci_controller_release_frame(ihost, frame_index);
459 return SCI_FAILURE_INVALID_STATE;
460 case SCI_DEV_READY:
461 case SCI_STP_DEV_NCQ_ERROR:
462 case SCI_STP_DEV_AWAIT_RESET:
463 case SCI_DEV_STOPPING:
464 case SCI_DEV_FAILED:
465 case SCI_DEV_RESETTING: {
466 struct isci_request *ireq;
467 struct ssp_frame_hdr hdr;
468 void *frame_header;
469 ssize_t word_cnt;
470
471 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
472 frame_index,
473 &frame_header);
474 if (status != SCI_SUCCESS)
475 return status;
476
477 word_cnt = sizeof(hdr) / sizeof(u32);
478 sci_swab32_cpy(&hdr, frame_header, word_cnt);
479
480 ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag));
481 if (ireq && ireq->target_device == idev) {
482 /* The IO request is now in charge of releasing the frame */
483 status = sci_io_request_frame_handler(ireq, frame_index);
484 } else {
485 /* We could not map this tag to a valid IO
486 * request Just toss the frame and continue
487 */
488 sci_controller_release_frame(ihost, frame_index);
489 }
490 break;
491 }
492 case SCI_STP_DEV_NCQ: {
493 struct dev_to_host_fis *hdr;
494
495 status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
496 frame_index,
497 (void **)&hdr);
498 if (status != SCI_SUCCESS)
499 return status;
500
501 if (hdr->fis_type == FIS_SETDEVBITS &&
502 (hdr->status & ATA_ERR)) {
503 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
504
505 /* TODO Check sactive and complete associated IO if any. */
506 sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
507 } else if (hdr->fis_type == FIS_REGD2H &&
508 (hdr->status & ATA_ERR)) {
509 /*
510 * Some devices return D2H FIS when an NCQ error is detected.
511 * Treat this like an SDB error FIS ready reason.
512 */
513 idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
514 sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
515 } else
516 status = SCI_FAILURE;
517
518 sci_controller_release_frame(ihost, frame_index);
519 break;
520 }
521 case SCI_STP_DEV_CMD:
522 case SCI_SMP_DEV_CMD:
523 /* The device does not process any UF received from the hardware while
524 * in this state. All unsolicited frames are forwarded to the io request
525 * object.
526 */
527 status = sci_io_request_frame_handler(idev->working_request, frame_index);
528 break;
529 }
530
531 return status;
532}
533
534static bool is_remote_device_ready(struct isci_remote_device *idev)
535{
536
537 struct sci_base_state_machine *sm = &idev->sm;
538 enum sci_remote_device_states state = sm->current_state_id;
539
540 switch (state) {
541 case SCI_DEV_READY:
542 case SCI_STP_DEV_IDLE:
543 case SCI_STP_DEV_CMD:
544 case SCI_STP_DEV_NCQ:
545 case SCI_STP_DEV_NCQ_ERROR:
546 case SCI_STP_DEV_AWAIT_RESET:
547 case SCI_SMP_DEV_IDLE:
548 case SCI_SMP_DEV_CMD:
549 return true;
550 default:
551 return false;
552 }
553}
554
555/*
556 * called once the remote node context has transisitioned to a ready
557 * state (after suspending RX and/or TX due to early D2H fis)
558 */
559static void atapi_remote_device_resume_done(void *_dev)
560{
561 struct isci_remote_device *idev = _dev;
562 struct isci_request *ireq = idev->working_request;
563
564 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
565}
566
567enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
568 u32 event_code)
569{
570 enum sci_status status;
571 struct sci_base_state_machine *sm = &idev->sm;
572 enum sci_remote_device_states state = sm->current_state_id;
573
574 switch (scu_get_event_type(event_code)) {
575 case SCU_EVENT_TYPE_RNC_OPS_MISC:
576 case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
577 case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
578 status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
579 break;
580 case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
581 if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
582 status = SCI_SUCCESS;
583
584 /* Suspend the associated RNC */
585 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
586
587 dev_dbg(scirdev_to_dev(idev),
588 "%s: device: %p event code: %x: %s\n",
589 __func__, idev, event_code,
590 is_remote_device_ready(idev)
591 ? "I_T_Nexus_Timeout event"
592 : "I_T_Nexus_Timeout event in wrong state");
593
594 break;
595 }
596 fallthrough; /* and treat as unhandled */
597 default:
598 dev_dbg(scirdev_to_dev(idev),
599 "%s: device: %p event code: %x: %s\n",
600 __func__, idev, event_code,
601 is_remote_device_ready(idev)
602 ? "unexpected event"
603 : "unexpected event in wrong state");
604 status = SCI_FAILURE_INVALID_STATE;
605 break;
606 }
607
608 if (status != SCI_SUCCESS)
609 return status;
610
611 /* Decode device-specific states that may require an RNC resume during
612 * normal operation. When the abort path is active, these resumes are
613 * managed when the abort path exits.
614 */
615 if (state == SCI_STP_DEV_ATAPI_ERROR) {
616 /* For ATAPI error state resume the RNC right away. */
617 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
618 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
619 return sci_remote_node_context_resume(&idev->rnc,
620 atapi_remote_device_resume_done,
621 idev);
622 }
623 }
624
625 if (state == SCI_STP_DEV_IDLE) {
626
627 /* We pick up suspension events to handle specifically to this
628 * state. We resume the RNC right away.
629 */
630 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
631 scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
632 status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
633 }
634
635 return status;
636}
637
638static void sci_remote_device_start_request(struct isci_remote_device *idev,
639 struct isci_request *ireq,
640 enum sci_status status)
641{
642 struct isci_port *iport = idev->owning_port;
643
644 /* cleanup requests that failed after starting on the port */
645 if (status != SCI_SUCCESS)
646 sci_port_complete_io(iport, idev, ireq);
647 else {
648 kref_get(&idev->kref);
649 idev->started_request_count++;
650 }
651}
652
653enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
654 struct isci_remote_device *idev,
655 struct isci_request *ireq)
656{
657 struct sci_base_state_machine *sm = &idev->sm;
658 enum sci_remote_device_states state = sm->current_state_id;
659 struct isci_port *iport = idev->owning_port;
660 enum sci_status status;
661
662 switch (state) {
663 case SCI_DEV_INITIAL:
664 case SCI_DEV_STOPPED:
665 case SCI_DEV_STARTING:
666 case SCI_STP_DEV_NCQ_ERROR:
667 case SCI_DEV_STOPPING:
668 case SCI_DEV_FAILED:
669 case SCI_DEV_RESETTING:
670 case SCI_DEV_FINAL:
671 default:
672 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
673 __func__, dev_state_name(state));
674 return SCI_FAILURE_INVALID_STATE;
675 case SCI_DEV_READY:
676 /* attempt to start an io request for this device object. The remote
677 * device object will issue the start request for the io and if
678 * successful it will start the request for the port object then
679 * increment its own request count.
680 */
681 status = sci_port_start_io(iport, idev, ireq);
682 if (status != SCI_SUCCESS)
683 return status;
684
685 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
686 if (status != SCI_SUCCESS)
687 break;
688
689 status = sci_request_start(ireq);
690 break;
691 case SCI_STP_DEV_IDLE: {
692 /* handle the start io operation for a sata device that is in
693 * the command idle state. - Evalute the type of IO request to
694 * be started - If its an NCQ request change to NCQ substate -
695 * If its any other command change to the CMD substate
696 *
697 * If this is a softreset we may want to have a different
698 * substate.
699 */
700 enum sci_remote_device_states new_state;
701 struct sas_task *task = isci_request_access_task(ireq);
702
703 status = sci_port_start_io(iport, idev, ireq);
704 if (status != SCI_SUCCESS)
705 return status;
706
707 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
708 if (status != SCI_SUCCESS)
709 break;
710
711 status = sci_request_start(ireq);
712 if (status != SCI_SUCCESS)
713 break;
714
715 if (task->ata_task.use_ncq)
716 new_state = SCI_STP_DEV_NCQ;
717 else {
718 idev->working_request = ireq;
719 new_state = SCI_STP_DEV_CMD;
720 }
721 sci_change_state(sm, new_state);
722 break;
723 }
724 case SCI_STP_DEV_NCQ: {
725 struct sas_task *task = isci_request_access_task(ireq);
726
727 if (task->ata_task.use_ncq) {
728 status = sci_port_start_io(iport, idev, ireq);
729 if (status != SCI_SUCCESS)
730 return status;
731
732 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
733 if (status != SCI_SUCCESS)
734 break;
735
736 status = sci_request_start(ireq);
737 } else
738 return SCI_FAILURE_INVALID_STATE;
739 break;
740 }
741 case SCI_STP_DEV_AWAIT_RESET:
742 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
743 case SCI_SMP_DEV_IDLE:
744 status = sci_port_start_io(iport, idev, ireq);
745 if (status != SCI_SUCCESS)
746 return status;
747
748 status = sci_remote_node_context_start_io(&idev->rnc, ireq);
749 if (status != SCI_SUCCESS)
750 break;
751
752 status = sci_request_start(ireq);
753 if (status != SCI_SUCCESS)
754 break;
755
756 idev->working_request = ireq;
757 sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
758 break;
759 case SCI_STP_DEV_CMD:
760 case SCI_SMP_DEV_CMD:
761 /* device is already handling a command it can not accept new commands
762 * until this one is complete.
763 */
764 return SCI_FAILURE_INVALID_STATE;
765 }
766
767 sci_remote_device_start_request(idev, ireq, status);
768 return status;
769}
770
771static enum sci_status common_complete_io(struct isci_port *iport,
772 struct isci_remote_device *idev,
773 struct isci_request *ireq)
774{
775 enum sci_status status;
776
777 status = sci_request_complete(ireq);
778 if (status != SCI_SUCCESS)
779 return status;
780
781 status = sci_port_complete_io(iport, idev, ireq);
782 if (status != SCI_SUCCESS)
783 return status;
784
785 sci_remote_device_decrement_request_count(idev);
786 return status;
787}
788
789enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
790 struct isci_remote_device *idev,
791 struct isci_request *ireq)
792{
793 struct sci_base_state_machine *sm = &idev->sm;
794 enum sci_remote_device_states state = sm->current_state_id;
795 struct isci_port *iport = idev->owning_port;
796 enum sci_status status;
797
798 switch (state) {
799 case SCI_DEV_INITIAL:
800 case SCI_DEV_STOPPED:
801 case SCI_DEV_STARTING:
802 case SCI_STP_DEV_IDLE:
803 case SCI_SMP_DEV_IDLE:
804 case SCI_DEV_FAILED:
805 case SCI_DEV_FINAL:
806 default:
807 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
808 __func__, dev_state_name(state));
809 return SCI_FAILURE_INVALID_STATE;
810 case SCI_DEV_READY:
811 case SCI_STP_DEV_AWAIT_RESET:
812 case SCI_DEV_RESETTING:
813 status = common_complete_io(iport, idev, ireq);
814 break;
815 case SCI_STP_DEV_CMD:
816 case SCI_STP_DEV_NCQ:
817 case SCI_STP_DEV_NCQ_ERROR:
818 case SCI_STP_DEV_ATAPI_ERROR:
819 status = common_complete_io(iport, idev, ireq);
820 if (status != SCI_SUCCESS)
821 break;
822
823 if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
824 /* This request causes hardware error, device needs to be Lun Reset.
825 * So here we force the state machine to IDLE state so the rest IOs
826 * can reach RNC state handler, these IOs will be completed by RNC with
827 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
828 */
829 sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
830 } else if (idev->started_request_count == 0)
831 sci_change_state(sm, SCI_STP_DEV_IDLE);
832 break;
833 case SCI_SMP_DEV_CMD:
834 status = common_complete_io(iport, idev, ireq);
835 if (status != SCI_SUCCESS)
836 break;
837 sci_change_state(sm, SCI_SMP_DEV_IDLE);
838 break;
839 case SCI_DEV_STOPPING:
840 status = common_complete_io(iport, idev, ireq);
841 if (status != SCI_SUCCESS)
842 break;
843
844 if (idev->started_request_count == 0)
845 sci_remote_node_context_destruct(&idev->rnc,
846 rnc_destruct_done,
847 idev);
848 break;
849 }
850
851 if (status != SCI_SUCCESS)
852 dev_err(scirdev_to_dev(idev),
853 "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
854 "could not complete\n", __func__, iport,
855 idev, ireq, status);
856 else
857 isci_put_device(idev);
858
859 return status;
860}
861
862static void sci_remote_device_continue_request(void *dev)
863{
864 struct isci_remote_device *idev = dev;
865
866 /* we need to check if this request is still valid to continue. */
867 if (idev->working_request)
868 sci_controller_continue_io(idev->working_request);
869}
870
871enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
872 struct isci_remote_device *idev,
873 struct isci_request *ireq)
874{
875 struct sci_base_state_machine *sm = &idev->sm;
876 enum sci_remote_device_states state = sm->current_state_id;
877 struct isci_port *iport = idev->owning_port;
878 enum sci_status status;
879
880 switch (state) {
881 case SCI_DEV_INITIAL:
882 case SCI_DEV_STOPPED:
883 case SCI_DEV_STARTING:
884 case SCI_SMP_DEV_IDLE:
885 case SCI_SMP_DEV_CMD:
886 case SCI_DEV_STOPPING:
887 case SCI_DEV_FAILED:
888 case SCI_DEV_RESETTING:
889 case SCI_DEV_FINAL:
890 default:
891 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
892 __func__, dev_state_name(state));
893 return SCI_FAILURE_INVALID_STATE;
894 case SCI_STP_DEV_IDLE:
895 case SCI_STP_DEV_CMD:
896 case SCI_STP_DEV_NCQ:
897 case SCI_STP_DEV_NCQ_ERROR:
898 case SCI_STP_DEV_AWAIT_RESET:
899 status = sci_port_start_io(iport, idev, ireq);
900 if (status != SCI_SUCCESS)
901 return status;
902
903 status = sci_request_start(ireq);
904 if (status != SCI_SUCCESS)
905 goto out;
906
907 /* Note: If the remote device state is not IDLE this will
908 * replace the request that probably resulted in the task
909 * management request.
910 */
911 idev->working_request = ireq;
912 sci_change_state(sm, SCI_STP_DEV_CMD);
913
914 /* The remote node context must cleanup the TCi to NCQ mapping
915 * table. The only way to do this correctly is to either write
916 * to the TLCR register or to invalidate and repost the RNC. In
917 * either case the remote node context state machine will take
918 * the correct action when the remote node context is suspended
919 * and later resumed.
920 */
921 sci_remote_device_suspend(idev,
922 SCI_SW_SUSPEND_LINKHANG_DETECT);
923
924 status = sci_remote_node_context_start_task(&idev->rnc, ireq,
925 sci_remote_device_continue_request, idev);
926
927 out:
928 sci_remote_device_start_request(idev, ireq, status);
929 /* We need to let the controller start request handler know that
930 * it can't post TC yet. We will provide a callback function to
931 * post TC when RNC gets resumed.
932 */
933 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
934 case SCI_DEV_READY:
935 status = sci_port_start_io(iport, idev, ireq);
936 if (status != SCI_SUCCESS)
937 return status;
938
939 /* Resume the RNC as needed: */
940 status = sci_remote_node_context_start_task(&idev->rnc, ireq,
941 NULL, NULL);
942 if (status != SCI_SUCCESS)
943 break;
944
945 status = sci_request_start(ireq);
946 break;
947 }
948 sci_remote_device_start_request(idev, ireq, status);
949
950 return status;
951}
952
953void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
954{
955 struct isci_port *iport = idev->owning_port;
956 u32 context;
957
958 context = request |
959 (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
960 (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
961 idev->rnc.remote_node_index;
962
963 sci_controller_post_request(iport->owning_controller, context);
964}
965
966/* called once the remote node context has transisitioned to a
967 * ready state. This is the indication that the remote device object can also
968 * transition to ready.
969 */
970static void remote_device_resume_done(void *_dev)
971{
972 struct isci_remote_device *idev = _dev;
973
974 if (is_remote_device_ready(idev))
975 return;
976
977 /* go 'ready' if we are not already in a ready state */
978 sci_change_state(&idev->sm, SCI_DEV_READY);
979}
980
981static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
982{
983 struct isci_remote_device *idev = _dev;
984 struct isci_host *ihost = idev->owning_port->owning_controller;
985
986 /* For NCQ operation we do not issue a isci_remote_device_not_ready().
987 * As a result, avoid sending the ready notification.
988 */
989 if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
990 isci_remote_device_ready(ihost, idev);
991}
992
993static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
994{
995 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
996
997 /* Initial state is a transitional state to the stopped state */
998 sci_change_state(&idev->sm, SCI_DEV_STOPPED);
999}
1000
1001/**
1002 * sci_remote_device_destruct() - free remote node context and destruct
1003 * @remote_device: This parameter specifies the remote device to be destructed.
1004 *
1005 * Remote device objects are a limited resource. As such, they must be
1006 * protected. Thus calls to construct and destruct are mutually exclusive and
1007 * non-reentrant. The return value shall indicate if the device was
1008 * successfully destructed or if some failure occurred. enum sci_status This value
1009 * is returned if the device is successfully destructed.
1010 * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
1011 * device isn't valid (e.g. it's already been destoryed, the handle isn't
1012 * valid, etc.).
1013 */
1014static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
1015{
1016 struct sci_base_state_machine *sm = &idev->sm;
1017 enum sci_remote_device_states state = sm->current_state_id;
1018 struct isci_host *ihost;
1019
1020 if (state != SCI_DEV_STOPPED) {
1021 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1022 __func__, dev_state_name(state));
1023 return SCI_FAILURE_INVALID_STATE;
1024 }
1025
1026 ihost = idev->owning_port->owning_controller;
1027 sci_controller_free_remote_node_context(ihost, idev,
1028 idev->rnc.remote_node_index);
1029 idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
1030 sci_change_state(sm, SCI_DEV_FINAL);
1031
1032 return SCI_SUCCESS;
1033}
1034
1035/**
1036 * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
1037 * @ihost: This parameter specifies the isci host object.
1038 * @idev: This parameter specifies the remote device to be freed.
1039 *
1040 */
1041static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
1042{
1043 dev_dbg(&ihost->pdev->dev,
1044 "%s: isci_device = %p\n", __func__, idev);
1045
1046 /* There should not be any outstanding io's. All paths to
1047 * here should go through isci_remote_device_nuke_requests.
1048 * If we hit this condition, we will need a way to complete
1049 * io requests in process */
1050 BUG_ON(idev->started_request_count > 0);
1051
1052 sci_remote_device_destruct(idev);
1053 list_del_init(&idev->node);
1054 isci_put_device(idev);
1055}
1056
1057static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
1058{
1059 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1060 struct isci_host *ihost = idev->owning_port->owning_controller;
1061 u32 prev_state;
1062
1063 /* If we are entering from the stopping state let the SCI User know that
1064 * the stop operation has completed.
1065 */
1066 prev_state = idev->sm.previous_state_id;
1067 if (prev_state == SCI_DEV_STOPPING)
1068 isci_remote_device_deconstruct(ihost, idev);
1069
1070 sci_controller_remote_device_stopped(ihost, idev);
1071}
1072
1073static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
1074{
1075 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1076 struct isci_host *ihost = idev->owning_port->owning_controller;
1077
1078 isci_remote_device_not_ready(ihost, idev,
1079 SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
1080}
1081
1082static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
1083{
1084 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1085 struct isci_host *ihost = idev->owning_port->owning_controller;
1086 struct domain_device *dev = idev->domain_dev;
1087
1088 if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
1089 sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
1090 } else if (dev_is_expander(dev->dev_type)) {
1091 sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
1092 } else
1093 isci_remote_device_ready(ihost, idev);
1094}
1095
1096static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
1097{
1098 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1099 struct domain_device *dev = idev->domain_dev;
1100
1101 if (dev->dev_type == SAS_END_DEVICE) {
1102 struct isci_host *ihost = idev->owning_port->owning_controller;
1103
1104 isci_remote_device_not_ready(ihost, idev,
1105 SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
1106 }
1107}
1108
1109static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
1110{
1111 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1112 struct isci_host *ihost = idev->owning_port->owning_controller;
1113
1114 dev_dbg(&ihost->pdev->dev,
1115 "%s: isci_device = %p\n", __func__, idev);
1116
1117 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1118}
1119
1120static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
1121{
1122 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1123 struct isci_host *ihost = idev->owning_port->owning_controller;
1124
1125 dev_dbg(&ihost->pdev->dev,
1126 "%s: isci_device = %p\n", __func__, idev);
1127
1128 sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
1129}
1130
1131static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1132{
1133 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1134
1135 idev->working_request = NULL;
1136 if (sci_remote_node_context_is_ready(&idev->rnc)) {
1137 /*
1138 * Since the RNC is ready, it's alright to finish completion
1139 * processing (e.g. signal the remote device is ready). */
1140 sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
1141 } else {
1142 sci_remote_node_context_resume(&idev->rnc,
1143 sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
1144 idev);
1145 }
1146}
1147
1148static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1149{
1150 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1151 struct isci_host *ihost = idev->owning_port->owning_controller;
1152
1153 BUG_ON(idev->working_request == NULL);
1154
1155 isci_remote_device_not_ready(ihost, idev,
1156 SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1157}
1158
1159static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
1160{
1161 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1162 struct isci_host *ihost = idev->owning_port->owning_controller;
1163
1164 if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1165 isci_remote_device_not_ready(ihost, idev,
1166 idev->not_ready_reason);
1167}
1168
1169static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1170{
1171 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1172 struct isci_host *ihost = idev->owning_port->owning_controller;
1173
1174 isci_remote_device_ready(ihost, idev);
1175}
1176
1177static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1178{
1179 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1180 struct isci_host *ihost = idev->owning_port->owning_controller;
1181
1182 BUG_ON(idev->working_request == NULL);
1183
1184 isci_remote_device_not_ready(ihost, idev,
1185 SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1186}
1187
1188static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1189{
1190 struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1191
1192 idev->working_request = NULL;
1193}
1194
1195static const struct sci_base_state sci_remote_device_state_table[] = {
1196 [SCI_DEV_INITIAL] = {
1197 .enter_state = sci_remote_device_initial_state_enter,
1198 },
1199 [SCI_DEV_STOPPED] = {
1200 .enter_state = sci_remote_device_stopped_state_enter,
1201 },
1202 [SCI_DEV_STARTING] = {
1203 .enter_state = sci_remote_device_starting_state_enter,
1204 },
1205 [SCI_DEV_READY] = {
1206 .enter_state = sci_remote_device_ready_state_enter,
1207 .exit_state = sci_remote_device_ready_state_exit
1208 },
1209 [SCI_STP_DEV_IDLE] = {
1210 .enter_state = sci_stp_remote_device_ready_idle_substate_enter,
1211 },
1212 [SCI_STP_DEV_CMD] = {
1213 .enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
1214 },
1215 [SCI_STP_DEV_NCQ] = { },
1216 [SCI_STP_DEV_NCQ_ERROR] = {
1217 .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
1218 },
1219 [SCI_STP_DEV_ATAPI_ERROR] = { },
1220 [SCI_STP_DEV_AWAIT_RESET] = { },
1221 [SCI_SMP_DEV_IDLE] = {
1222 .enter_state = sci_smp_remote_device_ready_idle_substate_enter,
1223 },
1224 [SCI_SMP_DEV_CMD] = {
1225 .enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
1226 .exit_state = sci_smp_remote_device_ready_cmd_substate_exit,
1227 },
1228 [SCI_DEV_STOPPING] = { },
1229 [SCI_DEV_FAILED] = { },
1230 [SCI_DEV_RESETTING] = {
1231 .enter_state = sci_remote_device_resetting_state_enter,
1232 .exit_state = sci_remote_device_resetting_state_exit
1233 },
1234 [SCI_DEV_FINAL] = { },
1235};
1236
1237/**
1238 * sci_remote_device_construct() - common construction
1239 * @sci_port: SAS/SATA port through which this device is accessed.
1240 * @sci_dev: remote device to construct
1241 *
1242 * This routine just performs benign initialization and does not
1243 * allocate the remote_node_context which is left to
1244 * sci_remote_device_[de]a_construct(). sci_remote_device_destruct()
1245 * frees the remote_node_context(s) for the device.
1246 */
1247static void sci_remote_device_construct(struct isci_port *iport,
1248 struct isci_remote_device *idev)
1249{
1250 idev->owning_port = iport;
1251 idev->started_request_count = 0;
1252
1253 sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL);
1254
1255 sci_remote_node_context_construct(&idev->rnc,
1256 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1257}
1258
1259/**
1260 * sci_remote_device_da_construct() - construct direct attached device.
1261 *
1262 * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1263 * the device is known to the SCI Core since it is contained in the
1264 * sci_phy object. Remote node context(s) is/are a global resource
1265 * allocated by this routine, freed by sci_remote_device_destruct().
1266 *
1267 * Returns:
1268 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1269 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1270 * sata-only controller instance.
1271 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1272 */
1273static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
1274 struct isci_remote_device *idev)
1275{
1276 enum sci_status status;
1277 struct sci_port_properties properties;
1278
1279 sci_remote_device_construct(iport, idev);
1280
1281 sci_port_get_properties(iport, &properties);
1282 /* Get accurate port width from port's phy mask for a DA device. */
1283 idev->device_port_width = hweight32(properties.phy_mask);
1284
1285 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1286 idev,
1287 &idev->rnc.remote_node_index);
1288
1289 if (status != SCI_SUCCESS)
1290 return status;
1291
1292 idev->connection_rate = sci_port_get_max_allowed_speed(iport);
1293
1294 return SCI_SUCCESS;
1295}
1296
1297/**
1298 * sci_remote_device_ea_construct() - construct expander attached device
1299 *
1300 * Remote node context(s) is/are a global resource allocated by this
1301 * routine, freed by sci_remote_device_destruct().
1302 *
1303 * Returns:
1304 * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1305 * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1306 * sata-only controller instance.
1307 * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1308 */
1309static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
1310 struct isci_remote_device *idev)
1311{
1312 struct domain_device *dev = idev->domain_dev;
1313 enum sci_status status;
1314
1315 sci_remote_device_construct(iport, idev);
1316
1317 status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1318 idev,
1319 &idev->rnc.remote_node_index);
1320 if (status != SCI_SUCCESS)
1321 return status;
1322
1323 /* For SAS-2 the physical link rate is actually a logical link
1324 * rate that incorporates multiplexing. The SCU doesn't
1325 * incorporate multiplexing and for the purposes of the
1326 * connection the logical link rate is that same as the
1327 * physical. Furthermore, the SAS-2 and SAS-1.1 fields overlay
1328 * one another, so this code works for both situations.
1329 */
1330 idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
1331 dev->linkrate);
1332
1333 /* / @todo Should I assign the port width by reading all of the phys on the port? */
1334 idev->device_port_width = 1;
1335
1336 return SCI_SUCCESS;
1337}
1338
1339enum sci_status sci_remote_device_resume(
1340 struct isci_remote_device *idev,
1341 scics_sds_remote_node_context_callback cb_fn,
1342 void *cb_p)
1343{
1344 enum sci_status status;
1345
1346 status = sci_remote_node_context_resume(&idev->rnc, cb_fn, cb_p);
1347 if (status != SCI_SUCCESS)
1348 dev_dbg(scirdev_to_dev(idev), "%s: failed to resume: %d\n",
1349 __func__, status);
1350 return status;
1351}
1352
1353static void isci_remote_device_resume_from_abort_complete(void *cbparam)
1354{
1355 struct isci_remote_device *idev = cbparam;
1356 struct isci_host *ihost = idev->owning_port->owning_controller;
1357 scics_sds_remote_node_context_callback abort_resume_cb =
1358 idev->abort_resume_cb;
1359
1360 dev_dbg(scirdev_to_dev(idev), "%s: passing-along resume: %p\n",
1361 __func__, abort_resume_cb);
1362
1363 if (abort_resume_cb != NULL) {
1364 idev->abort_resume_cb = NULL;
1365 abort_resume_cb(idev->abort_resume_cbparam);
1366 }
1367 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1368 wake_up(&ihost->eventq);
1369}
1370
1371static bool isci_remote_device_test_resume_done(
1372 struct isci_host *ihost,
1373 struct isci_remote_device *idev)
1374{
1375 unsigned long flags;
1376 bool done;
1377
1378 spin_lock_irqsave(&ihost->scic_lock, flags);
1379 done = !test_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags)
1380 || test_bit(IDEV_STOP_PENDING, &idev->flags)
1381 || sci_remote_node_context_is_being_destroyed(&idev->rnc);
1382 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1383
1384 return done;
1385}
1386
1387void isci_remote_device_wait_for_resume_from_abort(
1388 struct isci_host *ihost,
1389 struct isci_remote_device *idev)
1390{
1391 dev_dbg(&ihost->pdev->dev, "%s: starting resume wait: %p\n",
1392 __func__, idev);
1393
1394 #define MAX_RESUME_MSECS 10000
1395 if (!wait_event_timeout(ihost->eventq,
1396 isci_remote_device_test_resume_done(ihost, idev),
1397 msecs_to_jiffies(MAX_RESUME_MSECS))) {
1398
1399 dev_warn(&ihost->pdev->dev, "%s: #### Timeout waiting for "
1400 "resume: %p\n", __func__, idev);
1401 }
1402 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1403
1404 dev_dbg(&ihost->pdev->dev, "%s: resume wait done: %p\n",
1405 __func__, idev);
1406}
1407
1408enum sci_status isci_remote_device_resume_from_abort(
1409 struct isci_host *ihost,
1410 struct isci_remote_device *idev)
1411{
1412 unsigned long flags;
1413 enum sci_status status = SCI_SUCCESS;
1414 int destroyed;
1415
1416 spin_lock_irqsave(&ihost->scic_lock, flags);
1417 /* Preserve any current resume callbacks, for instance from other
1418 * resumptions.
1419 */
1420 idev->abort_resume_cb = idev->rnc.user_callback;
1421 idev->abort_resume_cbparam = idev->rnc.user_cookie;
1422 set_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1423 clear_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1424 destroyed = sci_remote_node_context_is_being_destroyed(&idev->rnc);
1425 if (!destroyed)
1426 status = sci_remote_device_resume(
1427 idev, isci_remote_device_resume_from_abort_complete,
1428 idev);
1429 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1430 if (!destroyed && (status == SCI_SUCCESS))
1431 isci_remote_device_wait_for_resume_from_abort(ihost, idev);
1432 else
1433 clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1434
1435 return status;
1436}
1437
1438/**
1439 * sci_remote_device_start() - This method will start the supplied remote
1440 * device. This method enables normal IO requests to flow through to the
1441 * remote device.
1442 * @remote_device: This parameter specifies the device to be started.
1443 * @timeout: This parameter specifies the number of milliseconds in which the
1444 * start operation should complete.
1445 *
1446 * An indication of whether the device was successfully started. SCI_SUCCESS
1447 * This value is returned if the device was successfully started.
1448 * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1449 * the device when there have been no phys added to it.
1450 */
1451static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
1452 u32 timeout)
1453{
1454 struct sci_base_state_machine *sm = &idev->sm;
1455 enum sci_remote_device_states state = sm->current_state_id;
1456 enum sci_status status;
1457
1458 if (state != SCI_DEV_STOPPED) {
1459 dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1460 __func__, dev_state_name(state));
1461 return SCI_FAILURE_INVALID_STATE;
1462 }
1463
1464 status = sci_remote_device_resume(idev, remote_device_resume_done,
1465 idev);
1466 if (status != SCI_SUCCESS)
1467 return status;
1468
1469 sci_change_state(sm, SCI_DEV_STARTING);
1470
1471 return SCI_SUCCESS;
1472}
1473
1474static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1475 struct isci_remote_device *idev)
1476{
1477 struct isci_host *ihost = iport->isci_host;
1478 struct domain_device *dev = idev->domain_dev;
1479 enum sci_status status;
1480
1481 if (dev->parent && dev_is_expander(dev->parent->dev_type))
1482 status = sci_remote_device_ea_construct(iport, idev);
1483 else
1484 status = sci_remote_device_da_construct(iport, idev);
1485
1486 if (status != SCI_SUCCESS) {
1487 dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1488 __func__, status);
1489
1490 return status;
1491 }
1492
1493 /* start the device. */
1494 status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1495
1496 if (status != SCI_SUCCESS)
1497 dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1498 status);
1499
1500 return status;
1501}
1502
1503/**
1504 * This function builds the isci_remote_device when a libsas dev_found message
1505 * is received.
1506 * @isci_host: This parameter specifies the isci host object.
1507 * @port: This parameter specifies the isci_port connected to this device.
1508 *
1509 * pointer to new isci_remote_device.
1510 */
1511static struct isci_remote_device *
1512isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1513{
1514 struct isci_remote_device *idev;
1515 int i;
1516
1517 for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1518 idev = &ihost->devices[i];
1519 if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1520 break;
1521 }
1522
1523 if (i >= SCI_MAX_REMOTE_DEVICES) {
1524 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1525 return NULL;
1526 }
1527 if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1528 return NULL;
1529
1530 return idev;
1531}
1532
1533void isci_remote_device_release(struct kref *kref)
1534{
1535 struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
1536 struct isci_host *ihost = idev->isci_port->isci_host;
1537
1538 idev->domain_dev = NULL;
1539 idev->isci_port = NULL;
1540 clear_bit(IDEV_START_PENDING, &idev->flags);
1541 clear_bit(IDEV_STOP_PENDING, &idev->flags);
1542 clear_bit(IDEV_IO_READY, &idev->flags);
1543 clear_bit(IDEV_GONE, &idev->flags);
1544 smp_mb__before_atomic();
1545 clear_bit(IDEV_ALLOCATED, &idev->flags);
1546 wake_up(&ihost->eventq);
1547}
1548
1549/**
1550 * isci_remote_device_stop() - This function is called internally to stop the
1551 * remote device.
1552 * @isci_host: This parameter specifies the isci host object.
1553 * @isci_device: This parameter specifies the remote device.
1554 *
1555 * The status of the ihost request to stop.
1556 */
1557enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1558{
1559 enum sci_status status;
1560 unsigned long flags;
1561
1562 dev_dbg(&ihost->pdev->dev,
1563 "%s: isci_device = %p\n", __func__, idev);
1564
1565 spin_lock_irqsave(&ihost->scic_lock, flags);
1566 idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
1567 set_bit(IDEV_GONE, &idev->flags);
1568
1569 set_bit(IDEV_STOP_PENDING, &idev->flags);
1570 status = sci_remote_device_stop(idev, 50);
1571 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1572
1573 /* Wait for the stop complete callback. */
1574 if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
1575 /* nothing to wait for */;
1576 else
1577 wait_for_device_stop(ihost, idev);
1578
1579 dev_dbg(&ihost->pdev->dev,
1580 "%s: isci_device = %p, waiting done.\n", __func__, idev);
1581
1582 return status;
1583}
1584
1585/**
1586 * isci_remote_device_gone() - This function is called by libsas when a domain
1587 * device is removed.
1588 * @domain_device: This parameter specifies the libsas domain device.
1589 *
1590 */
1591void isci_remote_device_gone(struct domain_device *dev)
1592{
1593 struct isci_host *ihost = dev_to_ihost(dev);
1594 struct isci_remote_device *idev = dev->lldd_dev;
1595
1596 dev_dbg(&ihost->pdev->dev,
1597 "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1598 __func__, dev, idev, idev->isci_port);
1599
1600 isci_remote_device_stop(ihost, idev);
1601}
1602
1603
1604/**
1605 * isci_remote_device_found() - This function is called by libsas when a remote
1606 * device is discovered. A remote device object is created and started. the
1607 * function then sleeps until the sci core device started message is
1608 * received.
1609 * @domain_device: This parameter specifies the libsas domain device.
1610 *
1611 * status, zero indicates success.
1612 */
1613int isci_remote_device_found(struct domain_device *dev)
1614{
1615 struct isci_host *isci_host = dev_to_ihost(dev);
1616 struct isci_port *isci_port = dev->port->lldd_port;
1617 struct isci_remote_device *isci_device;
1618 enum sci_status status;
1619
1620 dev_dbg(&isci_host->pdev->dev,
1621 "%s: domain_device = %p\n", __func__, dev);
1622
1623 if (!isci_port)
1624 return -ENODEV;
1625
1626 isci_device = isci_remote_device_alloc(isci_host, isci_port);
1627 if (!isci_device)
1628 return -ENODEV;
1629
1630 kref_init(&isci_device->kref);
1631 INIT_LIST_HEAD(&isci_device->node);
1632
1633 spin_lock_irq(&isci_host->scic_lock);
1634 isci_device->domain_dev = dev;
1635 isci_device->isci_port = isci_port;
1636 list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1637
1638 set_bit(IDEV_START_PENDING, &isci_device->flags);
1639 status = isci_remote_device_construct(isci_port, isci_device);
1640
1641 dev_dbg(&isci_host->pdev->dev,
1642 "%s: isci_device = %p\n",
1643 __func__, isci_device);
1644
1645 if (status == SCI_SUCCESS) {
1646 /* device came up, advertise it to the world */
1647 dev->lldd_dev = isci_device;
1648 } else
1649 isci_put_device(isci_device);
1650 spin_unlock_irq(&isci_host->scic_lock);
1651
1652 /* wait for the device ready callback. */
1653 wait_for_device_start(isci_host, isci_device);
1654
1655 return status == SCI_SUCCESS ? 0 : -ENODEV;
1656}
1657
1658enum sci_status isci_remote_device_suspend_terminate(
1659 struct isci_host *ihost,
1660 struct isci_remote_device *idev,
1661 struct isci_request *ireq)
1662{
1663 unsigned long flags;
1664 enum sci_status status;
1665
1666 /* Put the device into suspension. */
1667 spin_lock_irqsave(&ihost->scic_lock, flags);
1668 set_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1669 sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1670 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1671
1672 /* Terminate and wait for the completions. */
1673 status = isci_remote_device_terminate_requests(ihost, idev, ireq);
1674 if (status != SCI_SUCCESS)
1675 dev_dbg(&ihost->pdev->dev,
1676 "%s: isci_remote_device_terminate_requests(%p) "
1677 "returned %d!\n",
1678 __func__, idev, status);
1679
1680 /* NOTE: RNC resumption is left to the caller! */
1681 return status;
1682}
1683
1684int isci_remote_device_is_safe_to_abort(
1685 struct isci_remote_device *idev)
1686{
1687 return sci_remote_node_context_is_safe_to_abort(&idev->rnc);
1688}
1689
1690enum sci_status sci_remote_device_abort_requests_pending_abort(
1691 struct isci_remote_device *idev)
1692{
1693 return sci_remote_device_terminate_reqs_checkabort(idev, 1);
1694}
1695
1696enum sci_status isci_remote_device_reset_complete(
1697 struct isci_host *ihost,
1698 struct isci_remote_device *idev)
1699{
1700 unsigned long flags;
1701 enum sci_status status;
1702
1703 spin_lock_irqsave(&ihost->scic_lock, flags);
1704 status = sci_remote_device_reset_complete(idev);
1705 spin_unlock_irqrestore(&ihost->scic_lock, flags);
1706
1707 return status;
1708}
1709
1710void isci_dev_set_hang_detection_timeout(
1711 struct isci_remote_device *idev,
1712 u32 timeout)
1713{
1714 if (dev_is_sata(idev->domain_dev)) {
1715 if (timeout) {
1716 if (test_and_set_bit(IDEV_RNC_LLHANG_ENABLED,
1717 &idev->flags))
1718 return; /* Already enabled. */
1719 } else if (!test_and_clear_bit(IDEV_RNC_LLHANG_ENABLED,
1720 &idev->flags))
1721 return; /* Not enabled. */
1722
1723 sci_port_set_hang_detection_timeout(idev->owning_port,
1724 timeout);
1725 }
1726}