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)
67 const 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 
75 enum 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  */
90 static 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 
101 static 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 
121 static 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 
140 static 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 
153 static 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 
170 static 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 
186 enum 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 */
296 static 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 		/* Fall through 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  */
323 static 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 
331 enum 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 
337 enum 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 
394 enum 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 
424 enum 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 
439 enum 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 
534 static 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  */
559 static 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 
567 enum 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 	/* Else, fall through 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 
638 static 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 
653 enum 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 
771 static 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 
789 enum 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 
862 static 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 
871 enum 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 
953 void 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  */
970 static 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 
981 static 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 
993 static 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  */
1014 static 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  */
1041 static 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 
1057 static 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 
1073 static 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 
1082 static 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 == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
1089 		sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
1090 	} else if (dev_is_expander(dev)) {
1091 		sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
1092 	} else
1093 		isci_remote_device_ready(ihost, idev);
1094 }
1095 
1096 static 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_DEV) {
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 
1109 static 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 
1120 static 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 
1131 static 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 
1148 static 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 
1159 static 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 
1169 static 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 
1177 static 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 
1188 static 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 
1195 static 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  */
1247 static 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  */
1273 static 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  */
1309 static 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 
1339 enum 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 
1353 static 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 
1371 static 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 
1387 void 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 
1408 enum 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  */
1451 static 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 
1474 static 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))
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 conected to this device.
1508  *
1509  * pointer to new isci_remote_device.
1510  */
1511 static struct isci_remote_device *
1512 isci_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 
1533 void 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_clear_bit();
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  */
1557 enum 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  */
1591 void 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  */
1613 int 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 
1658 enum 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 
1684 int 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 
1690 enum 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 
1696 enum 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 
1710 void 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 }
1727