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