remote_device.c 46.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
/*
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * BSD LICENSE
 *
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of Intel Corporation nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
55
#include <scsi/sas.h>
56 57 58 59 60 61 62 63
#include "isci.h"
#include "port.h"
#include "remote_device.h"
#include "request.h"
#include "remote_node_context.h"
#include "scu_event_codes.h"
#include "task.h"

64
/**
65
 * isci_remote_device_not_ready() - This function is called by the ihost when
66 67 68 69 70
 *    the remote device is not ready. We mark the isci device as ready (not
 *    "ready_for_io") and signal the waiting proccess.
 * @isci_host: This parameter specifies the isci host object.
 * @isci_device: This parameter specifies the remote device
 *
71
 * sci_lock is held on entrance to this function.
72 73 74 75
 */
static void isci_remote_device_not_ready(struct isci_host *ihost,
				  struct isci_remote_device *idev, u32 reason)
{
76
	struct isci_request *ireq;
77

78 79 80
	dev_dbg(&ihost->pdev->dev,
		"%s: isci_device = %p\n", __func__, idev);

81 82
	switch (reason) {
	case SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED:
83
		set_bit(IDEV_GONE, &idev->flags);
84 85 86 87 88 89 90 91 92 93 94
		break;
	case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
		set_bit(IDEV_IO_NCQERROR, &idev->flags);

		/* Kill all outstanding requests for the device. */
		list_for_each_entry(ireq, &idev->reqs_in_process, dev_node) {

			dev_dbg(&ihost->pdev->dev,
				"%s: isci_device = %p request = %p\n",
				__func__, idev, ireq);

95
			sci_controller_terminate_request(ihost,
96
							  idev,
97
							  ireq);
98 99 100
		}
		/* Fall through into the default case... */
	default:
101
		clear_bit(IDEV_IO_READY, &idev->flags);
102 103
		break;
	}
104 105 106
}

/**
107
 * isci_remote_device_ready() - This function is called by the ihost when the
108 109 110 111 112 113 114 115 116 117 118
 *    remote device is ready. We mark the isci device as ready and signal the
 *    waiting proccess.
 * @ihost: our valid isci_host
 * @idev: remote device
 *
 */
static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
{
	dev_dbg(&ihost->pdev->dev,
		"%s: idev = %p\n", __func__, idev);

119
	clear_bit(IDEV_IO_NCQERROR, &idev->flags);
120
	set_bit(IDEV_IO_READY, &idev->flags);
121 122 123 124
	if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
		wake_up(&ihost->eventq);
}

125 126 127 128 129
/* called once the remote node context is ready to be freed.
 * The remote device can now report that its stop operation is complete. none
 */
static void rnc_destruct_done(void *_dev)
{
130
	struct isci_remote_device *idev = _dev;
131

132 133
	BUG_ON(idev->started_request_count != 0);
	sci_change_state(&idev->sm, SCI_DEV_STOPPED);
134
}
135

136
static 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 145
		enum sci_status s;

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 152 153 154 155 156 157
		if (s != SCI_SUCCESS)
			status = s;
	}

	return status;
}

158
enum 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 166 167
	case SCI_DEV_INITIAL:
	case SCI_DEV_FAILED:
	case SCI_DEV_FINAL:
168
	default:
169
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
170 171
			 __func__, state);
		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 180 181
		/* Transition to the stopping state and wait for the
		 * remote node to complete being posted and invalidated.
		 */
182
		sci_change_state(sm, SCI_DEV_STOPPING);
183
		return SCI_SUCCESS;
184 185 186 187 188 189 190 191 192
	case SCI_DEV_READY:
	case SCI_STP_DEV_IDLE:
	case SCI_STP_DEV_CMD:
	case SCI_STP_DEV_NCQ:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_STP_DEV_AWAIT_RESET:
	case SCI_SMP_DEV_IDLE:
	case SCI_SMP_DEV_CMD:
		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 197
			return SCI_SUCCESS;
		} else
198
			return sci_remote_device_terminate_requests(idev);
199
		break;
200
	case SCI_DEV_STOPPING:
201 202 203 204
		/* All requests should have been terminated, but if there is an
		 * attempt to stop a device already in the stopping state, then
		 * try again to terminate.
		 */
205
		return sci_remote_device_terminate_requests(idev);
206 207
	case SCI_DEV_RESETTING:
		sci_change_state(sm, SCI_DEV_STOPPING);
208 209
		return SCI_SUCCESS;
	}
210 211
}

212
enum 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 219 220 221 222 223 224 225 226
	case SCI_DEV_INITIAL:
	case SCI_DEV_STOPPED:
	case SCI_DEV_STARTING:
	case SCI_SMP_DEV_IDLE:
	case SCI_SMP_DEV_CMD:
	case SCI_DEV_STOPPING:
	case SCI_DEV_FAILED:
	case SCI_DEV_RESETTING:
	case SCI_DEV_FINAL:
227
	default:
228
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
229 230
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
231 232 233 234 235 236 237
	case SCI_DEV_READY:
	case SCI_STP_DEV_IDLE:
	case SCI_STP_DEV_CMD:
	case SCI_STP_DEV_NCQ:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_STP_DEV_AWAIT_RESET:
		sci_change_state(sm, SCI_DEV_RESETTING);
238 239
		return SCI_SUCCESS;
	}
240 241
}

242
enum 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 250 251
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
	}
252

253
	sci_change_state(sm, SCI_DEV_READY);
254 255
	return SCI_SUCCESS;
}
256

257
enum 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 266 267 268
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
	}

269
	return sci_remote_node_context_suspend(&idev->rnc,
270
						    suspend_type, NULL, NULL);
271 272
}

273
enum 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 280 281
	enum sci_status status;

	switch (state) {
282 283 284 285 286 287
	case SCI_DEV_INITIAL:
	case SCI_DEV_STOPPED:
	case SCI_DEV_STARTING:
	case SCI_STP_DEV_IDLE:
	case SCI_SMP_DEV_IDLE:
	case SCI_DEV_FINAL:
288
	default:
289
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
290 291
			 __func__, state);
		/* Return the frame back to the controller */
292
		sci_controller_release_frame(ihost, frame_index);
293
		return SCI_FAILURE_INVALID_STATE;
294 295 296 297 298 299
	case SCI_DEV_READY:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_STP_DEV_AWAIT_RESET:
	case SCI_DEV_STOPPING:
	case SCI_DEV_FAILED:
	case SCI_DEV_RESETTING: {
300
		struct isci_request *ireq;
301 302 303
		struct ssp_frame_hdr hdr;
		void *frame_header;
		ssize_t word_cnt;
304

305
		status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
306
								       frame_index,
307
								       &frame_header);
308 309 310
		if (status != SCI_SUCCESS)
			return status;

311 312 313
		word_cnt = sizeof(hdr) / sizeof(u32);
		sci_swab32_cpy(&hdr, frame_header, word_cnt);

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 319 320 321
		} else {
			/* We could not map this tag to a valid IO
			 * request Just toss the frame and continue
			 */
322
			sci_controller_release_frame(ihost, frame_index);
323 324 325
		}
		break;
	}
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 331 332 333 334
								       frame_index,
								       (void **)&hdr);
		if (status != SCI_SUCCESS)
			return status;

335 336
		if (hdr->fis_type == FIS_SETDEVBITS &&
		    (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 342
		} else if (hdr->fis_type == FIS_REGD2H &&
			   (hdr->status & ATA_ERR)) {
343 344 345 346
			/*
			 * Some devices return D2H FIS when an NCQ error is detected.
			 * Treat this like an SDB error FIS ready reason.
			 */
347 348
			idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
			sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
349 350 351
		} else
			status = SCI_FAILURE;

352
		sci_controller_release_frame(ihost, frame_index);
353 354
		break;
	}
355 356
	case SCI_STP_DEV_CMD:
	case SCI_SMP_DEV_CMD:
357 358 359 360
		/* The device does not process any UF received from the hardware while
		 * in this state.  All unsolicited frames are forwarded to the io request
		 * object.
		 */
361
		status = sci_io_request_frame_handler(idev->working_request, frame_index);
362 363 364 365
		break;
	}

	return status;
366 367
}

368
static 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 376 377 378 379 380 381 382
	case SCI_DEV_READY:
	case SCI_STP_DEV_IDLE:
	case SCI_STP_DEV_CMD:
	case SCI_STP_DEV_NCQ:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_STP_DEV_AWAIT_RESET:
	case SCI_SMP_DEV_IDLE:
	case SCI_SMP_DEV_CMD:
383 384 385 386 387 388
		return true;
	default:
		return false;
	}
}

389 390 391 392 393 394 395 396 397 398 399 400
/*
 * called once the remote node context has transisitioned to a ready
 * state (after suspending RX and/or TX due to early D2H fis)
 */
static void atapi_remote_device_resume_done(void *_dev)
{
	struct isci_remote_device *idev = _dev;
	struct isci_request *ireq = idev->working_request;

	sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
}

401
enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
402 403
						     u32 event_code)
{
404
	struct sci_base_state_machine *sm = &idev->sm;
405
	enum sci_remote_device_states state = sm->current_state_id;
406 407 408 409 410 411
	enum sci_status status;

	switch (scu_get_event_type(event_code)) {
	case SCU_EVENT_TYPE_RNC_OPS_MISC:
	case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
	case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
412
		status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
413 414 415 416 417 418
		break;
	case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
		if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
			status = SCI_SUCCESS;

			/* Suspend the associated RNC */
419
			sci_remote_node_context_suspend(&idev->rnc,
420 421 422
							      SCI_SOFTWARE_SUSPENSION,
							      NULL, NULL);

423
			dev_dbg(scirdev_to_dev(idev),
424
				"%s: device: %p event code: %x: %s\n",
425 426
				__func__, idev, event_code,
				is_remote_device_ready(idev)
427 428 429 430 431 432 433
				? "I_T_Nexus_Timeout event"
				: "I_T_Nexus_Timeout event in wrong state");

			break;
		}
	/* Else, fall through and treat as unhandled... */
	default:
434
		dev_dbg(scirdev_to_dev(idev),
435
			"%s: device: %p event code: %x: %s\n",
436 437
			__func__, idev, event_code,
			is_remote_device_ready(idev)
438 439 440 441 442 443 444 445 446
			? "unexpected event"
			: "unexpected event in wrong state");
		status = SCI_FAILURE_INVALID_STATE;
		break;
	}

	if (status != SCI_SUCCESS)
		return status;

447 448 449 450 451 452 453 454 455 456
	if (state == SCI_STP_DEV_ATAPI_ERROR) {
		/* For ATAPI error state resume the RNC right away. */
		if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
		    scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
			return sci_remote_node_context_resume(&idev->rnc,
							      atapi_remote_device_resume_done,
							      idev);
		}
	}

457
	if (state == SCI_STP_DEV_IDLE) {
458 459 460 461 462 463

		/* We pick up suspension events to handle specifically to this
		 * state. We resume the RNC right away.
		 */
		if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
		    scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
464
			status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
465 466 467
	}

	return status;
468 469
}

470
static void sci_remote_device_start_request(struct isci_remote_device *idev,
471
						 struct isci_request *ireq,
472
						 enum sci_status status)
473
{
474
	struct isci_port *iport = idev->owning_port;
475 476 477

	/* cleanup requests that failed after starting on the port */
	if (status != SCI_SUCCESS)
478
		sci_port_complete_io(iport, idev, ireq);
479
	else {
480
		kref_get(&idev->kref);
481
		idev->started_request_count++;
482
	}
483 484
}

485
enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
486
						struct isci_remote_device *idev,
487
						struct isci_request *ireq)
488
{
489
	struct sci_base_state_machine *sm = &idev->sm;
490
	enum sci_remote_device_states state = sm->current_state_id;
491
	struct isci_port *iport = idev->owning_port;
492 493 494
	enum sci_status status;

	switch (state) {
495 496 497 498 499 500 501 502
	case SCI_DEV_INITIAL:
	case SCI_DEV_STOPPED:
	case SCI_DEV_STARTING:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_DEV_STOPPING:
	case SCI_DEV_FAILED:
	case SCI_DEV_RESETTING:
	case SCI_DEV_FINAL:
503
	default:
504
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
505 506
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
507
	case SCI_DEV_READY:
508 509 510 511 512
		/* attempt to start an io request for this device object. The remote
		 * device object will issue the start request for the io and if
		 * successful it will start the request for the port object then
		 * increment its own request count.
		 */
513
		status = sci_port_start_io(iport, idev, ireq);
514 515 516
		if (status != SCI_SUCCESS)
			return status;

517
		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
518 519 520
		if (status != SCI_SUCCESS)
			break;

521
		status = sci_request_start(ireq);
522
		break;
523
	case SCI_STP_DEV_IDLE: {
524 525 526 527 528 529 530 531
		/* handle the start io operation for a sata device that is in
		 * the command idle state. - Evalute the type of IO request to
		 * be started - If its an NCQ request change to NCQ substate -
		 * If its any other command change to the CMD substate
		 *
		 * If this is a softreset we may want to have a different
		 * substate.
		 */
532
		enum sci_remote_device_states new_state;
533
		struct sas_task *task = isci_request_access_task(ireq);
534

535
		status = sci_port_start_io(iport, idev, ireq);
536 537 538
		if (status != SCI_SUCCESS)
			return status;

539
		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
540 541 542
		if (status != SCI_SUCCESS)
			break;

543
		status = sci_request_start(ireq);
544 545 546
		if (status != SCI_SUCCESS)
			break;

547
		if (task->ata_task.use_ncq)
548
			new_state = SCI_STP_DEV_NCQ;
549
		else {
550
			idev->working_request = ireq;
551
			new_state = SCI_STP_DEV_CMD;
552
		}
553
		sci_change_state(sm, new_state);
554 555
		break;
	}
556
	case SCI_STP_DEV_NCQ: {
557 558 559
		struct sas_task *task = isci_request_access_task(ireq);

		if (task->ata_task.use_ncq) {
560
			status = sci_port_start_io(iport, idev, ireq);
561 562 563
			if (status != SCI_SUCCESS)
				return status;

564
			status = sci_remote_node_context_start_io(&idev->rnc, ireq);
565 566 567
			if (status != SCI_SUCCESS)
				break;

568
			status = sci_request_start(ireq);
569 570 571
		} else
			return SCI_FAILURE_INVALID_STATE;
		break;
572
	}
573
	case SCI_STP_DEV_AWAIT_RESET:
574
		return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
575
	case SCI_SMP_DEV_IDLE:
576
		status = sci_port_start_io(iport, idev, ireq);
577 578 579
		if (status != SCI_SUCCESS)
			return status;

580
		status = sci_remote_node_context_start_io(&idev->rnc, ireq);
581 582 583
		if (status != SCI_SUCCESS)
			break;

584
		status = sci_request_start(ireq);
585 586 587
		if (status != SCI_SUCCESS)
			break;

588 589
		idev->working_request = ireq;
		sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
590
		break;
591 592
	case SCI_STP_DEV_CMD:
	case SCI_SMP_DEV_CMD:
593 594 595 596 597 598
		/* device is already handling a command it can not accept new commands
		 * until this one is complete.
		 */
		return SCI_FAILURE_INVALID_STATE;
	}

599
	sci_remote_device_start_request(idev, ireq, status);
600
	return status;
601 602
}

603
static enum sci_status common_complete_io(struct isci_port *iport,
604
					  struct isci_remote_device *idev,
605
					  struct isci_request *ireq)
606
{
607 608
	enum sci_status status;

609
	status = sci_request_complete(ireq);
610 611 612
	if (status != SCI_SUCCESS)
		return status;

613
	status = sci_port_complete_io(iport, idev, ireq);
614 615 616
	if (status != SCI_SUCCESS)
		return status;

617
	sci_remote_device_decrement_request_count(idev);
618 619 620
	return status;
}

621
enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
622
						   struct isci_remote_device *idev,
623
						   struct isci_request *ireq)
624
{
625
	struct sci_base_state_machine *sm = &idev->sm;
626
	enum sci_remote_device_states state = sm->current_state_id;
627
	struct isci_port *iport = idev->owning_port;
628 629 630
	enum sci_status status;

	switch (state) {
631 632 633 634 635 636 637
	case SCI_DEV_INITIAL:
	case SCI_DEV_STOPPED:
	case SCI_DEV_STARTING:
	case SCI_STP_DEV_IDLE:
	case SCI_SMP_DEV_IDLE:
	case SCI_DEV_FAILED:
	case SCI_DEV_FINAL:
638
	default:
639
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
640 641
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
642 643 644
	case SCI_DEV_READY:
	case SCI_STP_DEV_AWAIT_RESET:
	case SCI_DEV_RESETTING:
645
		status = common_complete_io(iport, idev, ireq);
646
		break;
647 648 649
	case SCI_STP_DEV_CMD:
	case SCI_STP_DEV_NCQ:
	case SCI_STP_DEV_NCQ_ERROR:
650
	case SCI_STP_DEV_ATAPI_ERROR:
651
		status = common_complete_io(iport, idev, ireq);
652 653 654
		if (status != SCI_SUCCESS)
			break;

655
		if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
656 657 658 659 660
			/* This request causes hardware error, device needs to be Lun Reset.
			 * So here we force the state machine to IDLE state so the rest IOs
			 * can reach RNC state handler, these IOs will be completed by RNC with
			 * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
			 */
661
			sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
662
		} else if (idev->started_request_count == 0)
663
			sci_change_state(sm, SCI_STP_DEV_IDLE);
664
		break;
665
	case SCI_SMP_DEV_CMD:
666
		status = common_complete_io(iport, idev, ireq);
667 668
		if (status != SCI_SUCCESS)
			break;
669
		sci_change_state(sm, SCI_SMP_DEV_IDLE);
670
		break;
671
	case SCI_DEV_STOPPING:
672
		status = common_complete_io(iport, idev, ireq);
673 674 675
		if (status != SCI_SUCCESS)
			break;

676
		if (idev->started_request_count == 0)
677
			sci_remote_node_context_destruct(&idev->rnc,
678 679
							 rnc_destruct_done,
							 idev);
680 681 682 683
		break;
	}

	if (status != SCI_SUCCESS)
684
		dev_err(scirdev_to_dev(idev),
685
			"%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
686
			"could not complete\n", __func__, iport,
687
			idev, ireq, status);
688
	else
689
		isci_put_device(idev);
690 691

	return status;
692 693
}

694
static void sci_remote_device_continue_request(void *dev)
695
{
696
	struct isci_remote_device *idev = dev;
697 698

	/* we need to check if this request is still valid to continue. */
699
	if (idev->working_request)
700
		sci_controller_continue_io(idev->working_request);
701 702
}

703
enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
704
						  struct isci_remote_device *idev,
705
						  struct isci_request *ireq)
706
{
707
	struct sci_base_state_machine *sm = &idev->sm;
708
	enum sci_remote_device_states state = sm->current_state_id;
709
	struct isci_port *iport = idev->owning_port;
710 711 712
	enum sci_status status;

	switch (state) {
713 714 715 716 717 718 719 720 721
	case SCI_DEV_INITIAL:
	case SCI_DEV_STOPPED:
	case SCI_DEV_STARTING:
	case SCI_SMP_DEV_IDLE:
	case SCI_SMP_DEV_CMD:
	case SCI_DEV_STOPPING:
	case SCI_DEV_FAILED:
	case SCI_DEV_RESETTING:
	case SCI_DEV_FINAL:
722
	default:
723
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
724 725
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
726 727 728 729 730
	case SCI_STP_DEV_IDLE:
	case SCI_STP_DEV_CMD:
	case SCI_STP_DEV_NCQ:
	case SCI_STP_DEV_NCQ_ERROR:
	case SCI_STP_DEV_AWAIT_RESET:
731
		status = sci_port_start_io(iport, idev, ireq);
732 733 734
		if (status != SCI_SUCCESS)
			return status;

735
		status = sci_remote_node_context_start_task(&idev->rnc, ireq);
736 737 738
		if (status != SCI_SUCCESS)
			goto out;

739
		status = sci_request_start(ireq);
740 741 742 743 744 745 746
		if (status != SCI_SUCCESS)
			goto out;

		/* Note: If the remote device state is not IDLE this will
		 * replace the request that probably resulted in the task
		 * management request.
		 */
747
		idev->working_request = ireq;
748
		sci_change_state(sm, SCI_STP_DEV_CMD);
749 750 751 752 753 754 755 756

		/* The remote node context must cleanup the TCi to NCQ mapping
		 * table.  The only way to do this correctly is to either write
		 * to the TLCR register or to invalidate and repost the RNC. In
		 * either case the remote node context state machine will take
		 * the correct action when the remote node context is suspended
		 * and later resumed.
		 */
757
		sci_remote_node_context_suspend(&idev->rnc,
758
				SCI_SOFTWARE_SUSPENSION, NULL, NULL);
759 760
		sci_remote_node_context_resume(&idev->rnc,
				sci_remote_device_continue_request,
761
						    idev);
762 763

	out:
764
		sci_remote_device_start_request(idev, ireq, status);
765 766 767 768 769
		/* We need to let the controller start request handler know that
		 * it can't post TC yet. We will provide a callback function to
		 * post TC when RNC gets resumed.
		 */
		return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
770
	case SCI_DEV_READY:
771
		status = sci_port_start_io(iport, idev, ireq);
772 773 774
		if (status != SCI_SUCCESS)
			return status;

775
		status = sci_remote_node_context_start_task(&idev->rnc, ireq);
776 777 778
		if (status != SCI_SUCCESS)
			break;

779
		status = sci_request_start(ireq);
780 781
		break;
	}
782
	sci_remote_device_start_request(idev, ireq, status);
783 784

	return status;
785 786
}

787
void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
788
{
789
	struct isci_port *iport = idev->owning_port;
790 791
	u32 context;

792 793 794 795
	context = request |
		  (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
		  (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
		  idev->rnc.remote_node_index;
796

797
	sci_controller_post_request(iport->owning_controller, context);
798 799
}

800
/* called once the remote node context has transisitioned to a
801
 * ready state.  This is the indication that the remote device object can also
802
 * transition to ready.
803
 */
804
static void remote_device_resume_done(void *_dev)
805
{
806
	struct isci_remote_device *idev = _dev;
807

808
	if (is_remote_device_ready(idev))
809
		return;
810

811
	/* go 'ready' if we are not already in a ready state */
812
	sci_change_state(&idev->sm, SCI_DEV_READY);
813 814
}

815
static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
816
{
817
	struct isci_remote_device *idev = _dev;
818
	struct isci_host *ihost = idev->owning_port->owning_controller;
819 820 821 822

	/* For NCQ operation we do not issue a isci_remote_device_not_ready().
	 * As a result, avoid sending the ready notification.
	 */
823
	if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
824
		isci_remote_device_ready(ihost, idev);
825 826
}

827
static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
828
{
829
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
830

831
	/* Initial state is a transitional state to the stopped state */
832
	sci_change_state(&idev->sm, SCI_DEV_STOPPED);
833
}
834

835
/**
836
 * sci_remote_device_destruct() - free remote node context and destruct
837 838 839 840 841 842 843 844 845 846 847
 * @remote_device: This parameter specifies the remote device to be destructed.
 *
 * Remote device objects are a limited resource.  As such, they must be
 * protected.  Thus calls to construct and destruct are mutually exclusive and
 * non-reentrant. The return value shall indicate if the device was
 * successfully destructed or if some failure occurred. enum sci_status This value
 * is returned if the device is successfully destructed.
 * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
 * device isn't valid (e.g. it's already been destoryed, the handle isn't
 * valid, etc.).
 */
848
static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
849
{
850
	struct sci_base_state_machine *sm = &idev->sm;
851
	enum sci_remote_device_states state = sm->current_state_id;
852
	struct isci_host *ihost;
853

854
	if (state != SCI_DEV_STOPPED) {
855
		dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
856 857 858 859
			 __func__, state);
		return SCI_FAILURE_INVALID_STATE;
	}

860
	ihost = idev->owning_port->owning_controller;
861
	sci_controller_free_remote_node_context(ihost, idev,
862 863
						     idev->rnc.remote_node_index);
	idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
864
	sci_change_state(sm, SCI_DEV_FINAL);
865 866

	return SCI_SUCCESS;
867
}
868 869 870

/**
 * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
871 872
 * @ihost: This parameter specifies the isci host object.
 * @idev: This parameter specifies the remote device to be freed.
873 874
 *
 */
875
static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
876
{
877 878
	dev_dbg(&ihost->pdev->dev,
		"%s: isci_device = %p\n", __func__, idev);
879 880 881 882 883

	/* There should not be any outstanding io's. All paths to
	 * here should go through isci_remote_device_nuke_requests.
	 * If we hit this condition, we will need a way to complete
	 * io requests in process */
884
	BUG_ON(!list_empty(&idev->reqs_in_process));
885

886
	sci_remote_device_destruct(idev);
887
	list_del_init(&idev->node);
888
	isci_put_device(idev);
889 890
}

891
static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
892
{
893
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
894
	struct isci_host *ihost = idev->owning_port->owning_controller;
895 896 897 898 899
	u32 prev_state;

	/* If we are entering from the stopping state let the SCI User know that
	 * the stop operation has completed.
	 */
900
	prev_state = idev->sm.previous_state_id;
901
	if (prev_state == SCI_DEV_STOPPING)
902
		isci_remote_device_deconstruct(ihost, idev);
903

904
	sci_controller_remote_device_stopped(ihost, idev);
905 906
}

907
static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
908
{
909
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
910
	struct isci_host *ihost = idev->owning_port->owning_controller;
911 912 913 914 915

	isci_remote_device_not_ready(ihost, idev,
				     SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
}

916
static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
917
{
918
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
919
	struct isci_host *ihost = idev->owning_port->owning_controller;
920
	struct domain_device *dev = idev->domain_dev;
921

922
	if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
923
		sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
924
	} else if (dev_is_expander(dev)) {
925
		sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
926
	} else
927
		isci_remote_device_ready(ihost, idev);
928 929
}

930
static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
931
{
932 933
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
	struct domain_device *dev = idev->domain_dev;
934 935

	if (dev->dev_type == SAS_END_DEV) {
936
		struct isci_host *ihost = idev->owning_port->owning_controller;
937

938
		isci_remote_device_not_ready(ihost, idev,
939 940 941 942
					     SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
	}
}

943
static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
944
{
945
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
946

947
	sci_remote_node_context_suspend(
948
		&idev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
949 950
}

951
static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
952
{
953
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
954

955
	sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
956 957
}

958
static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
959
{
960
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
961

962
	idev->working_request = NULL;
963
	if (sci_remote_node_context_is_ready(&idev->rnc)) {
964 965 966
		/*
		 * Since the RNC is ready, it's alright to finish completion
		 * processing (e.g. signal the remote device is ready). */
967
		sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
968
	} else {
969 970
		sci_remote_node_context_resume(&idev->rnc,
			sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
971
			idev);
972 973 974
	}
}

975
static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
976
{
977
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
978
	struct isci_host *ihost = idev->owning_port->owning_controller;
979

980
	BUG_ON(idev->working_request == NULL);
981

982
	isci_remote_device_not_ready(ihost, idev,
983 984 985
				     SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
}

986
static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
987
{
988
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
989
	struct isci_host *ihost = idev->owning_port->owning_controller;
990

991
	if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
992
		isci_remote_device_not_ready(ihost, idev,
993
					     idev->not_ready_reason);
994 995
}

996
static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
997
{
998
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
999
	struct isci_host *ihost = idev->owning_port->owning_controller;
1000

1001
	isci_remote_device_ready(ihost, idev);
1002 1003
}

1004
static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1005
{
1006
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1007
	struct isci_host *ihost = idev->owning_port->owning_controller;
1008

1009
	BUG_ON(idev->working_request == NULL);
1010

1011
	isci_remote_device_not_ready(ihost, idev,
1012 1013 1014
				     SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
}

1015
static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1016
{
1017
	struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1018

1019
	idev->working_request = NULL;
1020
}
1021

1022
static const struct sci_base_state sci_remote_device_state_table[] = {
1023
	[SCI_DEV_INITIAL] = {
1024
		.enter_state = sci_remote_device_initial_state_enter,
1025
	},
1026
	[SCI_DEV_STOPPED] = {
1027
		.enter_state = sci_remote_device_stopped_state_enter,
1028
	},
1029
	[SCI_DEV_STARTING] = {
1030
		.enter_state = sci_remote_device_starting_state_enter,
1031
	},
1032
	[SCI_DEV_READY] = {
1033 1034
		.enter_state = sci_remote_device_ready_state_enter,
		.exit_state  = sci_remote_device_ready_state_exit
1035
	},
1036
	[SCI_STP_DEV_IDLE] = {
1037
		.enter_state = sci_stp_remote_device_ready_idle_substate_enter,
1038
	},
1039
	[SCI_STP_DEV_CMD] = {
1040
		.enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
1041
	},
1042 1043
	[SCI_STP_DEV_NCQ] = { },
	[SCI_STP_DEV_NCQ_ERROR] = {
1044
		.enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
1045
	},
1046
	[SCI_STP_DEV_ATAPI_ERROR] = { },
1047 1048
	[SCI_STP_DEV_AWAIT_RESET] = { },
	[SCI_SMP_DEV_IDLE] = {
1049
		.enter_state = sci_smp_remote_device_ready_idle_substate_enter,
1050
	},
1051
	[SCI_SMP_DEV_CMD] = {
1052 1053
		.enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
		.exit_state  = sci_smp_remote_device_ready_cmd_substate_exit,
1054
	},
1055 1056 1057
	[SCI_DEV_STOPPING] = { },
	[SCI_DEV_FAILED] = { },
	[SCI_DEV_RESETTING] = {
1058 1059
		.enter_state = sci_remote_device_resetting_state_enter,
		.exit_state  = sci_remote_device_resetting_state_exit
1060
	},
1061
	[SCI_DEV_FINAL] = { },
1062 1063 1064
};

/**