drivers/scsi/isci/remote_device.c

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