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