drivers/scsi/isci/task.h

   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
  56 #if !defined(_ISCI_TASK_H_)
  57 #define _ISCI_TASK_H_
  58
  59 struct isci_request;
  60 struct isci_host;
  61
  62 /**
  63  * enum isci_tmf_cb_state - This enum defines the possible states in which the
  64  *    TMF callback function is invoked during the TMF execution process.
  65  *
  66  *
  67  */
  68 enum isci_tmf_cb_state {
  69
  70         isci_tmf_init_state = 0,
  71         isci_tmf_started,
  72         isci_tmf_timed_out
  73 };
  74
  75 /**
  76  * enum isci_tmf_function_codes - This enum defines the possible preparations
  77  *    of task management requests.
  78  *
  79  *
  80  */
  81 enum isci_tmf_function_codes {
  82
  83         isci_tmf_func_none      = 0,
  84         isci_tmf_ssp_task_abort = TMF_ABORT_TASK,
  85         isci_tmf_ssp_lun_reset  = TMF_LU_RESET,
  86         isci_tmf_sata_srst_high = TMF_LU_RESET + 0x100, /* Non SCSI */
  87         isci_tmf_sata_srst_low  = TMF_LU_RESET + 0x101  /* Non SCSI */
  88 };
  89 /**
  90  * struct isci_tmf - This class represents the task management object which
  91  *    acts as an interface to libsas for processing task management requests
  92  *
  93  *
  94  */
  95 struct isci_tmf {
  96
  97         struct completion *complete;
  98         enum sas_protocol proto;
  99         union {
 100                 struct sci_ssp_response_iu resp_iu;
 101                 struct dev_to_host_fis d2h_fis;
 102         }                            resp;
 103         unsigned char lun[8];
 104         u16 io_tag;
 105         struct isci_remote_device *device;
 106         enum isci_tmf_function_codes tmf_code;
 107         int status;
 108
 109         struct isci_timer *timeout_timer;
 110
 111         /* The optional callback function allows the user process to
 112          * track the TMF transmit / timeout conditions.
 113          */
 114         void (*cb_state_func)(
 115                 enum isci_tmf_cb_state,
 116                 struct isci_tmf *, void *);
 117         void *cb_data;
 118
 119 };
 120
 121 static inline void isci_print_tmf(
 122         struct isci_tmf *tmf)
 123 {
 124         if (SAS_PROTOCOL_SATA == tmf->proto)
 125                 dev_dbg(&tmf->device->isci_port->isci_host->pdev->dev,
 126                         "%s: status = %x\n"
 127                         "tmf->resp.d2h_fis.status = %x\n"
 128                         "tmf->resp.d2h_fis.error = %x\n",
 129                         __func__,
 130                         tmf->status,
 131                         tmf->resp.d2h_fis.status,
 132                         tmf->resp.d2h_fis.error);
 133         else
 134                 dev_dbg(&tmf->device->isci_port->isci_host->pdev->dev,
 135                         "%s: status = %x\n"
 136                         "tmf->resp.resp_iu.data_present = %x\n"
 137                         "tmf->resp.resp_iu.status = %x\n"
 138                         "tmf->resp.resp_iu.data_length = %x\n"
 139                         "tmf->resp.resp_iu.data[0] = %x\n"
 140                         "tmf->resp.resp_iu.data[1] = %x\n"
 141                         "tmf->resp.resp_iu.data[2] = %x\n"
 142                         "tmf->resp.resp_iu.data[3] = %x\n",
 143                         __func__,
 144                         tmf->status,
 145                         tmf->resp.resp_iu.data_present,
 146                         tmf->resp.resp_iu.status,
 147                         (tmf->resp.resp_iu.response_data_length[0] << 24) +
 148                         (tmf->resp.resp_iu.response_data_length[1] << 16) +
 149                         (tmf->resp.resp_iu.response_data_length[2] << 8) +
 150                         tmf->resp.resp_iu.response_data_length[3],
 151                         tmf->resp.resp_iu.data[0],
 152                         tmf->resp.resp_iu.data[1],
 153                         tmf->resp.resp_iu.data[2],
 154                         tmf->resp.resp_iu.data[3]);
 155 }
 156
 157
 158 int isci_task_execute_task(
 159         struct sas_task *task,
 160         int num,
 161         gfp_t gfp_flags);
 162
 163 int isci_task_abort_task(
 164         struct sas_task *task);
 165
 166 int isci_task_abort_task_set(
 167         struct domain_device *d_device,
 168         u8 *lun);
 169
 170 int isci_task_clear_aca(
 171         struct domain_device *d_device,
 172         u8 *lun);
 173
 174 int isci_task_clear_task_set(
 175         struct domain_device *d_device,
 176         u8 *lun);
 177
 178 int isci_task_query_task(
 179         struct sas_task *task);
 180
 181 int isci_task_lu_reset(
 182         struct domain_device *d_device,
 183         u8 *lun);
 184
 185 int isci_task_clear_nexus_port(
 186         struct asd_sas_port *port);
 187
 188 int isci_task_clear_nexus_ha(
 189         struct sas_ha_struct *ha);
 190
 191 int isci_task_I_T_nexus_reset(
 192         struct domain_device *d_device);
 193
 194 void isci_task_request_complete(
 195         struct isci_host *isci_host,
 196         struct isci_request *request,
 197         enum sci_task_status completion_status);
 198
 199 u16 isci_task_ssp_request_get_io_tag_to_manage(
 200         struct isci_request *request);
 201
 202 u8 isci_task_ssp_request_get_function(
 203         struct isci_request *request);
 204
 205 u32 isci_task_ssp_request_get_lun(
 206         struct isci_request *request);
 207
 208 void *isci_task_ssp_request_get_response_data_address(
 209         struct isci_request *request);
 210
 211 u32 isci_task_ssp_request_get_response_data_length(
 212         struct isci_request *request);
 213
 214 int isci_queuecommand(
 215         struct scsi_cmnd *scsi_cmd,
 216         void (*donefunc)(struct scsi_cmnd *));
 217
 218 int isci_bus_reset_handler(struct scsi_cmnd *cmd);
 219
 220 void isci_task_build_tmf(
 221         struct isci_tmf *tmf,
 222         struct isci_remote_device *isci_device,
 223         enum isci_tmf_function_codes code,
 224         void (*tmf_sent_cb)(
 225                 enum isci_tmf_cb_state,
 226                 struct isci_tmf *, void *),
 227         void *cb_data);
 228
 229 int isci_task_execute_tmf(
 230         struct isci_host *isci_host,
 231         struct isci_tmf *tmf,
 232         unsigned long timeout_ms);
 233
 234 /**
 235  * enum isci_completion_selection - This enum defines the possible actions to
 236  *    take with respect to a given request's notification back to libsas.
 237  *
 238  *
 239  */
 240 enum isci_completion_selection {
 241
 242         isci_perform_normal_io_completion,      /* Normal notify (task_done) */
 243         isci_perform_aborted_io_completion,     /* No notification.   */
 244         isci_perform_error_io_completion        /* Use sas_task_abort */
 245 };
 246
 247 static inline void isci_set_task_doneflags(
 248         struct sas_task *task)
 249 {
 250         /* Since no futher action will be taken on this task,
 251          * make sure to mark it complete from the lldd perspective.
 252          */
 253         task->task_state_flags |= SAS_TASK_STATE_DONE;
 254         task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
 255         task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
 256 }
 257 /**
 258  * isci_task_all_done() - This function clears the task bits to indicate the
 259  *    LLDD is done with the task.
 260  *
 261  *
 262  */
 263 static inline void isci_task_all_done(
 264         struct sas_task *task)
 265 {
 266         unsigned long flags;
 267
 268         /* Since no futher action will be taken on this task,
 269          * make sure to mark it complete from the lldd perspective.
 270          */
 271         spin_lock_irqsave(&task->task_state_lock, flags);
 272         isci_set_task_doneflags(task);
 273         spin_unlock_irqrestore(&task->task_state_lock, flags);
 274 }
 275
 276 /**
 277  * isci_task_set_completion_status() - This function sets the completion status
 278  *    for the request.
 279  * @task: This parameter is the completed request.
 280  * @response: This parameter is the response code for the completed task.
 281  * @status: This parameter is the status code for the completed task.
 282  *
 283 * @return The new notification mode for the request.
 284 */
 285 static inline enum isci_completion_selection
 286 isci_task_set_completion_status(
 287         struct sas_task *task,
 288         enum service_response response,
 289         enum exec_status status,
 290         enum isci_completion_selection task_notification_selection)
 291 {
 292         unsigned long flags;
 293
 294         spin_lock_irqsave(&task->task_state_lock, flags);
 295
 296         task->task_status.resp = response;
 297         task->task_status.stat = status;
 298
 299         /* If a device reset is being indicated, make sure the I/O
 300         * is in the error path.
 301         */
 302         if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
 303                 task_notification_selection = isci_perform_error_io_completion;
 304
 305         switch (task_notification_selection) {
 306
 307                 case isci_perform_aborted_io_completion:
 308                         /* This path can occur with task-managed requests as well as
 309                         * requests terminated because of LUN or device resets.
 310                         */
 311                         /* Fall through to the normal case... */
 312
 313                 case isci_perform_normal_io_completion:
 314                         /* Normal notification (task_done) */
 315                         isci_set_task_doneflags(task);
 316                         break;
 317
 318                 default:
 319                         WARN_ON(FALSE);
 320                         /* Fall through to the error case... */
 321
 322                 case isci_perform_error_io_completion:
 323                         /* Use sas_task_abort */
 324                         /* Leave SAS_TASK_STATE_DONE clear
 325                         *  Leave SAS_TASK_AT_INITIATOR set.
 326                         */
 327                         break;
 328         }
 329
 330         spin_unlock_irqrestore(&task->task_state_lock, flags);
 331
 332         return task_notification_selection;
 333
 334 }
 335 /**
 336  * isci_task_complete_for_upper_layer() - This function completes the request
 337  *    to the upper layer driver.
 338  * @host: This parameter is a pointer to the host on which the the request
 339  *    should be queued (either as an error or success).
 340  * @request: This parameter is the completed request.
 341  * @response: This parameter is the response code for the completed task.
 342  * @status: This parameter is the status code for the completed task.
 343  *
 344  * none.
 345  */
 346 static inline void isci_task_complete_for_upper_layer(
 347         struct sas_task *task,
 348         enum service_response response,
 349         enum exec_status status,
 350         enum isci_completion_selection task_notification_selection)
 351 {
 352         task_notification_selection
 353                 = isci_task_set_completion_status(task, response, status,
 354                                                   task_notification_selection);
 355
 356         /* Tasks aborted specifically by a call to the lldd_abort_task
 357          * function should not be completed to the host in the regular path.
 358          */
 359         switch (task_notification_selection) {
 360         case isci_perform_normal_io_completion:
 361                 /* Normal notification (task_done) */
 362                 dev_dbg(task->dev->port->ha->dev,
 363                         "%s: Normal - task = %p, response=%d, status=%d\n",
 364                         __func__, task, response, status);
 365                 task->task_done(task);
 366                 task->lldd_task = NULL;
 367                 break;
 368
 369         case isci_perform_aborted_io_completion:
 370                 /* No notification because this request is already in the
 371                  * abort path.
 372                  */
 373                 dev_warn(task->dev->port->ha->dev,
 374                          "%s: Aborted - task = %p, response=%d, status=%d\n",
 375                          __func__, task, response, status);
 376                 break;
 377
 378         case isci_perform_error_io_completion:
 379                 /* Use sas_task_abort */
 380                 dev_warn(task->dev->port->ha->dev,
 381                          "%s: Error - task = %p, response=%d, status=%d\n",
 382                          __func__, task, response, status);
 383                 sas_task_abort(task);
 384                 break;
 385
 386         default:
 387                 dev_warn(task->dev->port->ha->dev,
 388                          "%s: isci task notification default case!",
 389                          __func__);
 390                 sas_task_abort(task);
 391                 break;
 392         }
 393 }
 394
 395 #endif /* !defined(_SCI_TASK_H_) */