LXR linux/drivers/scsi/csiostor/csio

   1/*
   2 * This file is part of the Chelsio FCoE driver for Linux.
   3 *
   4 * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.
   5 *
   6 * This software is available to you under a choice of one of two
   7 * licenses.  You may choose to be licensed under the terms of the GNU
   8 * General Public License (GPL) Version 2, available from the file
   9 * COPYING in the main directory of this source tree, or the
  10 * OpenIB.org BSD license below:
  11 *
  12 *     Redistribution and use in source and binary forms, with or
  13 *     without modification, are permitted provided that the following
  14 *     conditions are met:
  15 *
  16 *      - Redistributions of source code must retain the above
  17 *        copyright notice, this list of conditions and the following
  18 *        disclaimer.
  19 *
  20 *      - Redistributions in binary form must reproduce the above
  21 *        copyright notice, this list of conditions and the following
  22 *        disclaimer in the documentation and/or other materials
  23 *        provided with the distribution.
  24 *
  25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32 * SOFTWARE.
  33 */
  34
  35#ifndef __CSIO_SCSI_H__
  36#define __CSIO_SCSI_H__
  37
  38#include <linux/spinlock_types.h>
  39#include <linux/completion.h>
  40#include <scsi/scsi.h>
  41#include <scsi/scsi_cmnd.h>
  42#include <scsi/scsi_device.h>
  43#include <scsi/scsi_host.h>
  44#include <scsi/scsi_eh.h>
  45#include <scsi/scsi_tcq.h>
  46#include <scsi/fc/fc_fcp.h>
  47
  48#include "csio_defs.h"
  49#include "csio_wr.h"
  50
  51extern struct scsi_host_template csio_fcoe_shost_template;
  52extern struct scsi_host_template csio_fcoe_shost_vport_template;
  53
  54extern int csio_scsi_eqsize;
  55extern int csio_scsi_iqlen;
  56extern int csio_scsi_ioreqs;
  57extern uint32_t csio_max_scan_tmo;
  58extern uint32_t csio_delta_scan_tmo;
  59extern int csio_lun_qdepth;
  60
  61/*
  62 **************************** NOTE *******************************
  63 * How do we calculate MAX FCoE SCSI SGEs? Here is the math:
  64 * Max Egress WR size = 512 bytes
  65 * One SCSI egress WR has the following fixed no of bytes:
  66 *      48 (sizeof(struct fw_scsi_write[read]_wr)) - FW WR
  67 *    + 32 (sizeof(struct fc_fcp_cmnd)) - Immediate FCP_CMD
  68 *    ------
  69 *      80
  70 *    ------
  71 * That leaves us with 512 - 96 = 432 bytes for data SGE. Using
  72 * struct ulptx_sgl header for the SGE consumes:
  73 *      - 4 bytes for cmnd_sge.
  74 *      - 12 bytes for the first SGL.
  75 * That leaves us with 416 bytes for the remaining SGE pairs. Which is
  76 * is 416 / 24 (size(struct ulptx_sge_pair)) = 17 SGE pairs,
  77 * or 34 SGEs. Adding the first SGE fetches us 35 SGEs.
  78 */
  79#define CSIO_SCSI_MAX_SGE               35
  80#define CSIO_SCSI_ABRT_TMO_MS           60000
  81#define CSIO_SCSI_LUNRST_TMO_MS         60000
  82#define CSIO_SCSI_TM_POLL_MS            2000    /* should be less than
  83                                                 * all TM timeouts.
  84                                                 */
  85#define CSIO_SCSI_IQ_WRSZ               128
  86#define CSIO_SCSI_IQSIZE                (csio_scsi_iqlen * CSIO_SCSI_IQ_WRSZ)
  87
  88#define CSIO_MAX_SNS_LEN                128
  89#define CSIO_SCSI_RSP_LEN       (FCP_RESP_WITH_EXT + 4 + CSIO_MAX_SNS_LEN)
  90
  91/* Reference to scsi_cmnd */
  92#define csio_scsi_cmnd(req)             ((req)->scratch1)
  93
  94struct csio_scsi_stats {
  95        uint64_t                n_tot_success;  /* Total number of good I/Os */
  96        uint32_t                n_rn_nr_error;  /* No. of remote-node-not-
  97                                                 * ready errors
  98                                                 */
  99        uint32_t                n_hw_nr_error;  /* No. of hw-module-not-
 100                                                 * ready errors
 101                                                 */
 102        uint32_t                n_dmamap_error; /* No. of DMA map erros */
 103        uint32_t                n_unsupp_sge_error; /* No. of too-many-SGes
 104                                                     * errors.
 105                                                     */
 106        uint32_t                n_no_req_error; /* No. of Out-of-ioreqs error */
 107        uint32_t                n_busy_error;   /* No. of -EBUSY errors */
 108        uint32_t                n_hosterror;    /* No. of FW_HOSTERROR I/O */
 109        uint32_t                n_rsperror;     /* No. of response errors */
 110        uint32_t                n_autosense;    /* No. of auto sense replies */
 111        uint32_t                n_ovflerror;    /* No. of overflow errors */
 112        uint32_t                n_unflerror;    /* No. of underflow errors */
 113        uint32_t                n_rdev_nr_error;/* No. of rdev not
 114                                                 * ready errors
 115                                                 */
 116        uint32_t                n_rdev_lost_error;/* No. of rdev lost errors */
 117        uint32_t                n_rdev_logo_error;/* No. of rdev logo errors */
 118        uint32_t                n_link_down_error;/* No. of link down errors */
 119        uint32_t                n_no_xchg_error; /* No. no exchange error */
 120        uint32_t                n_unknown_error;/* No. of unhandled errors */
 121        uint32_t                n_aborted;      /* No. of aborted I/Os */
 122        uint32_t                n_abrt_timedout; /* No. of abort timedouts */
 123        uint32_t                n_abrt_fail;    /* No. of abort failures */
 124        uint32_t                n_abrt_dups;    /* No. of duplicate aborts */
 125        uint32_t                n_abrt_race_comp; /* No. of aborts that raced
 126                                                   * with completions.
 127                                                   */
 128        uint32_t                n_abrt_busy_error;/* No. of abort failures
 129                                                   * due to -EBUSY.
 130                                                   */
 131        uint32_t                n_closed;       /* No. of closed I/Os */
 132        uint32_t                n_cls_busy_error; /* No. of close failures
 133                                                   * due to -EBUSY.
 134                                                   */
 135        uint32_t                n_active;       /* No. of IOs in active_q */
 136        uint32_t                n_tm_active;    /* No. of TMs in active_q */
 137        uint32_t                n_wcbfn;        /* No. of I/Os in worker
 138                                                 * cbfn q
 139                                                 */
 140        uint32_t                n_free_ioreq;   /* No. of freelist entries */
 141        uint32_t                n_free_ddp;     /* No. of DDP freelist */
 142        uint32_t                n_unaligned;    /* No. of Unaligned SGls */
 143        uint32_t                n_inval_cplop;  /* No. invalid CPL op's in IQ */
 144        uint32_t                n_inval_scsiop; /* No. invalid scsi op's in IQ*/
 145};
 146
 147struct csio_scsim {
 148        struct csio_hw          *hw;            /* Pointer to HW moduel */
 149        uint8_t                 max_sge;        /* Max SGE */
 150        uint8_t                 proto_cmd_len;  /* Proto specific SCSI
 151                                                 * cmd length
 152                                                 */
 153        uint16_t                proto_rsp_len;  /* Proto specific SCSI
 154                                                 * response length
 155                                                 */
 156        spinlock_t              freelist_lock;  /* Lock for ioreq freelist */
 157        struct list_head        active_q;       /* Outstanding SCSI I/Os */
 158        struct list_head        ioreq_freelist; /* Free list of ioreq's */
 159        struct list_head        ddp_freelist;   /* DDP descriptor freelist */
 160        struct csio_scsi_stats  stats;          /* This module's statistics */
 161};
 162
 163/* State machine defines */
 164enum csio_scsi_ev {
 165        CSIO_SCSIE_START_IO = 1,                /* Start a regular SCSI IO */
 166        CSIO_SCSIE_START_TM,                    /* Start a TM IO */
 167        CSIO_SCSIE_COMPLETED,                   /* IO Completed */
 168        CSIO_SCSIE_ABORT,                       /* Abort IO */
 169        CSIO_SCSIE_ABORTED,                     /* IO Aborted */
 170        CSIO_SCSIE_CLOSE,                       /* Close exchange */
 171        CSIO_SCSIE_CLOSED,                      /* Exchange closed */
 172        CSIO_SCSIE_DRVCLEANUP,                  /* Driver wants to manually
 173                                                 * cleanup this I/O.
 174                                                 */
 175};
 176
 177enum csio_scsi_lev {
 178        CSIO_LEV_ALL = 1,
 179        CSIO_LEV_LNODE,
 180        CSIO_LEV_RNODE,
 181        CSIO_LEV_LUN,
 182};
 183
 184struct csio_scsi_level_data {
 185        enum csio_scsi_lev      level;
 186        struct csio_rnode       *rnode;
 187        struct csio_lnode       *lnode;
 188        uint64_t                oslun;
 189};
 190
 191static inline struct csio_ioreq *
 192csio_get_scsi_ioreq(struct csio_scsim *scm)
 193{
 194        struct csio_sm *req;
 195
 196        if (likely(!list_empty(&scm->ioreq_freelist))) {
 197                req = list_first_entry(&scm->ioreq_freelist,
 198                                       struct csio_sm, sm_list);
 199                list_del_init(&req->sm_list);
 200                CSIO_DEC_STATS(scm, n_free_ioreq);
 201                return (struct csio_ioreq *)req;
 202        } else
 203                return NULL;
 204}
 205
 206static inline void
 207csio_put_scsi_ioreq(struct csio_scsim *scm, struct csio_ioreq *ioreq)
 208{
 209        list_add_tail(&ioreq->sm.sm_list, &scm->ioreq_freelist);
 210        CSIO_INC_STATS(scm, n_free_ioreq);
 211}
 212
 213static inline void
 214csio_put_scsi_ioreq_list(struct csio_scsim *scm, struct list_head *reqlist,
 215                         int n)
 216{
 217        list_splice_init(reqlist, &scm->ioreq_freelist);
 218        scm->stats.n_free_ioreq += n;
 219}
 220
 221static inline struct csio_dma_buf *
 222csio_get_scsi_ddp(struct csio_scsim *scm)
 223{
 224        struct csio_dma_buf *ddp;
 225
 226        if (likely(!list_empty(&scm->ddp_freelist))) {
 227                ddp = list_first_entry(&scm->ddp_freelist,
 228                                       struct csio_dma_buf, list);
 229                list_del_init(&ddp->list);
 230                CSIO_DEC_STATS(scm, n_free_ddp);
 231                return ddp;
 232        } else
 233                return NULL;
 234}
 235
 236static inline void
 237csio_put_scsi_ddp(struct csio_scsim *scm, struct csio_dma_buf *ddp)
 238{
 239        list_add_tail(&ddp->list, &scm->ddp_freelist);
 240        CSIO_INC_STATS(scm, n_free_ddp);
 241}
 242
 243static inline void
 244csio_put_scsi_ddp_list(struct csio_scsim *scm, struct list_head *reqlist,
 245                         int n)
 246{
 247        list_splice_tail_init(reqlist, &scm->ddp_freelist);
 248        scm->stats.n_free_ddp += n;
 249}
 250
 251static inline void
 252csio_scsi_completed(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
 253{
 254        csio_post_event(&ioreq->sm, CSIO_SCSIE_COMPLETED);
 255        if (csio_list_deleted(&ioreq->sm.sm_list))
 256                list_add_tail(&ioreq->sm.sm_list, cbfn_q);
 257}
 258
 259static inline void
 260csio_scsi_aborted(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
 261{
 262        csio_post_event(&ioreq->sm, CSIO_SCSIE_ABORTED);
 263        list_add_tail(&ioreq->sm.sm_list, cbfn_q);
 264}
 265
 266static inline void
 267csio_scsi_closed(struct csio_ioreq *ioreq, struct list_head *cbfn_q)
 268{
 269        csio_post_event(&ioreq->sm, CSIO_SCSIE_CLOSED);
 270        list_add_tail(&ioreq->sm.sm_list, cbfn_q);
 271}
 272
 273static inline void
 274csio_scsi_drvcleanup(struct csio_ioreq *ioreq)
 275{
 276        csio_post_event(&ioreq->sm, CSIO_SCSIE_DRVCLEANUP);
 277}
 278
 279/*
 280 * csio_scsi_start_io - Kick starts the IO SM.
 281 * @req: io request SM.
 282 *
 283 * needs to be called with lock held.
 284 */
 285static inline int
 286csio_scsi_start_io(struct csio_ioreq *ioreq)
 287{
 288        csio_post_event(&ioreq->sm, CSIO_SCSIE_START_IO);
 289        return ioreq->drv_status;
 290}
 291
 292/*
 293 * csio_scsi_start_tm - Kicks off the Task management IO SM.
 294 * @req: io request SM.
 295 *
 296 * needs to be called with lock held.
 297 */
 298static inline int
 299csio_scsi_start_tm(struct csio_ioreq *ioreq)
 300{
 301        csio_post_event(&ioreq->sm, CSIO_SCSIE_START_TM);
 302        return ioreq->drv_status;
 303}
 304
 305/*
 306 * csio_scsi_abort - Abort an IO request
 307 * @req: io request SM.
 308 *
 309 * needs to be called with lock held.
 310 */
 311static inline int
 312csio_scsi_abort(struct csio_ioreq *ioreq)
 313{
 314        csio_post_event(&ioreq->sm, CSIO_SCSIE_ABORT);
 315        return ioreq->drv_status;
 316}
 317
 318/*
 319 * csio_scsi_close - Close an IO request
 320 * @req: io request SM.
 321 *
 322 * needs to be called with lock held.
 323 */
 324static inline int
 325csio_scsi_close(struct csio_ioreq *ioreq)
 326{
 327        csio_post_event(&ioreq->sm, CSIO_SCSIE_CLOSE);
 328        return ioreq->drv_status;
 329}
 330
 331void csio_scsi_cleanup_io_q(struct csio_scsim *, struct list_head *);
 332int csio_scsim_cleanup_io(struct csio_scsim *, bool abort);
 333int csio_scsim_cleanup_io_lnode(struct csio_scsim *,
 334                                          struct csio_lnode *);
 335struct csio_ioreq *csio_scsi_cmpl_handler(struct csio_hw *, void *, uint32_t,
 336                                          struct csio_fl_dma_buf *,
 337                                          void *, uint8_t **);
 338int csio_scsi_qconfig(struct csio_hw *);
 339int csio_scsim_init(struct csio_scsim *, struct csio_hw *);
 340void csio_scsim_exit(struct csio_scsim *);
 341
 342#endif /* __CSIO_SCSI_H__ */
 343