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