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