drivers/scsi/isci/request.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_REQUEST_H_)
  57 #define _ISCI_REQUEST_H_
  58
  59 #include "isci.h"
  60
  61 /**
  62  * struct isci_request_status - This enum defines the possible states of an I/O
  63  *    request.
  64  *
  65  *
  66  */
  67 enum isci_request_status {
  68         unallocated = 0x00,
  69         allocated   = 0x01,
  70         started     = 0x02,
  71         completed   = 0x03,
  72         aborting    = 0x04,
  73         aborted     = 0x05,
  74         terminating = 0x06,
  75         dead        = 0x07
  76 };
  77
  78 enum task_type {
  79         io_task  = 0,
  80         tmf_task = 1
  81 };
  82
  83 /**
  84  * struct isci_request - This class represents the request object used to track
  85  *    IO, smp and TMF request internal. It wraps the SCIC request object.
  86  *
  87  *
  88  */
  89 struct isci_request {
  90
  91         struct scic_sds_request *sci_request_handle;
  92
  93         enum isci_request_status status;
  94         enum task_type ttype;
  95         unsigned short io_tag;
  96         bool complete_in_target;
  97
  98         union ttype_ptr_union {
  99                 struct sas_task *io_task_ptr;   /* When ttype==io_task  */
 100                 struct isci_tmf *tmf_task_ptr;  /* When ttype==tmf_task */
 101         } ttype_ptr;
 102         struct isci_host *isci_host;
 103         struct isci_remote_device *isci_device;
 104         /* For use in the requests_to_{complete|abort} lists: */
 105         struct list_head completed_node;
 106         /* For use in the reqs_in_process list: */
 107         struct list_head dev_node;
 108         void *sci_request_mem_ptr;
 109         spinlock_t state_lock;
 110         dma_addr_t request_daddr;
 111         dma_addr_t zero_scatter_daddr;
 112
 113         unsigned int num_sg_entries;                    /* returned by pci_alloc_sg */
 114         unsigned int request_alloc_size;                /* size of block from dma_pool_alloc */
 115
 116         /** Note: "io_request_completion" is completed in two different ways
 117          * depending on whether this is a TMF or regular request.
 118          * - TMF requests are completed in the thread that started them;
 119          * - regular requests are completed in the request completion callback
 120          *   function.
 121          * This difference in operation allows the aborter of a TMF request
 122          * to be sure that once the TMF request completes, the I/O that the
 123          * TMF was aborting is guaranteed to have completed.
 124          */
 125         struct completion *io_request_completion;
 126 };
 127
 128 /**
 129  * This function gets the status of the request object.
 130  * @request: This parameter points to the isci_request object
 131  *
 132  * status of the object as a isci_request_status enum.
 133  */
 134 static inline
 135 enum isci_request_status isci_request_get_state(
 136         struct isci_request *isci_request)
 137 {
 138         BUG_ON(isci_request == NULL);
 139
 140         /*probably a bad sign...        */
 141         if (isci_request->status == unallocated)
 142                 dev_warn(&isci_request->isci_host->pdev->dev,
 143                          "%s: isci_request->status == unallocated\n",
 144                          __func__);
 145
 146         return isci_request->status;
 147 }
 148
 149
 150 /**
 151  * isci_request_change_state() - This function sets the status of the request
 152  *    object.
 153  * @request: This parameter points to the isci_request object
 154  * @status: This Parameter is the new status of the object
 155  *
 156  */
 157 static inline enum isci_request_status isci_request_change_state(
 158         struct isci_request *isci_request,
 159         enum isci_request_status status)
 160 {
 161         enum isci_request_status old_state;
 162         unsigned long flags;
 163
 164         dev_dbg(&isci_request->isci_host->pdev->dev,
 165                 "%s: isci_request = %p, state = 0x%x\n",
 166                 __func__,
 167                 isci_request,
 168                 status);
 169
 170         BUG_ON(isci_request == NULL);
 171
 172         spin_lock_irqsave(&isci_request->state_lock, flags);
 173         old_state = isci_request->status;
 174         isci_request->status = status;
 175         spin_unlock_irqrestore(&isci_request->state_lock, flags);
 176
 177         return old_state;
 178 }
 179
 180 /**
 181  * isci_request_change_started_to_newstate() - This function sets the status of
 182  *    the request object.
 183  * @request: This parameter points to the isci_request object
 184  * @status: This Parameter is the new status of the object
 185  *
 186  * state previous to any change.
 187  */
 188 static inline enum isci_request_status isci_request_change_started_to_newstate(
 189         struct isci_request *isci_request,
 190         struct completion *completion_ptr,
 191         enum isci_request_status newstate)
 192 {
 193         enum isci_request_status old_state;
 194         unsigned long flags;
 195
 196         BUG_ON(isci_request == NULL);
 197
 198         spin_lock_irqsave(&isci_request->state_lock, flags);
 199
 200         old_state = isci_request->status;
 201
 202         if (old_state == started) {
 203                 BUG_ON(isci_request->io_request_completion != NULL);
 204
 205                 isci_request->io_request_completion = completion_ptr;
 206                 isci_request->status = newstate;
 207         }
 208         spin_unlock_irqrestore(&isci_request->state_lock, flags);
 209
 210         dev_dbg(&isci_request->isci_host->pdev->dev,
 211                 "%s: isci_request = %p, old_state = 0x%x\n",
 212                 __func__,
 213                 isci_request,
 214                 old_state);
 215
 216         return old_state;
 217 }
 218
 219 /**
 220  * isci_request_change_started_to_aborted() - This function sets the status of
 221  *    the request object.
 222  * @request: This parameter points to the isci_request object
 223  * @completion_ptr: This parameter is saved as the kernel completion structure
 224  *    signalled when the old request completes.
 225  *
 226  * state previous to any change.
 227  */
 228 static inline enum isci_request_status isci_request_change_started_to_aborted(
 229         struct isci_request *isci_request,
 230         struct completion *completion_ptr)
 231 {
 232         return isci_request_change_started_to_newstate(
 233                        isci_request, completion_ptr, aborted
 234                        );
 235 }
 236 /**
 237  * isci_request_free() - This function frees the request object.
 238  * @isci_host: This parameter specifies the ISCI host object
 239  * @isci_request: This parameter points to the isci_request object
 240  *
 241  */
 242 static inline void isci_request_free(
 243         struct isci_host *isci_host,
 244         struct isci_request *isci_request)
 245 {
 246         BUG_ON(isci_request == NULL);
 247
 248         /* release the dma memory if we fail. */
 249         dma_pool_free(isci_host->dma_pool, isci_request,
 250                       isci_request->request_daddr);
 251 }
 252
 253
 254 /* #define ISCI_REQUEST_VALIDATE_ACCESS
 255  */
 256
 257 #ifdef ISCI_REQUEST_VALIDATE_ACCESS
 258
 259 static inline
 260 struct sas_task *isci_request_access_task(struct isci_request *isci_request)
 261 {
 262         BUG_ON(isci_request->ttype != io_task);
 263         return isci_request->ttype_ptr.io_task_ptr;
 264 }
 265
 266 static inline
 267 struct isci_tmf *isci_request_access_tmf(struct isci_request *isci_request)
 268 {
 269         BUG_ON(isci_request->ttype != tmf_task);
 270         return isci_request->ttype_ptr.tmf_task_ptr;
 271 }
 272
 273 #else  /* not ISCI_REQUEST_VALIDATE_ACCESS */
 274
 275 #define isci_request_access_task(RequestPtr) \
 276         ((RequestPtr)->ttype_ptr.io_task_ptr)
 277
 278 #define isci_request_access_tmf(RequestPtr)  \
 279         ((RequestPtr)->ttype_ptr.tmf_task_ptr)
 280
 281 #endif /* not ISCI_REQUEST_VALIDATE_ACCESS */
 282
 283
 284 int isci_request_alloc_tmf(
 285         struct isci_host *isci_host,
 286         struct isci_tmf *isci_tmf,
 287         struct isci_request **isci_request,
 288         struct isci_remote_device *isci_device,
 289         gfp_t gfp_flags);
 290
 291
 292 int isci_request_execute(
 293         struct isci_host *isci_host,
 294         struct sas_task *task,
 295         struct isci_request **request,
 296         gfp_t gfp_flags);
 297
 298 /**
 299  * isci_request_unmap_sgl() - This function unmaps the DMA address of a given
 300  *    sgl
 301  * @request: This parameter points to the isci_request object
 302  * @*pdev: This Parameter is the pci_device struct for the controller
 303  *
 304  */
 305 static inline void isci_request_unmap_sgl(
 306         struct isci_request *request,
 307         struct pci_dev *pdev)
 308 {
 309         struct sas_task *task = isci_request_access_task(request);
 310
 311         dev_dbg(&request->isci_host->pdev->dev,
 312                 "%s: request = %p, task = %p,\n"
 313                 "task->data_dir = %d, is_sata = %d\n ",
 314                 __func__,
 315                 request,
 316                 task,
 317                 task->data_dir,
 318                 sas_protocol_ata(task->task_proto));
 319
 320         if ((task->data_dir != PCI_DMA_NONE) &&
 321             !sas_protocol_ata(task->task_proto)) {
 322                 if (task->num_scatter == 0)
 323                         /* 0 indicates a single dma address */
 324                         dma_unmap_single(
 325                                 &pdev->dev,
 326                                 request->zero_scatter_daddr,
 327                                 task->total_xfer_len,
 328                                 task->data_dir
 329                                 );
 330
 331                 else  /* unmap the sgl dma addresses */
 332                         dma_unmap_sg(
 333                                 &pdev->dev,
 334                                 task->scatter,
 335                                 request->num_sg_entries,
 336                                 task->data_dir
 337                                 );
 338         }
 339 }
 340
 341
 342 void isci_request_io_request_complete(
 343         struct isci_host *isci_host,
 344         struct isci_request *request,
 345         enum sci_io_status completion_status);
 346
 347 u32 isci_request_io_request_get_transfer_length(
 348         struct isci_request *request);
 349
 350 enum dma_data_direction isci_request_io_request_get_data_direction(struct isci_request *req);
 351
 352 /**
 353  * isci_request_io_request_get_next_sge() - This function is called by the sci
 354  *    core to retrieve the next sge for a given request.
 355  * @request: This parameter is the isci_request object.
 356  * @current_sge_address: This parameter is the last sge retrieved by the sci
 357  *    core for this request.
 358  *
 359  * pointer to the next sge for specified request.
 360  */
 361 static inline void *isci_request_io_request_get_next_sge(
 362         struct isci_request *request,
 363         void *current_sge_address)
 364 {
 365         struct sas_task *task = isci_request_access_task(request);
 366         void *ret = NULL;
 367
 368         dev_dbg(&request->isci_host->pdev->dev,
 369                 "%s: request = %p, "
 370                 "current_sge_address = %p, "
 371                 "num_scatter = %d\n",
 372                 __func__,
 373                 request,
 374                 current_sge_address,
 375                 task->num_scatter);
 376
 377         if (!current_sge_address)       /* First time through.. */
 378                 ret = task->scatter;    /* always task->scatter */
 379         else if (task->num_scatter == 0) /* Next element, if num_scatter == 0 */
 380                 ret = NULL;              /* there is only one element. */
 381         else
 382                 ret = sg_next(current_sge_address);     /* sg_next returns NULL
 383                                                          * for the last element
 384                                                          */
 385
 386         dev_dbg(&request->isci_host->pdev->dev,
 387                 "%s: next sge address = %p\n",
 388                 __func__,
 389                 ret);
 390
 391         return ret;
 392 }
 393
 394
 395
 396 void *isci_request_ssp_io_request_get_cdb_address(
 397         struct isci_request *request);
 398
 399 u32 isci_request_ssp_io_request_get_cdb_length(
 400         struct isci_request *request);
 401
 402 u32  isci_request_ssp_io_request_get_lun(
 403         struct isci_request *request);
 404
 405 u32 isci_request_ssp_io_request_get_task_attribute(
 406         struct isci_request *request);
 407
 408 u32 isci_request_ssp_io_request_get_command_priority(
 409         struct isci_request *request);
 410
 411
 412
 413
 414
 415 void isci_terminate_pending_requests(
 416         struct isci_host *isci_host,
 417         struct isci_remote_device *isci_device,
 418         enum isci_request_status new_request_state);
 419
 420
 421
 422
 423 #endif /* !defined(_ISCI_REQUEST_H_) */