drivers/scsi/csiostor/csio_mb.h

   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_MB_H__
  36 #define __CSIO_MB_H__
  37
  38 #include <linux/timer.h>
  39 #include <linux/completion.h>
  40
  41 #include "t4fw_api.h"
  42 #include "t4fw_api_stor.h"
  43 #include "csio_defs.h"
  44
  45 #define CSIO_STATS_OFFSET (2)
  46 #define CSIO_NUM_STATS_PER_MB (6)
  47
  48 struct fw_fcoe_port_cmd_params {
  49         uint8_t         portid;
  50         uint8_t         idx;
  51         uint8_t         nstats;
  52 };
  53
  54 #define CSIO_DUMP_MB(__hw, __num, __mb)                                 \
  55         csio_dbg(__hw, "\t%llx %llx %llx %llx %llx %llx %llx %llx\n",   \
  56                 (unsigned long long)csio_rd_reg64(__hw, __mb),          \
  57                 (unsigned long long)csio_rd_reg64(__hw, __mb + 8),      \
  58                 (unsigned long long)csio_rd_reg64(__hw, __mb + 16),     \
  59                 (unsigned long long)csio_rd_reg64(__hw, __mb + 24),     \
  60                 (unsigned long long)csio_rd_reg64(__hw, __mb + 32),     \
  61                 (unsigned long long)csio_rd_reg64(__hw, __mb + 40),     \
  62                 (unsigned long long)csio_rd_reg64(__hw, __mb + 48),     \
  63                 (unsigned long long)csio_rd_reg64(__hw, __mb + 56))
  64
  65 #define CSIO_MB_MAX_REGS        8
  66 #define CSIO_MAX_MB_SIZE        64
  67 #define CSIO_MB_POLL_FREQ       5               /*  5 ms */
  68 #define CSIO_MB_DEFAULT_TMO     FW_CMD_MAX_TIMEOUT
  69
  70 /* Device master in HELLO command */
  71 enum csio_dev_master { CSIO_MASTER_CANT, CSIO_MASTER_MAY, CSIO_MASTER_MUST };
  72
  73 enum csio_mb_owner { CSIO_MBOWNER_NONE, CSIO_MBOWNER_FW, CSIO_MBOWNER_PL };
  74
  75 enum csio_dev_state {
  76         CSIO_DEV_STATE_UNINIT,
  77         CSIO_DEV_STATE_INIT,
  78         CSIO_DEV_STATE_ERR
  79 };
  80
  81 #define FW_PARAM_DEV(param) \
  82         (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | \
  83          FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_##param))
  84
  85 #define FW_PARAM_PFVF(param) \
  86         (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_PFVF) | \
  87          FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_PFVF_##param)|  \
  88          FW_PARAMS_PARAM_Y_V(0) | \
  89          FW_PARAMS_PARAM_Z_V(0))
  90
  91 enum {
  92         PAUSE_RX      = 1 << 0,
  93         PAUSE_TX      = 1 << 1,
  94         PAUSE_AUTONEG = 1 << 2
  95 };
  96
  97 #define CSIO_INIT_MBP(__mbp, __cp,  __tmo, __priv, __fn, __clear)       \
  98 do {                                                                    \
  99         if (__clear)                                                    \
 100                 memset((__cp), 0,                                       \
 101                             CSIO_MB_MAX_REGS * sizeof(__be64));         \
 102         INIT_LIST_HEAD(&(__mbp)->list);                                 \
 103         (__mbp)->tmo            = (__tmo);                              \
 104         (__mbp)->priv           = (void *)(__priv);                     \
 105         (__mbp)->mb_cbfn        = (__fn);                               \
 106         (__mbp)->mb_size        = sizeof(*(__cp));                      \
 107 } while (0)
 108
 109 struct csio_mbm_stats {
 110         uint32_t        n_req;          /* number of mbox req */
 111         uint32_t        n_rsp;          /* number of mbox rsp */
 112         uint32_t        n_activeq;      /* number of mbox req active Q */
 113         uint32_t        n_cbfnq;        /* number of mbox req cbfn Q */
 114         uint32_t        n_tmo;          /* number of mbox timeout */
 115         uint32_t        n_cancel;       /* number of mbox cancel */
 116         uint32_t        n_err;          /* number of mbox error */
 117 };
 118
 119 /* Driver version of Mailbox */
 120 struct csio_mb {
 121         struct list_head        list;                   /* for req/resp */
 122                                                         /* queue in driver */
 123         __be64                  mb[CSIO_MB_MAX_REGS];   /* MB in HW format */
 124         int                     mb_size;                /* Size of this
 125                                                          * mailbox.
 126                                                          */
 127         uint32_t                tmo;                    /* Timeout */
 128         struct completion       cmplobj;                /* MB Completion
 129                                                          * object
 130                                                          */
 131         void                    (*mb_cbfn) (struct csio_hw *, struct csio_mb *);
 132                                                         /* Callback fn */
 133         void                    *priv;                  /* Owner private ptr */
 134 };
 135
 136 struct csio_mbm {
 137         uint32_t                a_mbox;                 /* Async mbox num */
 138         uint32_t                intr_idx;               /* Interrupt index */
 139         struct timer_list       timer;                  /* Mbox timer */
 140         struct list_head        req_q;                  /* Mbox request queue */
 141         struct list_head        cbfn_q;                 /* Mbox completion q */
 142         struct csio_mb          *mcurrent;              /* Current mailbox */
 143         uint32_t                req_q_cnt;              /* Outstanding mbox
 144                                                          * cmds
 145                                                          */
 146         struct csio_mbm_stats   stats;                  /* Statistics */
 147 };
 148
 149 #define csio_set_mb_intr_idx(_m, _i)    ((_m)->intr_idx = (_i))
 150 #define csio_get_mb_intr_idx(_m)        ((_m)->intr_idx)
 151
 152 struct csio_iq_params;
 153 struct csio_eq_params;
 154
 155 enum fw_retval csio_mb_fw_retval(struct csio_mb *);
 156
 157 /* MB helpers */
 158 void csio_mb_hello(struct csio_hw *, struct csio_mb *, uint32_t,
 159                    uint32_t, uint32_t, enum csio_dev_master,
 160                    void (*)(struct csio_hw *, struct csio_mb *));
 161
 162 void csio_mb_process_hello_rsp(struct csio_hw *, struct csio_mb *,
 163                                enum fw_retval *, enum csio_dev_state *,
 164                                uint8_t *);
 165
 166 void csio_mb_bye(struct csio_hw *, struct csio_mb *, uint32_t,
 167                  void (*)(struct csio_hw *, struct csio_mb *));
 168
 169 void csio_mb_reset(struct csio_hw *, struct csio_mb *, uint32_t, int, int,
 170                    void (*)(struct csio_hw *, struct csio_mb *));
 171
 172 void csio_mb_params(struct csio_hw *, struct csio_mb *, uint32_t, unsigned int,
 173                     unsigned int, unsigned int, const u32 *, u32 *, bool,
 174                     void (*)(struct csio_hw *, struct csio_mb *));
 175
 176 void csio_mb_process_read_params_rsp(struct csio_hw *, struct csio_mb *,
 177                                 enum fw_retval *, unsigned int , u32 *);
 178
 179 void csio_mb_ldst(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo,
 180                   int reg);
 181
 182 void csio_mb_caps_config(struct csio_hw *, struct csio_mb *, uint32_t,
 183                             bool, bool, bool, bool,
 184                             void (*)(struct csio_hw *, struct csio_mb *));
 185
 186 void csio_mb_port(struct csio_hw *, struct csio_mb *, uint32_t,
 187                   uint8_t, bool, uint32_t, uint16_t,
 188                   void (*) (struct csio_hw *, struct csio_mb *));
 189
 190 void csio_mb_process_read_port_rsp(struct csio_hw *, struct csio_mb *,
 191                                    enum fw_retval *, uint16_t *);
 192
 193 void csio_mb_initialize(struct csio_hw *, struct csio_mb *, uint32_t,
 194                         void (*)(struct csio_hw *, struct csio_mb *));
 195
 196 void csio_mb_iq_alloc_write(struct csio_hw *, struct csio_mb *, void *,
 197                         uint32_t, struct csio_iq_params *,
 198                         void (*) (struct csio_hw *, struct csio_mb *));
 199
 200 void csio_mb_iq_alloc_write_rsp(struct csio_hw *, struct csio_mb *,
 201                                 enum fw_retval *, struct csio_iq_params *);
 202
 203 void csio_mb_iq_free(struct csio_hw *, struct csio_mb *, void *,
 204                      uint32_t, struct csio_iq_params *,
 205                      void (*) (struct csio_hw *, struct csio_mb *));
 206
 207 void csio_mb_eq_ofld_alloc_write(struct csio_hw *, struct csio_mb *, void *,
 208                                  uint32_t, struct csio_eq_params *,
 209                                  void (*) (struct csio_hw *, struct csio_mb *));
 210
 211 void csio_mb_eq_ofld_alloc_write_rsp(struct csio_hw *, struct csio_mb *,
 212                                      enum fw_retval *, struct csio_eq_params *);
 213
 214 void csio_mb_eq_ofld_free(struct csio_hw *, struct csio_mb *, void *,
 215                           uint32_t , struct csio_eq_params *,
 216                           void (*) (struct csio_hw *, struct csio_mb *));
 217
 218 void csio_fcoe_read_res_info_init_mb(struct csio_hw *, struct csio_mb *,
 219                         uint32_t,
 220                         void (*) (struct csio_hw *, struct csio_mb *));
 221
 222 void csio_write_fcoe_link_cond_init_mb(struct csio_lnode *, struct csio_mb *,
 223                         uint32_t, uint8_t, uint32_t, uint8_t, bool, uint32_t,
 224                         void (*) (struct csio_hw *, struct csio_mb *));
 225
 226 void csio_fcoe_vnp_alloc_init_mb(struct csio_lnode *, struct csio_mb *,
 227                         uint32_t, uint32_t , uint32_t , uint16_t,
 228                         uint8_t [8], uint8_t [8],
 229                         void (*) (struct csio_hw *, struct csio_mb *));
 230
 231 void csio_fcoe_vnp_read_init_mb(struct csio_lnode *, struct csio_mb *,
 232                         uint32_t, uint32_t , uint32_t ,
 233                         void (*) (struct csio_hw *, struct csio_mb *));
 234
 235 void csio_fcoe_vnp_free_init_mb(struct csio_lnode *, struct csio_mb *,
 236                         uint32_t , uint32_t, uint32_t ,
 237                         void (*) (struct csio_hw *, struct csio_mb *));
 238
 239 void csio_fcoe_read_fcf_init_mb(struct csio_lnode *, struct csio_mb *,
 240                         uint32_t, uint32_t, uint32_t,
 241                         void (*cbfn) (struct csio_hw *, struct csio_mb *));
 242
 243 void csio_fcoe_read_portparams_init_mb(struct csio_hw *hw,
 244                         struct csio_mb *mbp, uint32_t mb_tmo,
 245                         struct fw_fcoe_port_cmd_params *portparams,
 246                         void (*cbfn)(struct csio_hw *, struct csio_mb *));
 247
 248 void csio_mb_process_portparams_rsp(struct csio_hw *hw, struct csio_mb *mbp,
 249                                 enum fw_retval *retval,
 250                                 struct fw_fcoe_port_cmd_params *portparams,
 251                                 struct fw_fcoe_port_stats *portstats);
 252
 253 /* MB module functions */
 254 int csio_mbm_init(struct csio_mbm *, struct csio_hw *,
 255                             void (*)(uintptr_t));
 256 void csio_mbm_exit(struct csio_mbm *);
 257 void csio_mb_intr_enable(struct csio_hw *);
 258 void csio_mb_intr_disable(struct csio_hw *);
 259
 260 int csio_mb_issue(struct csio_hw *, struct csio_mb *);
 261 void csio_mb_completions(struct csio_hw *, struct list_head *);
 262 int csio_mb_fwevt_handler(struct csio_hw *, __be64 *);
 263 int csio_mb_isr_handler(struct csio_hw *);
 264 struct csio_mb *csio_mb_tmo_handler(struct csio_hw *);
 265 void csio_mb_cancel_all(struct csio_hw *, struct list_head *);
 266
 267 #endif /* ifndef __CSIO_MB_H__ */