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