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