Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * This file is provided under a dual BSD/GPLv2 license.  When using or
0003  * redistributing this file, you may do so under either license.
0004  *
0005  * GPL LICENSE SUMMARY
0006  *
0007  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
0008  *
0009  * This program is free software; you can redistribute it and/or modify
0010  * it under the terms of version 2 of the GNU General Public License as
0011  * published by the Free Software Foundation.
0012  *
0013  * This program is distributed in the hope that it will be useful, but
0014  * WITHOUT ANY WARRANTY; without even the implied warranty of
0015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0016  * General Public License for more details.
0017  *
0018  * You should have received a copy of the GNU General Public License
0019  * along with this program; if not, write to the Free Software
0020  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
0021  * The full GNU General Public License is included in this distribution
0022  * in the file called LICENSE.GPL.
0023  *
0024  * BSD LICENSE
0025  *
0026  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
0027  * All rights reserved.
0028  *
0029  * Redistribution and use in source and binary forms, with or without
0030  * modification, are permitted provided that the following conditions
0031  * are met:
0032  *
0033  *   * Redistributions of source code must retain the above copyright
0034  *     notice, this list of conditions and the following disclaimer.
0035  *   * Redistributions in binary form must reproduce the above copyright
0036  *     notice, this list of conditions and the following disclaimer in
0037  *     the documentation and/or other materials provided with the
0038  *     distribution.
0039  *   * Neither the name of Intel Corporation nor the names of its
0040  *     contributors may be used to endorse or promote products derived
0041  *     from this software without specific prior written permission.
0042  *
0043  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
0044  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
0045  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
0046  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
0047  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
0048  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
0049  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
0050  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
0051  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
0052  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
0053  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
0054  */
0055 #include <scsi/sas.h>
0056 #include <linux/bitops.h>
0057 #include "isci.h"
0058 #include "port.h"
0059 #include "remote_device.h"
0060 #include "request.h"
0061 #include "remote_node_context.h"
0062 #include "scu_event_codes.h"
0063 #include "task.h"
0064 
0065 #undef C
0066 #define C(a) (#a)
0067 const char *dev_state_name(enum sci_remote_device_states state)
0068 {
0069     static const char * const strings[] = REMOTE_DEV_STATES;
0070 
0071     return strings[state];
0072 }
0073 #undef C
0074 
0075 enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
0076                       enum sci_remote_node_suspension_reasons reason)
0077 {
0078     return sci_remote_node_context_suspend(&idev->rnc, reason,
0079                            SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT);
0080 }
0081 
0082 /**
0083  * isci_remote_device_ready() - This function is called by the ihost when the
0084  *    remote device is ready. We mark the isci device as ready and signal the
0085  *    waiting proccess.
0086  * @ihost: our valid isci_host
0087  * @idev: remote device
0088  *
0089  */
0090 static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote_device *idev)
0091 {
0092     dev_dbg(&ihost->pdev->dev,
0093         "%s: idev = %p\n", __func__, idev);
0094 
0095     clear_bit(IDEV_IO_NCQERROR, &idev->flags);
0096     set_bit(IDEV_IO_READY, &idev->flags);
0097     if (test_and_clear_bit(IDEV_START_PENDING, &idev->flags))
0098         wake_up(&ihost->eventq);
0099 }
0100 
0101 static enum sci_status sci_remote_device_terminate_req(
0102     struct isci_host *ihost,
0103     struct isci_remote_device *idev,
0104     int check_abort,
0105     struct isci_request *ireq)
0106 {
0107     if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
0108         (ireq->target_device != idev) ||
0109         (check_abort && !test_bit(IREQ_PENDING_ABORT, &ireq->flags)))
0110         return SCI_SUCCESS;
0111 
0112     dev_dbg(&ihost->pdev->dev,
0113         "%s: idev=%p; flags=%lx; req=%p; req target=%p\n",
0114         __func__, idev, idev->flags, ireq, ireq->target_device);
0115 
0116     set_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
0117 
0118     return sci_controller_terminate_request(ihost, idev, ireq);
0119 }
0120 
0121 static enum sci_status sci_remote_device_terminate_reqs_checkabort(
0122     struct isci_remote_device *idev,
0123     int chk)
0124 {
0125     struct isci_host *ihost = idev->owning_port->owning_controller;
0126     enum sci_status status  = SCI_SUCCESS;
0127     u32 i;
0128 
0129     for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
0130         struct isci_request *ireq = ihost->reqs[i];
0131         enum sci_status s;
0132 
0133         s = sci_remote_device_terminate_req(ihost, idev, chk, ireq);
0134         if (s != SCI_SUCCESS)
0135             status = s;
0136     }
0137     return status;
0138 }
0139 
0140 static bool isci_compare_suspendcount(
0141     struct isci_remote_device *idev,
0142     u32 localcount)
0143 {
0144     smp_rmb();
0145 
0146     /* Check for a change in the suspend count, or the RNC
0147      * being destroyed.
0148      */
0149     return (localcount != idev->rnc.suspend_count)
0150         || sci_remote_node_context_is_being_destroyed(&idev->rnc);
0151 }
0152 
0153 static bool isci_check_reqterm(
0154     struct isci_host *ihost,
0155     struct isci_remote_device *idev,
0156     struct isci_request *ireq,
0157     u32 localcount)
0158 {
0159     unsigned long flags;
0160     bool res;
0161 
0162     spin_lock_irqsave(&ihost->scic_lock, flags);
0163     res = isci_compare_suspendcount(idev, localcount)
0164         && !test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
0165     spin_unlock_irqrestore(&ihost->scic_lock, flags);
0166 
0167     return res;
0168 }
0169 
0170 static bool isci_check_devempty(
0171     struct isci_host *ihost,
0172     struct isci_remote_device *idev,
0173     u32 localcount)
0174 {
0175     unsigned long flags;
0176     bool res;
0177 
0178     spin_lock_irqsave(&ihost->scic_lock, flags);
0179     res = isci_compare_suspendcount(idev, localcount)
0180         && idev->started_request_count == 0;
0181     spin_unlock_irqrestore(&ihost->scic_lock, flags);
0182 
0183     return res;
0184 }
0185 
0186 enum sci_status isci_remote_device_terminate_requests(
0187     struct isci_host *ihost,
0188     struct isci_remote_device *idev,
0189     struct isci_request *ireq)
0190 {
0191     enum sci_status status = SCI_SUCCESS;
0192     unsigned long flags;
0193     u32 rnc_suspend_count;
0194 
0195     spin_lock_irqsave(&ihost->scic_lock, flags);
0196 
0197     if (isci_get_device(idev) == NULL) {
0198         dev_dbg(&ihost->pdev->dev, "%s: failed isci_get_device(idev=%p)\n",
0199             __func__, idev);
0200         spin_unlock_irqrestore(&ihost->scic_lock, flags);
0201         status = SCI_FAILURE;
0202     } else {
0203         /* If already suspended, don't wait for another suspension. */
0204         smp_rmb();
0205         rnc_suspend_count
0206             = sci_remote_node_context_is_suspended(&idev->rnc)
0207                 ? 0 : idev->rnc.suspend_count;
0208 
0209         dev_dbg(&ihost->pdev->dev,
0210             "%s: idev=%p, ireq=%p; started_request_count=%d, "
0211                 "rnc_suspend_count=%d, rnc.suspend_count=%d"
0212                 "about to wait\n",
0213             __func__, idev, ireq, idev->started_request_count,
0214             rnc_suspend_count, idev->rnc.suspend_count);
0215 
0216         #define MAX_SUSPEND_MSECS 10000
0217         if (ireq) {
0218             /* Terminate a specific TC. */
0219             set_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
0220             sci_remote_device_terminate_req(ihost, idev, 0, ireq);
0221             spin_unlock_irqrestore(&ihost->scic_lock, flags);
0222             if (!wait_event_timeout(ihost->eventq,
0223                         isci_check_reqterm(ihost, idev, ireq,
0224                                    rnc_suspend_count),
0225                         msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
0226 
0227                 dev_warn(&ihost->pdev->dev, "%s host%d timeout single\n",
0228                      __func__, ihost->id);
0229                 dev_dbg(&ihost->pdev->dev,
0230                      "%s: ******* Timeout waiting for "
0231                      "suspend; idev=%p, current state %s; "
0232                      "started_request_count=%d, flags=%lx\n\t"
0233                      "rnc_suspend_count=%d, rnc.suspend_count=%d "
0234                      "RNC: current state %s, current "
0235                      "suspend_type %x dest state %d;\n"
0236                      "ireq=%p, ireq->flags = %lx\n",
0237                      __func__, idev,
0238                      dev_state_name(idev->sm.current_state_id),
0239                      idev->started_request_count, idev->flags,
0240                      rnc_suspend_count, idev->rnc.suspend_count,
0241                      rnc_state_name(idev->rnc.sm.current_state_id),
0242                      idev->rnc.suspend_type,
0243                      idev->rnc.destination_state,
0244                      ireq, ireq->flags);
0245             }
0246             spin_lock_irqsave(&ihost->scic_lock, flags);
0247             clear_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
0248             if (!test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
0249                 isci_free_tag(ihost, ireq->io_tag);
0250             spin_unlock_irqrestore(&ihost->scic_lock, flags);
0251         } else {
0252             /* Terminate all TCs. */
0253             sci_remote_device_terminate_requests(idev);
0254             spin_unlock_irqrestore(&ihost->scic_lock, flags);
0255             if (!wait_event_timeout(ihost->eventq,
0256                         isci_check_devempty(ihost, idev,
0257                                     rnc_suspend_count),
0258                         msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
0259 
0260                 dev_warn(&ihost->pdev->dev, "%s host%d timeout all\n",
0261                      __func__, ihost->id);
0262                 dev_dbg(&ihost->pdev->dev,
0263                     "%s: ******* Timeout waiting for "
0264                     "suspend; idev=%p, current state %s; "
0265                     "started_request_count=%d, flags=%lx\n\t"
0266                     "rnc_suspend_count=%d, "
0267                     "RNC: current state %s, "
0268                     "rnc.suspend_count=%d, current "
0269                     "suspend_type %x dest state %d\n",
0270                     __func__, idev,
0271                     dev_state_name(idev->sm.current_state_id),
0272                     idev->started_request_count, idev->flags,
0273                     rnc_suspend_count,
0274                     rnc_state_name(idev->rnc.sm.current_state_id),
0275                     idev->rnc.suspend_count,
0276                     idev->rnc.suspend_type,
0277                     idev->rnc.destination_state);
0278             }
0279         }
0280         dev_dbg(&ihost->pdev->dev, "%s: idev=%p, wait done\n",
0281             __func__, idev);
0282         isci_put_device(idev);
0283     }
0284     return status;
0285 }
0286 
0287 /**
0288 * isci_remote_device_not_ready() - This function is called by the ihost when
0289 *    the remote device is not ready. We mark the isci device as ready (not
0290 *    "ready_for_io") and signal the waiting proccess.
0291 * @ihost: This parameter specifies the isci host object.
0292 * @idev: This parameter specifies the remote device
0293 * @reason: Reason to switch on
0294 *
0295 * sci_lock is held on entrance to this function.
0296 */
0297 static void isci_remote_device_not_ready(struct isci_host *ihost,
0298                      struct isci_remote_device *idev,
0299                      u32 reason)
0300 {
0301     dev_dbg(&ihost->pdev->dev,
0302         "%s: isci_device = %p; reason = %d\n", __func__, idev, reason);
0303 
0304     switch (reason) {
0305     case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
0306         set_bit(IDEV_IO_NCQERROR, &idev->flags);
0307 
0308         /* Suspend the remote device so the I/O can be terminated. */
0309         sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
0310 
0311         /* Kill all outstanding requests for the device. */
0312         sci_remote_device_terminate_requests(idev);
0313 
0314         fallthrough;    /* into the default case */
0315     default:
0316         clear_bit(IDEV_IO_READY, &idev->flags);
0317         break;
0318     }
0319 }
0320 
0321 /* called once the remote node context is ready to be freed.
0322  * The remote device can now report that its stop operation is complete. none
0323  */
0324 static void rnc_destruct_done(void *_dev)
0325 {
0326     struct isci_remote_device *idev = _dev;
0327 
0328     BUG_ON(idev->started_request_count != 0);
0329     sci_change_state(&idev->sm, SCI_DEV_STOPPED);
0330 }
0331 
0332 enum sci_status sci_remote_device_terminate_requests(
0333     struct isci_remote_device *idev)
0334 {
0335     return sci_remote_device_terminate_reqs_checkabort(idev, 0);
0336 }
0337 
0338 enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
0339                     u32 timeout)
0340 {
0341     struct sci_base_state_machine *sm = &idev->sm;
0342     enum sci_remote_device_states state = sm->current_state_id;
0343 
0344     switch (state) {
0345     case SCI_DEV_INITIAL:
0346     case SCI_DEV_FAILED:
0347     case SCI_DEV_FINAL:
0348     default:
0349         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0350              __func__, dev_state_name(state));
0351         return SCI_FAILURE_INVALID_STATE;
0352     case SCI_DEV_STOPPED:
0353         return SCI_SUCCESS;
0354     case SCI_DEV_STARTING:
0355         /* device not started so there had better be no requests */
0356         BUG_ON(idev->started_request_count != 0);
0357         sci_remote_node_context_destruct(&idev->rnc,
0358                               rnc_destruct_done, idev);
0359         /* Transition to the stopping state and wait for the
0360          * remote node to complete being posted and invalidated.
0361          */
0362         sci_change_state(sm, SCI_DEV_STOPPING);
0363         return SCI_SUCCESS;
0364     case SCI_DEV_READY:
0365     case SCI_STP_DEV_IDLE:
0366     case SCI_STP_DEV_CMD:
0367     case SCI_STP_DEV_NCQ:
0368     case SCI_STP_DEV_NCQ_ERROR:
0369     case SCI_STP_DEV_AWAIT_RESET:
0370     case SCI_SMP_DEV_IDLE:
0371     case SCI_SMP_DEV_CMD:
0372         sci_change_state(sm, SCI_DEV_STOPPING);
0373         if (idev->started_request_count == 0)
0374             sci_remote_node_context_destruct(&idev->rnc,
0375                              rnc_destruct_done,
0376                              idev);
0377         else {
0378             sci_remote_device_suspend(
0379                 idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
0380             sci_remote_device_terminate_requests(idev);
0381         }
0382         return SCI_SUCCESS;
0383     case SCI_DEV_STOPPING:
0384         /* All requests should have been terminated, but if there is an
0385          * attempt to stop a device already in the stopping state, then
0386          * try again to terminate.
0387          */
0388         return sci_remote_device_terminate_requests(idev);
0389     case SCI_DEV_RESETTING:
0390         sci_change_state(sm, SCI_DEV_STOPPING);
0391         return SCI_SUCCESS;
0392     }
0393 }
0394 
0395 enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
0396 {
0397     struct sci_base_state_machine *sm = &idev->sm;
0398     enum sci_remote_device_states state = sm->current_state_id;
0399 
0400     switch (state) {
0401     case SCI_DEV_INITIAL:
0402     case SCI_DEV_STOPPED:
0403     case SCI_DEV_STARTING:
0404     case SCI_SMP_DEV_IDLE:
0405     case SCI_SMP_DEV_CMD:
0406     case SCI_DEV_STOPPING:
0407     case SCI_DEV_FAILED:
0408     case SCI_DEV_RESETTING:
0409     case SCI_DEV_FINAL:
0410     default:
0411         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0412              __func__, dev_state_name(state));
0413         return SCI_FAILURE_INVALID_STATE;
0414     case SCI_DEV_READY:
0415     case SCI_STP_DEV_IDLE:
0416     case SCI_STP_DEV_CMD:
0417     case SCI_STP_DEV_NCQ:
0418     case SCI_STP_DEV_NCQ_ERROR:
0419     case SCI_STP_DEV_AWAIT_RESET:
0420         sci_change_state(sm, SCI_DEV_RESETTING);
0421         return SCI_SUCCESS;
0422     }
0423 }
0424 
0425 enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev)
0426 {
0427     struct sci_base_state_machine *sm = &idev->sm;
0428     enum sci_remote_device_states state = sm->current_state_id;
0429 
0430     if (state != SCI_DEV_RESETTING) {
0431         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0432              __func__, dev_state_name(state));
0433         return SCI_FAILURE_INVALID_STATE;
0434     }
0435 
0436     sci_change_state(sm, SCI_DEV_READY);
0437     return SCI_SUCCESS;
0438 }
0439 
0440 enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
0441                              u32 frame_index)
0442 {
0443     struct sci_base_state_machine *sm = &idev->sm;
0444     enum sci_remote_device_states state = sm->current_state_id;
0445     struct isci_host *ihost = idev->owning_port->owning_controller;
0446     enum sci_status status;
0447 
0448     switch (state) {
0449     case SCI_DEV_INITIAL:
0450     case SCI_DEV_STOPPED:
0451     case SCI_DEV_STARTING:
0452     case SCI_STP_DEV_IDLE:
0453     case SCI_SMP_DEV_IDLE:
0454     case SCI_DEV_FINAL:
0455     default:
0456         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0457              __func__, dev_state_name(state));
0458         /* Return the frame back to the controller */
0459         sci_controller_release_frame(ihost, frame_index);
0460         return SCI_FAILURE_INVALID_STATE;
0461     case SCI_DEV_READY:
0462     case SCI_STP_DEV_NCQ_ERROR:
0463     case SCI_STP_DEV_AWAIT_RESET:
0464     case SCI_DEV_STOPPING:
0465     case SCI_DEV_FAILED:
0466     case SCI_DEV_RESETTING: {
0467         struct isci_request *ireq;
0468         struct ssp_frame_hdr hdr;
0469         void *frame_header;
0470         ssize_t word_cnt;
0471 
0472         status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
0473                                        frame_index,
0474                                        &frame_header);
0475         if (status != SCI_SUCCESS)
0476             return status;
0477 
0478         word_cnt = sizeof(hdr) / sizeof(u32);
0479         sci_swab32_cpy(&hdr, frame_header, word_cnt);
0480 
0481         ireq = sci_request_by_tag(ihost, be16_to_cpu(hdr.tag));
0482         if (ireq && ireq->target_device == idev) {
0483             /* The IO request is now in charge of releasing the frame */
0484             status = sci_io_request_frame_handler(ireq, frame_index);
0485         } else {
0486             /* We could not map this tag to a valid IO
0487              * request Just toss the frame and continue
0488              */
0489             sci_controller_release_frame(ihost, frame_index);
0490         }
0491         break;
0492     }
0493     case SCI_STP_DEV_NCQ: {
0494         struct dev_to_host_fis *hdr;
0495 
0496         status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
0497                                        frame_index,
0498                                        (void **)&hdr);
0499         if (status != SCI_SUCCESS)
0500             return status;
0501 
0502         if (hdr->fis_type == FIS_SETDEVBITS &&
0503             (hdr->status & ATA_ERR)) {
0504             idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
0505 
0506             /* TODO Check sactive and complete associated IO if any. */
0507             sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
0508         } else if (hdr->fis_type == FIS_REGD2H &&
0509                (hdr->status & ATA_ERR)) {
0510             /*
0511              * Some devices return D2H FIS when an NCQ error is detected.
0512              * Treat this like an SDB error FIS ready reason.
0513              */
0514             idev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
0515             sci_change_state(&idev->sm, SCI_STP_DEV_NCQ_ERROR);
0516         } else
0517             status = SCI_FAILURE;
0518 
0519         sci_controller_release_frame(ihost, frame_index);
0520         break;
0521     }
0522     case SCI_STP_DEV_CMD:
0523     case SCI_SMP_DEV_CMD:
0524         /* The device does not process any UF received from the hardware while
0525          * in this state.  All unsolicited frames are forwarded to the io request
0526          * object.
0527          */
0528         status = sci_io_request_frame_handler(idev->working_request, frame_index);
0529         break;
0530     }
0531 
0532     return status;
0533 }
0534 
0535 static bool is_remote_device_ready(struct isci_remote_device *idev)
0536 {
0537 
0538     struct sci_base_state_machine *sm = &idev->sm;
0539     enum sci_remote_device_states state = sm->current_state_id;
0540 
0541     switch (state) {
0542     case SCI_DEV_READY:
0543     case SCI_STP_DEV_IDLE:
0544     case SCI_STP_DEV_CMD:
0545     case SCI_STP_DEV_NCQ:
0546     case SCI_STP_DEV_NCQ_ERROR:
0547     case SCI_STP_DEV_AWAIT_RESET:
0548     case SCI_SMP_DEV_IDLE:
0549     case SCI_SMP_DEV_CMD:
0550         return true;
0551     default:
0552         return false;
0553     }
0554 }
0555 
0556 /*
0557  * called once the remote node context has transisitioned to a ready
0558  * state (after suspending RX and/or TX due to early D2H fis)
0559  */
0560 static void atapi_remote_device_resume_done(void *_dev)
0561 {
0562     struct isci_remote_device *idev = _dev;
0563     struct isci_request *ireq = idev->working_request;
0564 
0565     sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
0566 }
0567 
0568 enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
0569                              u32 event_code)
0570 {
0571     enum sci_status status;
0572     struct sci_base_state_machine *sm = &idev->sm;
0573     enum sci_remote_device_states state = sm->current_state_id;
0574 
0575     switch (scu_get_event_type(event_code)) {
0576     case SCU_EVENT_TYPE_RNC_OPS_MISC:
0577     case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
0578     case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
0579         status = sci_remote_node_context_event_handler(&idev->rnc, event_code);
0580         break;
0581     case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
0582         if (scu_get_event_code(event_code) == SCU_EVENT_IT_NEXUS_TIMEOUT) {
0583             status = SCI_SUCCESS;
0584 
0585             /* Suspend the associated RNC */
0586             sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
0587 
0588             dev_dbg(scirdev_to_dev(idev),
0589                 "%s: device: %p event code: %x: %s\n",
0590                 __func__, idev, event_code,
0591                 is_remote_device_ready(idev)
0592                 ? "I_T_Nexus_Timeout event"
0593                 : "I_T_Nexus_Timeout event in wrong state");
0594 
0595             break;
0596         }
0597         fallthrough;    /* and treat as unhandled */
0598     default:
0599         dev_dbg(scirdev_to_dev(idev),
0600             "%s: device: %p event code: %x: %s\n",
0601             __func__, idev, event_code,
0602             is_remote_device_ready(idev)
0603             ? "unexpected event"
0604             : "unexpected event in wrong state");
0605         status = SCI_FAILURE_INVALID_STATE;
0606         break;
0607     }
0608 
0609     if (status != SCI_SUCCESS)
0610         return status;
0611 
0612     /* Decode device-specific states that may require an RNC resume during
0613      * normal operation.  When the abort path is active, these resumes are
0614      * managed when the abort path exits.
0615      */
0616     if (state == SCI_STP_DEV_ATAPI_ERROR) {
0617         /* For ATAPI error state resume the RNC right away. */
0618         if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
0619             scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
0620             return sci_remote_node_context_resume(&idev->rnc,
0621                                   atapi_remote_device_resume_done,
0622                                   idev);
0623         }
0624     }
0625 
0626     if (state == SCI_STP_DEV_IDLE) {
0627 
0628         /* We pick up suspension events to handle specifically to this
0629          * state. We resume the RNC right away.
0630          */
0631         if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
0632             scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX)
0633             status = sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
0634     }
0635 
0636     return status;
0637 }
0638 
0639 static void sci_remote_device_start_request(struct isci_remote_device *idev,
0640                          struct isci_request *ireq,
0641                          enum sci_status status)
0642 {
0643     struct isci_port *iport = idev->owning_port;
0644 
0645     /* cleanup requests that failed after starting on the port */
0646     if (status != SCI_SUCCESS)
0647         sci_port_complete_io(iport, idev, ireq);
0648     else {
0649         kref_get(&idev->kref);
0650         idev->started_request_count++;
0651     }
0652 }
0653 
0654 enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
0655                         struct isci_remote_device *idev,
0656                         struct isci_request *ireq)
0657 {
0658     struct sci_base_state_machine *sm = &idev->sm;
0659     enum sci_remote_device_states state = sm->current_state_id;
0660     struct isci_port *iport = idev->owning_port;
0661     enum sci_status status;
0662 
0663     switch (state) {
0664     case SCI_DEV_INITIAL:
0665     case SCI_DEV_STOPPED:
0666     case SCI_DEV_STARTING:
0667     case SCI_STP_DEV_NCQ_ERROR:
0668     case SCI_DEV_STOPPING:
0669     case SCI_DEV_FAILED:
0670     case SCI_DEV_RESETTING:
0671     case SCI_DEV_FINAL:
0672     default:
0673         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0674              __func__, dev_state_name(state));
0675         return SCI_FAILURE_INVALID_STATE;
0676     case SCI_DEV_READY:
0677         /* attempt to start an io request for this device object. The remote
0678          * device object will issue the start request for the io and if
0679          * successful it will start the request for the port object then
0680          * increment its own request count.
0681          */
0682         status = sci_port_start_io(iport, idev, ireq);
0683         if (status != SCI_SUCCESS)
0684             return status;
0685 
0686         status = sci_remote_node_context_start_io(&idev->rnc, ireq);
0687         if (status != SCI_SUCCESS)
0688             break;
0689 
0690         status = sci_request_start(ireq);
0691         break;
0692     case SCI_STP_DEV_IDLE: {
0693         /* handle the start io operation for a sata device that is in
0694          * the command idle state. - Evalute the type of IO request to
0695          * be started - If its an NCQ request change to NCQ substate -
0696          * If its any other command change to the CMD substate
0697          *
0698          * If this is a softreset we may want to have a different
0699          * substate.
0700          */
0701         enum sci_remote_device_states new_state;
0702         struct sas_task *task = isci_request_access_task(ireq);
0703 
0704         status = sci_port_start_io(iport, idev, ireq);
0705         if (status != SCI_SUCCESS)
0706             return status;
0707 
0708         status = sci_remote_node_context_start_io(&idev->rnc, ireq);
0709         if (status != SCI_SUCCESS)
0710             break;
0711 
0712         status = sci_request_start(ireq);
0713         if (status != SCI_SUCCESS)
0714             break;
0715 
0716         if (task->ata_task.use_ncq)
0717             new_state = SCI_STP_DEV_NCQ;
0718         else {
0719             idev->working_request = ireq;
0720             new_state = SCI_STP_DEV_CMD;
0721         }
0722         sci_change_state(sm, new_state);
0723         break;
0724     }
0725     case SCI_STP_DEV_NCQ: {
0726         struct sas_task *task = isci_request_access_task(ireq);
0727 
0728         if (task->ata_task.use_ncq) {
0729             status = sci_port_start_io(iport, idev, ireq);
0730             if (status != SCI_SUCCESS)
0731                 return status;
0732 
0733             status = sci_remote_node_context_start_io(&idev->rnc, ireq);
0734             if (status != SCI_SUCCESS)
0735                 break;
0736 
0737             status = sci_request_start(ireq);
0738         } else
0739             return SCI_FAILURE_INVALID_STATE;
0740         break;
0741     }
0742     case SCI_STP_DEV_AWAIT_RESET:
0743         return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
0744     case SCI_SMP_DEV_IDLE:
0745         status = sci_port_start_io(iport, idev, ireq);
0746         if (status != SCI_SUCCESS)
0747             return status;
0748 
0749         status = sci_remote_node_context_start_io(&idev->rnc, ireq);
0750         if (status != SCI_SUCCESS)
0751             break;
0752 
0753         status = sci_request_start(ireq);
0754         if (status != SCI_SUCCESS)
0755             break;
0756 
0757         idev->working_request = ireq;
0758         sci_change_state(&idev->sm, SCI_SMP_DEV_CMD);
0759         break;
0760     case SCI_STP_DEV_CMD:
0761     case SCI_SMP_DEV_CMD:
0762         /* device is already handling a command it can not accept new commands
0763          * until this one is complete.
0764          */
0765         return SCI_FAILURE_INVALID_STATE;
0766     }
0767 
0768     sci_remote_device_start_request(idev, ireq, status);
0769     return status;
0770 }
0771 
0772 static enum sci_status common_complete_io(struct isci_port *iport,
0773                       struct isci_remote_device *idev,
0774                       struct isci_request *ireq)
0775 {
0776     enum sci_status status;
0777 
0778     status = sci_request_complete(ireq);
0779     if (status != SCI_SUCCESS)
0780         return status;
0781 
0782     status = sci_port_complete_io(iport, idev, ireq);
0783     if (status != SCI_SUCCESS)
0784         return status;
0785 
0786     sci_remote_device_decrement_request_count(idev);
0787     return status;
0788 }
0789 
0790 enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
0791                            struct isci_remote_device *idev,
0792                            struct isci_request *ireq)
0793 {
0794     struct sci_base_state_machine *sm = &idev->sm;
0795     enum sci_remote_device_states state = sm->current_state_id;
0796     struct isci_port *iport = idev->owning_port;
0797     enum sci_status status;
0798 
0799     switch (state) {
0800     case SCI_DEV_INITIAL:
0801     case SCI_DEV_STOPPED:
0802     case SCI_DEV_STARTING:
0803     case SCI_STP_DEV_IDLE:
0804     case SCI_SMP_DEV_IDLE:
0805     case SCI_DEV_FAILED:
0806     case SCI_DEV_FINAL:
0807     default:
0808         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0809              __func__, dev_state_name(state));
0810         return SCI_FAILURE_INVALID_STATE;
0811     case SCI_DEV_READY:
0812     case SCI_STP_DEV_AWAIT_RESET:
0813     case SCI_DEV_RESETTING:
0814         status = common_complete_io(iport, idev, ireq);
0815         break;
0816     case SCI_STP_DEV_CMD:
0817     case SCI_STP_DEV_NCQ:
0818     case SCI_STP_DEV_NCQ_ERROR:
0819     case SCI_STP_DEV_ATAPI_ERROR:
0820         status = common_complete_io(iport, idev, ireq);
0821         if (status != SCI_SUCCESS)
0822             break;
0823 
0824         if (ireq->sci_status == SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED) {
0825             /* This request causes hardware error, device needs to be Lun Reset.
0826              * So here we force the state machine to IDLE state so the rest IOs
0827              * can reach RNC state handler, these IOs will be completed by RNC with
0828              * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
0829              */
0830             sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
0831         } else if (idev->started_request_count == 0)
0832             sci_change_state(sm, SCI_STP_DEV_IDLE);
0833         break;
0834     case SCI_SMP_DEV_CMD:
0835         status = common_complete_io(iport, idev, ireq);
0836         if (status != SCI_SUCCESS)
0837             break;
0838         sci_change_state(sm, SCI_SMP_DEV_IDLE);
0839         break;
0840     case SCI_DEV_STOPPING:
0841         status = common_complete_io(iport, idev, ireq);
0842         if (status != SCI_SUCCESS)
0843             break;
0844 
0845         if (idev->started_request_count == 0)
0846             sci_remote_node_context_destruct(&idev->rnc,
0847                              rnc_destruct_done,
0848                              idev);
0849         break;
0850     }
0851 
0852     if (status != SCI_SUCCESS)
0853         dev_err(scirdev_to_dev(idev),
0854             "%s: Port:0x%p Device:0x%p Request:0x%p Status:0x%x "
0855             "could not complete\n", __func__, iport,
0856             idev, ireq, status);
0857     else
0858         isci_put_device(idev);
0859 
0860     return status;
0861 }
0862 
0863 static void sci_remote_device_continue_request(void *dev)
0864 {
0865     struct isci_remote_device *idev = dev;
0866 
0867     /* we need to check if this request is still valid to continue. */
0868     if (idev->working_request)
0869         sci_controller_continue_io(idev->working_request);
0870 }
0871 
0872 enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
0873                           struct isci_remote_device *idev,
0874                           struct isci_request *ireq)
0875 {
0876     struct sci_base_state_machine *sm = &idev->sm;
0877     enum sci_remote_device_states state = sm->current_state_id;
0878     struct isci_port *iport = idev->owning_port;
0879     enum sci_status status;
0880 
0881     switch (state) {
0882     case SCI_DEV_INITIAL:
0883     case SCI_DEV_STOPPED:
0884     case SCI_DEV_STARTING:
0885     case SCI_SMP_DEV_IDLE:
0886     case SCI_SMP_DEV_CMD:
0887     case SCI_DEV_STOPPING:
0888     case SCI_DEV_FAILED:
0889     case SCI_DEV_RESETTING:
0890     case SCI_DEV_FINAL:
0891     default:
0892         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
0893              __func__, dev_state_name(state));
0894         return SCI_FAILURE_INVALID_STATE;
0895     case SCI_STP_DEV_IDLE:
0896     case SCI_STP_DEV_CMD:
0897     case SCI_STP_DEV_NCQ:
0898     case SCI_STP_DEV_NCQ_ERROR:
0899     case SCI_STP_DEV_AWAIT_RESET:
0900         status = sci_port_start_io(iport, idev, ireq);
0901         if (status != SCI_SUCCESS)
0902             return status;
0903 
0904         status = sci_request_start(ireq);
0905         if (status != SCI_SUCCESS)
0906             goto out;
0907 
0908         /* Note: If the remote device state is not IDLE this will
0909          * replace the request that probably resulted in the task
0910          * management request.
0911          */
0912         idev->working_request = ireq;
0913         sci_change_state(sm, SCI_STP_DEV_CMD);
0914 
0915         /* The remote node context must cleanup the TCi to NCQ mapping
0916          * table.  The only way to do this correctly is to either write
0917          * to the TLCR register or to invalidate and repost the RNC. In
0918          * either case the remote node context state machine will take
0919          * the correct action when the remote node context is suspended
0920          * and later resumed.
0921          */
0922         sci_remote_device_suspend(idev,
0923                       SCI_SW_SUSPEND_LINKHANG_DETECT);
0924 
0925         status = sci_remote_node_context_start_task(&idev->rnc, ireq,
0926                 sci_remote_device_continue_request, idev);
0927 
0928     out:
0929         sci_remote_device_start_request(idev, ireq, status);
0930         /* We need to let the controller start request handler know that
0931          * it can't post TC yet. We will provide a callback function to
0932          * post TC when RNC gets resumed.
0933          */
0934         return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
0935     case SCI_DEV_READY:
0936         status = sci_port_start_io(iport, idev, ireq);
0937         if (status != SCI_SUCCESS)
0938             return status;
0939 
0940         /* Resume the RNC as needed: */
0941         status = sci_remote_node_context_start_task(&idev->rnc, ireq,
0942                                 NULL, NULL);
0943         if (status != SCI_SUCCESS)
0944             break;
0945 
0946         status = sci_request_start(ireq);
0947         break;
0948     }
0949     sci_remote_device_start_request(idev, ireq, status);
0950 
0951     return status;
0952 }
0953 
0954 void sci_remote_device_post_request(struct isci_remote_device *idev, u32 request)
0955 {
0956     struct isci_port *iport = idev->owning_port;
0957     u32 context;
0958 
0959     context = request |
0960           (ISCI_PEG << SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT) |
0961           (iport->physical_port_index << SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT) |
0962           idev->rnc.remote_node_index;
0963 
0964     sci_controller_post_request(iport->owning_controller, context);
0965 }
0966 
0967 /* called once the remote node context has transisitioned to a
0968  * ready state.  This is the indication that the remote device object can also
0969  * transition to ready.
0970  */
0971 static void remote_device_resume_done(void *_dev)
0972 {
0973     struct isci_remote_device *idev = _dev;
0974 
0975     if (is_remote_device_ready(idev))
0976         return;
0977 
0978     /* go 'ready' if we are not already in a ready state */
0979     sci_change_state(&idev->sm, SCI_DEV_READY);
0980 }
0981 
0982 static void sci_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
0983 {
0984     struct isci_remote_device *idev = _dev;
0985     struct isci_host *ihost = idev->owning_port->owning_controller;
0986 
0987     /* For NCQ operation we do not issue a isci_remote_device_not_ready().
0988      * As a result, avoid sending the ready notification.
0989      */
0990     if (idev->sm.previous_state_id != SCI_STP_DEV_NCQ)
0991         isci_remote_device_ready(ihost, idev);
0992 }
0993 
0994 static void sci_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
0995 {
0996     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
0997 
0998     /* Initial state is a transitional state to the stopped state */
0999     sci_change_state(&idev->sm, SCI_DEV_STOPPED);
1000 }
1001 
1002 /**
1003  * sci_remote_device_destruct() - free remote node context and destruct
1004  * @idev: This parameter specifies the remote device to be destructed.
1005  *
1006  * Remote device objects are a limited resource.  As such, they must be
1007  * protected.  Thus calls to construct and destruct are mutually exclusive and
1008  * non-reentrant. The return value shall indicate if the device was
1009  * successfully destructed or if some failure occurred. enum sci_status This value
1010  * is returned if the device is successfully destructed.
1011  * SCI_FAILURE_INVALID_REMOTE_DEVICE This value is returned if the supplied
1012  * device isn't valid (e.g. it's already been destoryed, the handle isn't
1013  * valid, etc.).
1014  */
1015 static enum sci_status sci_remote_device_destruct(struct isci_remote_device *idev)
1016 {
1017     struct sci_base_state_machine *sm = &idev->sm;
1018     enum sci_remote_device_states state = sm->current_state_id;
1019     struct isci_host *ihost;
1020 
1021     if (state != SCI_DEV_STOPPED) {
1022         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1023              __func__, dev_state_name(state));
1024         return SCI_FAILURE_INVALID_STATE;
1025     }
1026 
1027     ihost = idev->owning_port->owning_controller;
1028     sci_controller_free_remote_node_context(ihost, idev,
1029                              idev->rnc.remote_node_index);
1030     idev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
1031     sci_change_state(sm, SCI_DEV_FINAL);
1032 
1033     return SCI_SUCCESS;
1034 }
1035 
1036 /**
1037  * isci_remote_device_deconstruct() - This function frees an isci_remote_device.
1038  * @ihost: This parameter specifies the isci host object.
1039  * @idev: This parameter specifies the remote device to be freed.
1040  *
1041  */
1042 static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_remote_device *idev)
1043 {
1044     dev_dbg(&ihost->pdev->dev,
1045         "%s: isci_device = %p\n", __func__, idev);
1046 
1047     /* There should not be any outstanding io's. All paths to
1048      * here should go through isci_remote_device_nuke_requests.
1049      * If we hit this condition, we will need a way to complete
1050      * io requests in process */
1051     BUG_ON(idev->started_request_count > 0);
1052 
1053     sci_remote_device_destruct(idev);
1054     list_del_init(&idev->node);
1055     isci_put_device(idev);
1056 }
1057 
1058 static void sci_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
1059 {
1060     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1061     struct isci_host *ihost = idev->owning_port->owning_controller;
1062     u32 prev_state;
1063 
1064     /* If we are entering from the stopping state let the SCI User know that
1065      * the stop operation has completed.
1066      */
1067     prev_state = idev->sm.previous_state_id;
1068     if (prev_state == SCI_DEV_STOPPING)
1069         isci_remote_device_deconstruct(ihost, idev);
1070 
1071     sci_controller_remote_device_stopped(ihost, idev);
1072 }
1073 
1074 static void sci_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
1075 {
1076     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1077     struct isci_host *ihost = idev->owning_port->owning_controller;
1078 
1079     isci_remote_device_not_ready(ihost, idev,
1080                      SCIC_REMOTE_DEVICE_NOT_READY_START_REQUESTED);
1081 }
1082 
1083 static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
1084 {
1085     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1086     struct isci_host *ihost = idev->owning_port->owning_controller;
1087     struct domain_device *dev = idev->domain_dev;
1088 
1089     if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
1090         sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
1091     } else if (dev_is_expander(dev->dev_type)) {
1092         sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
1093     } else
1094         isci_remote_device_ready(ihost, idev);
1095 }
1096 
1097 static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
1098 {
1099     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1100     struct domain_device *dev = idev->domain_dev;
1101 
1102     if (dev->dev_type == SAS_END_DEVICE) {
1103         struct isci_host *ihost = idev->owning_port->owning_controller;
1104 
1105         isci_remote_device_not_ready(ihost, idev,
1106                          SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED);
1107     }
1108 }
1109 
1110 static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
1111 {
1112     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1113     struct isci_host *ihost = idev->owning_port->owning_controller;
1114 
1115     dev_dbg(&ihost->pdev->dev,
1116         "%s: isci_device = %p\n", __func__, idev);
1117 
1118     sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1119 }
1120 
1121 static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
1122 {
1123     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1124     struct isci_host *ihost = idev->owning_port->owning_controller;
1125 
1126     dev_dbg(&ihost->pdev->dev,
1127         "%s: isci_device = %p\n", __func__, idev);
1128 
1129     sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
1130 }
1131 
1132 static void sci_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1133 {
1134     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1135 
1136     idev->working_request = NULL;
1137     if (sci_remote_node_context_is_ready(&idev->rnc)) {
1138         /*
1139          * Since the RNC is ready, it's alright to finish completion
1140          * processing (e.g. signal the remote device is ready). */
1141         sci_stp_remote_device_ready_idle_substate_resume_complete_handler(idev);
1142     } else {
1143         sci_remote_node_context_resume(&idev->rnc,
1144             sci_stp_remote_device_ready_idle_substate_resume_complete_handler,
1145             idev);
1146     }
1147 }
1148 
1149 static void sci_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1150 {
1151     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1152     struct isci_host *ihost = idev->owning_port->owning_controller;
1153 
1154     BUG_ON(idev->working_request == NULL);
1155 
1156     isci_remote_device_not_ready(ihost, idev,
1157                      SCIC_REMOTE_DEVICE_NOT_READY_SATA_REQUEST_STARTED);
1158 }
1159 
1160 static void sci_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
1161 {
1162     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1163     struct isci_host *ihost = idev->owning_port->owning_controller;
1164 
1165     if (idev->not_ready_reason == SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED)
1166         isci_remote_device_not_ready(ihost, idev,
1167                          idev->not_ready_reason);
1168 }
1169 
1170 static void sci_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
1171 {
1172     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1173     struct isci_host *ihost = idev->owning_port->owning_controller;
1174 
1175     isci_remote_device_ready(ihost, idev);
1176 }
1177 
1178 static void sci_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
1179 {
1180     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1181     struct isci_host *ihost = idev->owning_port->owning_controller;
1182 
1183     BUG_ON(idev->working_request == NULL);
1184 
1185     isci_remote_device_not_ready(ihost, idev,
1186                      SCIC_REMOTE_DEVICE_NOT_READY_SMP_REQUEST_STARTED);
1187 }
1188 
1189 static void sci_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
1190 {
1191     struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
1192 
1193     idev->working_request = NULL;
1194 }
1195 
1196 static const struct sci_base_state sci_remote_device_state_table[] = {
1197     [SCI_DEV_INITIAL] = {
1198         .enter_state = sci_remote_device_initial_state_enter,
1199     },
1200     [SCI_DEV_STOPPED] = {
1201         .enter_state = sci_remote_device_stopped_state_enter,
1202     },
1203     [SCI_DEV_STARTING] = {
1204         .enter_state = sci_remote_device_starting_state_enter,
1205     },
1206     [SCI_DEV_READY] = {
1207         .enter_state = sci_remote_device_ready_state_enter,
1208         .exit_state  = sci_remote_device_ready_state_exit
1209     },
1210     [SCI_STP_DEV_IDLE] = {
1211         .enter_state = sci_stp_remote_device_ready_idle_substate_enter,
1212     },
1213     [SCI_STP_DEV_CMD] = {
1214         .enter_state = sci_stp_remote_device_ready_cmd_substate_enter,
1215     },
1216     [SCI_STP_DEV_NCQ] = { },
1217     [SCI_STP_DEV_NCQ_ERROR] = {
1218         .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
1219     },
1220     [SCI_STP_DEV_ATAPI_ERROR] = { },
1221     [SCI_STP_DEV_AWAIT_RESET] = { },
1222     [SCI_SMP_DEV_IDLE] = {
1223         .enter_state = sci_smp_remote_device_ready_idle_substate_enter,
1224     },
1225     [SCI_SMP_DEV_CMD] = {
1226         .enter_state = sci_smp_remote_device_ready_cmd_substate_enter,
1227         .exit_state  = sci_smp_remote_device_ready_cmd_substate_exit,
1228     },
1229     [SCI_DEV_STOPPING] = { },
1230     [SCI_DEV_FAILED] = { },
1231     [SCI_DEV_RESETTING] = {
1232         .enter_state = sci_remote_device_resetting_state_enter,
1233         .exit_state  = sci_remote_device_resetting_state_exit
1234     },
1235     [SCI_DEV_FINAL] = { },
1236 };
1237 
1238 /**
1239  * sci_remote_device_construct() - common construction
1240  * @iport: SAS/SATA port through which this device is accessed.
1241  * @idev: remote device to construct
1242  *
1243  * This routine just performs benign initialization and does not
1244  * allocate the remote_node_context which is left to
1245  * sci_remote_device_[de]a_construct().  sci_remote_device_destruct()
1246  * frees the remote_node_context(s) for the device.
1247  */
1248 static void sci_remote_device_construct(struct isci_port *iport,
1249                   struct isci_remote_device *idev)
1250 {
1251     idev->owning_port = iport;
1252     idev->started_request_count = 0;
1253 
1254     sci_init_sm(&idev->sm, sci_remote_device_state_table, SCI_DEV_INITIAL);
1255 
1256     sci_remote_node_context_construct(&idev->rnc,
1257                            SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
1258 }
1259 
1260 /*
1261  * sci_remote_device_da_construct() - construct direct attached device.
1262  *
1263  * The information (e.g. IAF, Signature FIS, etc.) necessary to build
1264  * the device is known to the SCI Core since it is contained in the
1265  * sci_phy object.  Remote node context(s) is/are a global resource
1266  * allocated by this routine, freed by sci_remote_device_destruct().
1267  *
1268  * Returns:
1269  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1270  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1271  * sata-only controller instance.
1272  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1273  */
1274 static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
1275                                struct isci_remote_device *idev)
1276 {
1277     enum sci_status status;
1278     struct sci_port_properties properties;
1279 
1280     sci_remote_device_construct(iport, idev);
1281 
1282     sci_port_get_properties(iport, &properties);
1283     /* Get accurate port width from port's phy mask for a DA device. */
1284     idev->device_port_width = hweight32(properties.phy_mask);
1285 
1286     status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1287                                  idev,
1288                                  &idev->rnc.remote_node_index);
1289 
1290     if (status != SCI_SUCCESS)
1291         return status;
1292 
1293     idev->connection_rate = sci_port_get_max_allowed_speed(iport);
1294 
1295     return SCI_SUCCESS;
1296 }
1297 
1298 /*
1299  * sci_remote_device_ea_construct() - construct expander attached device
1300  *
1301  * Remote node context(s) is/are a global resource allocated by this
1302  * routine, freed by sci_remote_device_destruct().
1303  *
1304  * Returns:
1305  * SCI_FAILURE_DEVICE_EXISTS - device has already been constructed.
1306  * SCI_FAILURE_UNSUPPORTED_PROTOCOL - e.g. sas device attached to
1307  * sata-only controller instance.
1308  * SCI_FAILURE_INSUFFICIENT_RESOURCES - remote node contexts exhausted.
1309  */
1310 static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
1311                                struct isci_remote_device *idev)
1312 {
1313     struct domain_device *dev = idev->domain_dev;
1314     enum sci_status status;
1315 
1316     sci_remote_device_construct(iport, idev);
1317 
1318     status = sci_controller_allocate_remote_node_context(iport->owning_controller,
1319                                   idev,
1320                                   &idev->rnc.remote_node_index);
1321     if (status != SCI_SUCCESS)
1322         return status;
1323 
1324     /* For SAS-2 the physical link rate is actually a logical link
1325      * rate that incorporates multiplexing.  The SCU doesn't
1326      * incorporate multiplexing and for the purposes of the
1327      * connection the logical link rate is that same as the
1328      * physical.  Furthermore, the SAS-2 and SAS-1.1 fields overlay
1329      * one another, so this code works for both situations.
1330      */
1331     idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
1332                      dev->linkrate);
1333 
1334     /* / @todo Should I assign the port width by reading all of the phys on the port? */
1335     idev->device_port_width = 1;
1336 
1337     return SCI_SUCCESS;
1338 }
1339 
1340 enum sci_status sci_remote_device_resume(
1341     struct isci_remote_device *idev,
1342     scics_sds_remote_node_context_callback cb_fn,
1343     void *cb_p)
1344 {
1345     enum sci_status status;
1346 
1347     status = sci_remote_node_context_resume(&idev->rnc, cb_fn, cb_p);
1348     if (status != SCI_SUCCESS)
1349         dev_dbg(scirdev_to_dev(idev), "%s: failed to resume: %d\n",
1350             __func__, status);
1351     return status;
1352 }
1353 
1354 static void isci_remote_device_resume_from_abort_complete(void *cbparam)
1355 {
1356     struct isci_remote_device *idev = cbparam;
1357     struct isci_host *ihost = idev->owning_port->owning_controller;
1358     scics_sds_remote_node_context_callback abort_resume_cb =
1359         idev->abort_resume_cb;
1360 
1361     dev_dbg(scirdev_to_dev(idev), "%s: passing-along resume: %p\n",
1362         __func__, abort_resume_cb);
1363 
1364     if (abort_resume_cb != NULL) {
1365         idev->abort_resume_cb = NULL;
1366         abort_resume_cb(idev->abort_resume_cbparam);
1367     }
1368     clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1369     wake_up(&ihost->eventq);
1370 }
1371 
1372 static bool isci_remote_device_test_resume_done(
1373     struct isci_host *ihost,
1374     struct isci_remote_device *idev)
1375 {
1376     unsigned long flags;
1377     bool done;
1378 
1379     spin_lock_irqsave(&ihost->scic_lock, flags);
1380     done = !test_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags)
1381         || test_bit(IDEV_STOP_PENDING, &idev->flags)
1382         || sci_remote_node_context_is_being_destroyed(&idev->rnc);
1383     spin_unlock_irqrestore(&ihost->scic_lock, flags);
1384 
1385     return done;
1386 }
1387 
1388 static void isci_remote_device_wait_for_resume_from_abort(
1389     struct isci_host *ihost,
1390     struct isci_remote_device *idev)
1391 {
1392     dev_dbg(&ihost->pdev->dev, "%s: starting resume wait: %p\n",
1393          __func__, idev);
1394 
1395     #define MAX_RESUME_MSECS 10000
1396     if (!wait_event_timeout(ihost->eventq,
1397                 isci_remote_device_test_resume_done(ihost, idev),
1398                 msecs_to_jiffies(MAX_RESUME_MSECS))) {
1399 
1400         dev_warn(&ihost->pdev->dev, "%s: #### Timeout waiting for "
1401              "resume: %p\n", __func__, idev);
1402     }
1403     clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1404 
1405     dev_dbg(&ihost->pdev->dev, "%s: resume wait done: %p\n",
1406          __func__, idev);
1407 }
1408 
1409 enum sci_status isci_remote_device_resume_from_abort(
1410     struct isci_host *ihost,
1411     struct isci_remote_device *idev)
1412 {
1413     unsigned long flags;
1414     enum sci_status status = SCI_SUCCESS;
1415     int destroyed;
1416 
1417     spin_lock_irqsave(&ihost->scic_lock, flags);
1418     /* Preserve any current resume callbacks, for instance from other
1419      * resumptions.
1420      */
1421     idev->abort_resume_cb = idev->rnc.user_callback;
1422     idev->abort_resume_cbparam = idev->rnc.user_cookie;
1423     set_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1424     clear_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1425     destroyed = sci_remote_node_context_is_being_destroyed(&idev->rnc);
1426     if (!destroyed)
1427         status = sci_remote_device_resume(
1428             idev, isci_remote_device_resume_from_abort_complete,
1429             idev);
1430     spin_unlock_irqrestore(&ihost->scic_lock, flags);
1431     if (!destroyed && (status == SCI_SUCCESS))
1432         isci_remote_device_wait_for_resume_from_abort(ihost, idev);
1433     else
1434         clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
1435 
1436     return status;
1437 }
1438 
1439 /**
1440  * sci_remote_device_start() - This method will start the supplied remote
1441  *    device.  This method enables normal IO requests to flow through to the
1442  *    remote device.
1443  * @idev: This parameter specifies the device to be started.
1444  * @timeout: This parameter specifies the number of milliseconds in which the
1445  *    start operation should complete.
1446  *
1447  * An indication of whether the device was successfully started. SCI_SUCCESS
1448  * This value is returned if the device was successfully started.
1449  * SCI_FAILURE_INVALID_PHY This value is returned if the user attempts to start
1450  * the device when there have been no phys added to it.
1451  */
1452 static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
1453                            u32 timeout)
1454 {
1455     struct sci_base_state_machine *sm = &idev->sm;
1456     enum sci_remote_device_states state = sm->current_state_id;
1457     enum sci_status status;
1458 
1459     if (state != SCI_DEV_STOPPED) {
1460         dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
1461              __func__, dev_state_name(state));
1462         return SCI_FAILURE_INVALID_STATE;
1463     }
1464 
1465     status = sci_remote_device_resume(idev, remote_device_resume_done,
1466                       idev);
1467     if (status != SCI_SUCCESS)
1468         return status;
1469 
1470     sci_change_state(sm, SCI_DEV_STARTING);
1471 
1472     return SCI_SUCCESS;
1473 }
1474 
1475 static enum sci_status isci_remote_device_construct(struct isci_port *iport,
1476                             struct isci_remote_device *idev)
1477 {
1478     struct isci_host *ihost = iport->isci_host;
1479     struct domain_device *dev = idev->domain_dev;
1480     enum sci_status status;
1481 
1482     if (dev->parent && dev_is_expander(dev->parent->dev_type))
1483         status = sci_remote_device_ea_construct(iport, idev);
1484     else
1485         status = sci_remote_device_da_construct(iport, idev);
1486 
1487     if (status != SCI_SUCCESS) {
1488         dev_dbg(&ihost->pdev->dev, "%s: construct failed: %d\n",
1489             __func__, status);
1490 
1491         return status;
1492     }
1493 
1494     /* start the device. */
1495     status = sci_remote_device_start(idev, ISCI_REMOTE_DEVICE_START_TIMEOUT);
1496 
1497     if (status != SCI_SUCCESS)
1498         dev_warn(&ihost->pdev->dev, "remote device start failed: %d\n",
1499              status);
1500 
1501     return status;
1502 }
1503 
1504 /**
1505  * isci_remote_device_alloc()
1506  * This function builds the isci_remote_device when a libsas dev_found message
1507  *    is received.
1508  * @ihost: This parameter specifies the isci host object.
1509  * @iport: This parameter specifies the isci_port connected to this device.
1510  *
1511  * pointer to new isci_remote_device.
1512  */
1513 static struct isci_remote_device *
1514 isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
1515 {
1516     struct isci_remote_device *idev;
1517     int i;
1518 
1519     for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
1520         idev = &ihost->devices[i];
1521         if (!test_and_set_bit(IDEV_ALLOCATED, &idev->flags))
1522             break;
1523     }
1524 
1525     if (i >= SCI_MAX_REMOTE_DEVICES) {
1526         dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
1527         return NULL;
1528     }
1529     if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
1530         return NULL;
1531 
1532     return idev;
1533 }
1534 
1535 void isci_remote_device_release(struct kref *kref)
1536 {
1537     struct isci_remote_device *idev = container_of(kref, typeof(*idev), kref);
1538     struct isci_host *ihost = idev->isci_port->isci_host;
1539 
1540     idev->domain_dev = NULL;
1541     idev->isci_port = NULL;
1542     clear_bit(IDEV_START_PENDING, &idev->flags);
1543     clear_bit(IDEV_STOP_PENDING, &idev->flags);
1544     clear_bit(IDEV_IO_READY, &idev->flags);
1545     clear_bit(IDEV_GONE, &idev->flags);
1546     smp_mb__before_atomic();
1547     clear_bit(IDEV_ALLOCATED, &idev->flags);
1548     wake_up(&ihost->eventq);
1549 }
1550 
1551 /**
1552  * isci_remote_device_stop() - This function is called internally to stop the
1553  *    remote device.
1554  * @ihost: This parameter specifies the isci host object.
1555  * @idev: This parameter specifies the remote device.
1556  *
1557  * The status of the ihost request to stop.
1558  */
1559 enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_remote_device *idev)
1560 {
1561     enum sci_status status;
1562     unsigned long flags;
1563 
1564     dev_dbg(&ihost->pdev->dev,
1565         "%s: isci_device = %p\n", __func__, idev);
1566 
1567     spin_lock_irqsave(&ihost->scic_lock, flags);
1568     idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
1569     set_bit(IDEV_GONE, &idev->flags);
1570 
1571     set_bit(IDEV_STOP_PENDING, &idev->flags);
1572     status = sci_remote_device_stop(idev, 50);
1573     spin_unlock_irqrestore(&ihost->scic_lock, flags);
1574 
1575     /* Wait for the stop complete callback. */
1576     if (WARN_ONCE(status != SCI_SUCCESS, "failed to stop device\n"))
1577         /* nothing to wait for */;
1578     else
1579         wait_for_device_stop(ihost, idev);
1580 
1581     dev_dbg(&ihost->pdev->dev,
1582         "%s: isci_device = %p, waiting done.\n", __func__, idev);
1583 
1584     return status;
1585 }
1586 
1587 /**
1588  * isci_remote_device_gone() - This function is called by libsas when a domain
1589  *    device is removed.
1590  * @dev: This parameter specifies the libsas domain device.
1591  */
1592 void isci_remote_device_gone(struct domain_device *dev)
1593 {
1594     struct isci_host *ihost = dev_to_ihost(dev);
1595     struct isci_remote_device *idev = dev->lldd_dev;
1596 
1597     dev_dbg(&ihost->pdev->dev,
1598         "%s: domain_device = %p, isci_device = %p, isci_port = %p\n",
1599         __func__, dev, idev, idev->isci_port);
1600 
1601     isci_remote_device_stop(ihost, idev);
1602 }
1603 
1604 
1605 /**
1606  * isci_remote_device_found() - This function is called by libsas when a remote
1607  *    device is discovered. A remote device object is created and started. the
1608  *    function then sleeps until the sci core device started message is
1609  *    received.
1610  * @dev: This parameter specifies the libsas domain device.
1611  *
1612  * status, zero indicates success.
1613  */
1614 int isci_remote_device_found(struct domain_device *dev)
1615 {
1616     struct isci_host *isci_host = dev_to_ihost(dev);
1617     struct isci_port *isci_port = dev->port->lldd_port;
1618     struct isci_remote_device *isci_device;
1619     enum sci_status status;
1620 
1621     dev_dbg(&isci_host->pdev->dev,
1622         "%s: domain_device = %p\n", __func__, dev);
1623 
1624     if (!isci_port)
1625         return -ENODEV;
1626 
1627     isci_device = isci_remote_device_alloc(isci_host, isci_port);
1628     if (!isci_device)
1629         return -ENODEV;
1630 
1631     kref_init(&isci_device->kref);
1632     INIT_LIST_HEAD(&isci_device->node);
1633 
1634     spin_lock_irq(&isci_host->scic_lock);
1635     isci_device->domain_dev = dev;
1636     isci_device->isci_port = isci_port;
1637     list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
1638 
1639     set_bit(IDEV_START_PENDING, &isci_device->flags);
1640     status = isci_remote_device_construct(isci_port, isci_device);
1641 
1642     dev_dbg(&isci_host->pdev->dev,
1643         "%s: isci_device = %p\n",
1644         __func__, isci_device);
1645 
1646     if (status == SCI_SUCCESS) {
1647         /* device came up, advertise it to the world */
1648         dev->lldd_dev = isci_device;
1649     } else
1650         isci_put_device(isci_device);
1651     spin_unlock_irq(&isci_host->scic_lock);
1652 
1653     /* wait for the device ready callback. */
1654     wait_for_device_start(isci_host, isci_device);
1655 
1656     return status == SCI_SUCCESS ? 0 : -ENODEV;
1657 }
1658 
1659 enum sci_status isci_remote_device_suspend_terminate(
1660     struct isci_host *ihost,
1661     struct isci_remote_device *idev,
1662     struct isci_request *ireq)
1663 {
1664     unsigned long flags;
1665     enum sci_status status;
1666 
1667     /* Put the device into suspension. */
1668     spin_lock_irqsave(&ihost->scic_lock, flags);
1669     set_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
1670     sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
1671     spin_unlock_irqrestore(&ihost->scic_lock, flags);
1672 
1673     /* Terminate and wait for the completions. */
1674     status = isci_remote_device_terminate_requests(ihost, idev, ireq);
1675     if (status != SCI_SUCCESS)
1676         dev_dbg(&ihost->pdev->dev,
1677             "%s: isci_remote_device_terminate_requests(%p) "
1678                 "returned %d!\n",
1679             __func__, idev, status);
1680 
1681     /* NOTE: RNC resumption is left to the caller! */
1682     return status;
1683 }
1684 
1685 int isci_remote_device_is_safe_to_abort(
1686     struct isci_remote_device *idev)
1687 {
1688     return sci_remote_node_context_is_safe_to_abort(&idev->rnc);
1689 }
1690 
1691 enum sci_status sci_remote_device_abort_requests_pending_abort(
1692     struct isci_remote_device *idev)
1693 {
1694     return sci_remote_device_terminate_reqs_checkabort(idev, 1);
1695 }
1696 
1697 enum sci_status isci_remote_device_reset_complete(
1698     struct isci_host *ihost,
1699     struct isci_remote_device *idev)
1700 {
1701     unsigned long flags;
1702     enum sci_status status;
1703 
1704     spin_lock_irqsave(&ihost->scic_lock, flags);
1705     status = sci_remote_device_reset_complete(idev);
1706     spin_unlock_irqrestore(&ihost->scic_lock, flags);
1707 
1708     return status;
1709 }
1710 
1711 void isci_dev_set_hang_detection_timeout(
1712     struct isci_remote_device *idev,
1713     u32 timeout)
1714 {
1715     if (dev_is_sata(idev->domain_dev)) {
1716         if (timeout) {
1717             if (test_and_set_bit(IDEV_RNC_LLHANG_ENABLED,
1718                          &idev->flags))
1719                 return;  /* Already enabled. */
1720         } else if (!test_and_clear_bit(IDEV_RNC_LLHANG_ENABLED,
1721                            &idev->flags))
1722             return;  /* Not enabled. */
1723 
1724         sci_port_set_hang_detection_timeout(idev->owning_port,
1725                             timeout);
1726     }
1727 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!