drivers/scsi/bfa/bfa_fcpim.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2005-2014 Brocade Communications Systems, Inc.
   4  * Copyright (c) 2014- QLogic Corporation.
   5  * All rights reserved
   6  * www.qlogic.com
   7  *
   8  * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter.
   9  */
  10
  11 #include "bfad_drv.h"
  12 #include "bfa_modules.h"
  13
  14 BFA_TRC_FILE(HAL, FCPIM);
  15
  16 /*
  17  *  BFA ITNIM Related definitions
  18  */
  19 static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim);
  20
  21 #define BFA_ITNIM_FROM_TAG(_fcpim, _tag)                                \
  22         (((_fcpim)->itnim_arr + ((_tag) & ((_fcpim)->num_itnims - 1))))
  23
  24 #define bfa_fcpim_additn(__itnim)                                       \
  25         list_add_tail(&(__itnim)->qe, &(__itnim)->fcpim->itnim_q)
  26 #define bfa_fcpim_delitn(__itnim)       do {                            \
  27         WARN_ON(!bfa_q_is_on_q(&(__itnim)->fcpim->itnim_q, __itnim));   \
  28         bfa_itnim_update_del_itn_stats(__itnim);      \
  29         list_del(&(__itnim)->qe);      \
  30         WARN_ON(!list_empty(&(__itnim)->io_q));                         \
  31         WARN_ON(!list_empty(&(__itnim)->io_cleanup_q));                 \
  32         WARN_ON(!list_empty(&(__itnim)->pending_q));                    \
  33 } while (0)
  34
  35 #define bfa_itnim_online_cb(__itnim) do {                               \
  36         if ((__itnim)->bfa->fcs)                                        \
  37                 bfa_cb_itnim_online((__itnim)->ditn);      \
  38         else {                                                          \
  39                 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe,        \
  40                 __bfa_cb_itnim_online, (__itnim));      \
  41         }                                                               \
  42 } while (0)
  43
  44 #define bfa_itnim_offline_cb(__itnim) do {                              \
  45         if ((__itnim)->bfa->fcs)                                        \
  46                 bfa_cb_itnim_offline((__itnim)->ditn);      \
  47         else {                                                          \
  48                 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe,        \
  49                 __bfa_cb_itnim_offline, (__itnim));      \
  50         }                                                               \
  51 } while (0)
  52
  53 #define bfa_itnim_sler_cb(__itnim) do {                                 \
  54         if ((__itnim)->bfa->fcs)                                        \
  55                 bfa_cb_itnim_sler((__itnim)->ditn);      \
  56         else {                                                          \
  57                 bfa_cb_queue((__itnim)->bfa, &(__itnim)->hcb_qe,        \
  58                 __bfa_cb_itnim_sler, (__itnim));      \
  59         }                                                               \
  60 } while (0)
  61
  62 enum bfa_ioim_lm_ua_status {
  63         BFA_IOIM_LM_UA_RESET = 0,
  64         BFA_IOIM_LM_UA_SET = 1,
  65 };
  66
  67 /*
  68  *  itnim state machine event
  69  */
  70 enum bfa_itnim_event {
  71         BFA_ITNIM_SM_CREATE = 1,        /*  itnim is created */
  72         BFA_ITNIM_SM_ONLINE = 2,        /*  itnim is online */
  73         BFA_ITNIM_SM_OFFLINE = 3,       /*  itnim is offline */
  74         BFA_ITNIM_SM_FWRSP = 4,         /*  firmware response */
  75         BFA_ITNIM_SM_DELETE = 5,        /*  deleting an existing itnim */
  76         BFA_ITNIM_SM_CLEANUP = 6,       /*  IO cleanup completion */
  77         BFA_ITNIM_SM_SLER = 7,          /*  second level error recovery */
  78         BFA_ITNIM_SM_HWFAIL = 8,        /*  IOC h/w failure event */
  79         BFA_ITNIM_SM_QRESUME = 9,       /*  queue space available */
  80 };
  81
  82 /*
  83  *  BFA IOIM related definitions
  84  */
  85 #define bfa_ioim_move_to_comp_q(__ioim) do {                            \
  86         list_del(&(__ioim)->qe);                                        \
  87         list_add_tail(&(__ioim)->qe, &(__ioim)->fcpim->ioim_comp_q);    \
  88 } while (0)
  89
  90
  91 #define bfa_ioim_cb_profile_comp(__fcpim, __ioim) do {                  \
  92         if ((__fcpim)->profile_comp)                                    \
  93                 (__fcpim)->profile_comp(__ioim);                        \
  94 } while (0)
  95
  96 #define bfa_ioim_cb_profile_start(__fcpim, __ioim) do {                 \
  97         if ((__fcpim)->profile_start)                                   \
  98                 (__fcpim)->profile_start(__ioim);                       \
  99 } while (0)
 100
 101 /*
 102  * IO state machine events
 103  */
 104 enum bfa_ioim_event {
 105         BFA_IOIM_SM_START       = 1,    /*  io start request from host */
 106         BFA_IOIM_SM_COMP_GOOD   = 2,    /*  io good comp, resource free */
 107         BFA_IOIM_SM_COMP        = 3,    /*  io comp, resource is free */
 108         BFA_IOIM_SM_COMP_UTAG   = 4,    /*  io comp, resource is free */
 109         BFA_IOIM_SM_DONE        = 5,    /*  io comp, resource not free */
 110         BFA_IOIM_SM_FREE        = 6,    /*  io resource is freed */
 111         BFA_IOIM_SM_ABORT       = 7,    /*  abort request from scsi stack */
 112         BFA_IOIM_SM_ABORT_COMP  = 8,    /*  abort from f/w */
 113         BFA_IOIM_SM_ABORT_DONE  = 9,    /*  abort completion from f/w */
 114         BFA_IOIM_SM_QRESUME     = 10,   /*  CQ space available to queue IO */
 115         BFA_IOIM_SM_SGALLOCED   = 11,   /*  SG page allocation successful */
 116         BFA_IOIM_SM_SQRETRY     = 12,   /*  sequence recovery retry */
 117         BFA_IOIM_SM_HCB         = 13,   /*  bfa callback complete */
 118         BFA_IOIM_SM_CLEANUP     = 14,   /*  IO cleanup from itnim */
 119         BFA_IOIM_SM_TMSTART     = 15,   /*  IO cleanup from tskim */
 120         BFA_IOIM_SM_TMDONE      = 16,   /*  IO cleanup from tskim */
 121         BFA_IOIM_SM_HWFAIL      = 17,   /*  IOC h/w failure event */
 122         BFA_IOIM_SM_IOTOV       = 18,   /*  ITN offline TOV */
 123 };
 124
 125
 126 /*
 127  *  BFA TSKIM related definitions
 128  */
 129
 130 /*
 131  * task management completion handling
 132  */
 133 #define bfa_tskim_qcomp(__tskim, __cbfn) do {                           \
 134         bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, __cbfn, (__tskim));\
 135         bfa_tskim_notify_comp(__tskim);      \
 136 } while (0)
 137
 138 #define bfa_tskim_notify_comp(__tskim) do {                             \
 139         if ((__tskim)->notify)                                          \
 140                 bfa_itnim_tskdone((__tskim)->itnim);      \
 141 } while (0)
 142
 143
 144 enum bfa_tskim_event {
 145         BFA_TSKIM_SM_START      = 1,    /*  TM command start            */
 146         BFA_TSKIM_SM_DONE       = 2,    /*  TM completion               */
 147         BFA_TSKIM_SM_QRESUME    = 3,    /*  resume after qfull          */
 148         BFA_TSKIM_SM_HWFAIL     = 5,    /*  IOC h/w failure event       */
 149         BFA_TSKIM_SM_HCB        = 6,    /*  BFA callback completion     */
 150         BFA_TSKIM_SM_IOS_DONE   = 7,    /*  IO and sub TM completions   */
 151         BFA_TSKIM_SM_CLEANUP    = 8,    /*  TM cleanup on ITN offline   */
 152         BFA_TSKIM_SM_CLEANUP_DONE = 9,  /*  TM abort completion */
 153         BFA_TSKIM_SM_UTAG       = 10,   /*  TM completion unknown tag  */
 154 };
 155
 156 /*
 157  * forward declaration for BFA ITNIM functions
 158  */
 159 static void     bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim);
 160 static bfa_boolean_t bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim);
 161 static bfa_boolean_t bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim);
 162 static void     bfa_itnim_cleanp_comp(void *itnim_cbarg);
 163 static void     bfa_itnim_cleanup(struct bfa_itnim_s *itnim);
 164 static void     __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete);
 165 static void     __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete);
 166 static void     __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete);
 167 static void     bfa_itnim_iotov_online(struct bfa_itnim_s *itnim);
 168 static void     bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim);
 169 static void     bfa_itnim_iotov(void *itnim_arg);
 170 static void     bfa_itnim_iotov_start(struct bfa_itnim_s *itnim);
 171 static void     bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim);
 172 static void     bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim);
 173
 174 /*
 175  * forward declaration of ITNIM state machine
 176  */
 177 static void     bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim,
 178                                         enum bfa_itnim_event event);
 179 static void     bfa_itnim_sm_created(struct bfa_itnim_s *itnim,
 180                                         enum bfa_itnim_event event);
 181 static void     bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim,
 182                                         enum bfa_itnim_event event);
 183 static void     bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
 184                                         enum bfa_itnim_event event);
 185 static void     bfa_itnim_sm_online(struct bfa_itnim_s *itnim,
 186                                         enum bfa_itnim_event event);
 187 static void     bfa_itnim_sm_sler(struct bfa_itnim_s *itnim,
 188                                         enum bfa_itnim_event event);
 189 static void     bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
 190                                         enum bfa_itnim_event event);
 191 static void     bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
 192                                         enum bfa_itnim_event event);
 193 static void     bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim,
 194                                         enum bfa_itnim_event event);
 195 static void     bfa_itnim_sm_offline(struct bfa_itnim_s *itnim,
 196                                         enum bfa_itnim_event event);
 197 static void     bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
 198                                         enum bfa_itnim_event event);
 199 static void     bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim,
 200                                         enum bfa_itnim_event event);
 201 static void     bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
 202                                         enum bfa_itnim_event event);
 203 static void     bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
 204                                         enum bfa_itnim_event event);
 205 static void     bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
 206                                         enum bfa_itnim_event event);
 207
 208 /*
 209  * forward declaration for BFA IOIM functions
 210  */
 211 static bfa_boolean_t    bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
 212 static bfa_boolean_t    bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim);
 213 static bfa_boolean_t    bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
 214 static void             bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
 215 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
 216 static void __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete);
 217 static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
 218 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
 219 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
 220 static bfa_boolean_t    bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);
 221
 222 /*
 223  * forward declaration of BFA IO state machine
 224  */
 225 static void     bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim,
 226                                         enum bfa_ioim_event event);
 227 static void     bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim,
 228                                         enum bfa_ioim_event event);
 229 static void     bfa_ioim_sm_active(struct bfa_ioim_s *ioim,
 230                                         enum bfa_ioim_event event);
 231 static void     bfa_ioim_sm_abort(struct bfa_ioim_s *ioim,
 232                                         enum bfa_ioim_event event);
 233 static void     bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim,
 234                                         enum bfa_ioim_event event);
 235 static void     bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim,
 236                                         enum bfa_ioim_event event);
 237 static void     bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim,
 238                                         enum bfa_ioim_event event);
 239 static void     bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim,
 240                                         enum bfa_ioim_event event);
 241 static void     bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim,
 242                                         enum bfa_ioim_event event);
 243 static void     bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim,
 244                                         enum bfa_ioim_event event);
 245 static void     bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
 246                                         enum bfa_ioim_event event);
 247 static void     bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim,
 248                                         enum bfa_ioim_event event);
 249 /*
 250  * forward declaration for BFA TSKIM functions
 251  */
 252 static void     __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete);
 253 static void     __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete);
 254 static bfa_boolean_t bfa_tskim_match_scope(struct bfa_tskim_s *tskim,
 255                                         struct scsi_lun lun);
 256 static void     bfa_tskim_gather_ios(struct bfa_tskim_s *tskim);
 257 static void     bfa_tskim_cleanp_comp(void *tskim_cbarg);
 258 static void     bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim);
 259 static bfa_boolean_t bfa_tskim_send(struct bfa_tskim_s *tskim);
 260 static bfa_boolean_t bfa_tskim_send_abort(struct bfa_tskim_s *tskim);
 261 static void     bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim);
 262
 263 /*
 264  * forward declaration of BFA TSKIM state machine
 265  */
 266 static void     bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim,
 267                                         enum bfa_tskim_event event);
 268 static void     bfa_tskim_sm_active(struct bfa_tskim_s *tskim,
 269                                         enum bfa_tskim_event event);
 270 static void     bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim,
 271                                         enum bfa_tskim_event event);
 272 static void     bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim,
 273                                         enum bfa_tskim_event event);
 274 static void     bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim,
 275                                         enum bfa_tskim_event event);
 276 static void     bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
 277                                         enum bfa_tskim_event event);
 278 static void     bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim,
 279                                         enum bfa_tskim_event event);
 280 /*
 281  *  BFA FCP Initiator Mode module
 282  */
 283
 284 /*
 285  * Compute and return memory needed by FCP(im) module.
 286  */
 287 static void
 288 bfa_fcpim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len)
 289 {
 290         bfa_itnim_meminfo(cfg, km_len);
 291
 292         /*
 293          * IO memory
 294          */
 295         *km_len += cfg->fwcfg.num_ioim_reqs *
 296           (sizeof(struct bfa_ioim_s) + sizeof(struct bfa_ioim_sp_s));
 297
 298         /*
 299          * task management command memory
 300          */
 301         if (cfg->fwcfg.num_tskim_reqs < BFA_TSKIM_MIN)
 302                 cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN;
 303         *km_len += cfg->fwcfg.num_tskim_reqs * sizeof(struct bfa_tskim_s);
 304 }
 305
 306
 307 static void
 308 bfa_fcpim_attach(struct bfa_fcp_mod_s *fcp, void *bfad,
 309                 struct bfa_iocfc_cfg_s *cfg, struct bfa_pcidev_s *pcidev)
 310 {
 311         struct bfa_fcpim_s *fcpim = &fcp->fcpim;
 312         struct bfa_s *bfa = fcp->bfa;
 313
 314         bfa_trc(bfa, cfg->drvcfg.path_tov);
 315         bfa_trc(bfa, cfg->fwcfg.num_rports);
 316         bfa_trc(bfa, cfg->fwcfg.num_ioim_reqs);
 317         bfa_trc(bfa, cfg->fwcfg.num_tskim_reqs);
 318
 319         fcpim->fcp              = fcp;
 320         fcpim->bfa              = bfa;
 321         fcpim->num_itnims       = cfg->fwcfg.num_rports;
 322         fcpim->num_tskim_reqs = cfg->fwcfg.num_tskim_reqs;
 323         fcpim->path_tov         = cfg->drvcfg.path_tov;
 324         fcpim->delay_comp       = cfg->drvcfg.delay_comp;
 325         fcpim->profile_comp = NULL;
 326         fcpim->profile_start = NULL;
 327
 328         bfa_itnim_attach(fcpim);
 329         bfa_tskim_attach(fcpim);
 330         bfa_ioim_attach(fcpim);
 331 }
 332
 333 void
 334 bfa_fcpim_iocdisable(struct bfa_fcp_mod_s *fcp)
 335 {
 336         struct bfa_fcpim_s *fcpim = &fcp->fcpim;
 337         struct bfa_itnim_s *itnim;
 338         struct list_head *qe, *qen;
 339
 340         /* Enqueue unused ioim resources to free_q */
 341         list_splice_tail_init(&fcpim->tskim_unused_q, &fcpim->tskim_free_q);
 342
 343         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
 344                 itnim = (struct bfa_itnim_s *) qe;
 345                 bfa_itnim_iocdisable(itnim);
 346         }
 347 }
 348
 349 void
 350 bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov)
 351 {
 352         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 353
 354         fcpim->path_tov = path_tov * 1000;
 355         if (fcpim->path_tov > BFA_FCPIM_PATHTOV_MAX)
 356                 fcpim->path_tov = BFA_FCPIM_PATHTOV_MAX;
 357 }
 358
 359 u16
 360 bfa_fcpim_path_tov_get(struct bfa_s *bfa)
 361 {
 362         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 363
 364         return fcpim->path_tov / 1000;
 365 }
 366
 367 #define bfa_fcpim_add_iostats(__l, __r, __stats)        \
 368         (__l->__stats += __r->__stats)
 369
 370 void
 371 bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
 372                 struct bfa_itnim_iostats_s *rstats)
 373 {
 374         bfa_fcpim_add_iostats(lstats, rstats, total_ios);
 375         bfa_fcpim_add_iostats(lstats, rstats, qresumes);
 376         bfa_fcpim_add_iostats(lstats, rstats, no_iotags);
 377         bfa_fcpim_add_iostats(lstats, rstats, io_aborts);
 378         bfa_fcpim_add_iostats(lstats, rstats, no_tskims);
 379         bfa_fcpim_add_iostats(lstats, rstats, iocomp_ok);
 380         bfa_fcpim_add_iostats(lstats, rstats, iocomp_underrun);
 381         bfa_fcpim_add_iostats(lstats, rstats, iocomp_overrun);
 382         bfa_fcpim_add_iostats(lstats, rstats, iocomp_aborted);
 383         bfa_fcpim_add_iostats(lstats, rstats, iocomp_timedout);
 384         bfa_fcpim_add_iostats(lstats, rstats, iocom_nexus_abort);
 385         bfa_fcpim_add_iostats(lstats, rstats, iocom_proto_err);
 386         bfa_fcpim_add_iostats(lstats, rstats, iocom_dif_err);
 387         bfa_fcpim_add_iostats(lstats, rstats, iocom_sqer_needed);
 388         bfa_fcpim_add_iostats(lstats, rstats, iocom_res_free);
 389         bfa_fcpim_add_iostats(lstats, rstats, iocom_hostabrts);
 390         bfa_fcpim_add_iostats(lstats, rstats, iocom_utags);
 391         bfa_fcpim_add_iostats(lstats, rstats, io_cleanups);
 392         bfa_fcpim_add_iostats(lstats, rstats, io_tmaborts);
 393         bfa_fcpim_add_iostats(lstats, rstats, onlines);
 394         bfa_fcpim_add_iostats(lstats, rstats, offlines);
 395         bfa_fcpim_add_iostats(lstats, rstats, creates);
 396         bfa_fcpim_add_iostats(lstats, rstats, deletes);
 397         bfa_fcpim_add_iostats(lstats, rstats, create_comps);
 398         bfa_fcpim_add_iostats(lstats, rstats, delete_comps);
 399         bfa_fcpim_add_iostats(lstats, rstats, sler_events);
 400         bfa_fcpim_add_iostats(lstats, rstats, fw_create);
 401         bfa_fcpim_add_iostats(lstats, rstats, fw_delete);
 402         bfa_fcpim_add_iostats(lstats, rstats, ioc_disabled);
 403         bfa_fcpim_add_iostats(lstats, rstats, cleanup_comps);
 404         bfa_fcpim_add_iostats(lstats, rstats, tm_cmnds);
 405         bfa_fcpim_add_iostats(lstats, rstats, tm_fw_rsps);
 406         bfa_fcpim_add_iostats(lstats, rstats, tm_success);
 407         bfa_fcpim_add_iostats(lstats, rstats, tm_failures);
 408         bfa_fcpim_add_iostats(lstats, rstats, tm_io_comps);
 409         bfa_fcpim_add_iostats(lstats, rstats, tm_qresumes);
 410         bfa_fcpim_add_iostats(lstats, rstats, tm_iocdowns);
 411         bfa_fcpim_add_iostats(lstats, rstats, tm_cleanups);
 412         bfa_fcpim_add_iostats(lstats, rstats, tm_cleanup_comps);
 413         bfa_fcpim_add_iostats(lstats, rstats, io_comps);
 414         bfa_fcpim_add_iostats(lstats, rstats, input_reqs);
 415         bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
 416         bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
 417         bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
 418 }
 419
 420 bfa_status_t
 421 bfa_fcpim_port_iostats(struct bfa_s *bfa,
 422                 struct bfa_itnim_iostats_s *stats, u8 lp_tag)
 423 {
 424         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 425         struct list_head *qe, *qen;
 426         struct bfa_itnim_s *itnim;
 427
 428         /* accumulate IO stats from itnim */
 429         memset(stats, 0, sizeof(struct bfa_itnim_iostats_s));
 430         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
 431                 itnim = (struct bfa_itnim_s *) qe;
 432                 if (itnim->rport->rport_info.lp_tag != lp_tag)
 433                         continue;
 434                 bfa_fcpim_add_stats(stats, &(itnim->stats));
 435         }
 436         return BFA_STATUS_OK;
 437 }
 438
 439 static void
 440 bfa_ioim_profile_comp(struct bfa_ioim_s *ioim)
 441 {
 442         struct bfa_itnim_latency_s *io_lat =
 443                         &(ioim->itnim->ioprofile.io_latency);
 444         u32 val, idx;
 445
 446         val = (u32)(jiffies - ioim->start_time);
 447         idx = bfa_ioim_get_index(scsi_bufflen((struct scsi_cmnd *)ioim->dio));
 448         bfa_itnim_ioprofile_update(ioim->itnim, idx);
 449
 450         io_lat->count[idx]++;
 451         io_lat->min[idx] = (io_lat->min[idx] < val) ? io_lat->min[idx] : val;
 452         io_lat->max[idx] = (io_lat->max[idx] > val) ? io_lat->max[idx] : val;
 453         io_lat->avg[idx] += val;
 454 }
 455
 456 static void
 457 bfa_ioim_profile_start(struct bfa_ioim_s *ioim)
 458 {
 459         ioim->start_time = jiffies;
 460 }
 461
 462 bfa_status_t
 463 bfa_fcpim_profile_on(struct bfa_s *bfa, time64_t time)
 464 {
 465         struct bfa_itnim_s *itnim;
 466         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 467         struct list_head *qe, *qen;
 468
 469         /* accumulate IO stats from itnim */
 470         list_for_each_safe(qe, qen, &fcpim->itnim_q) {
 471                 itnim = (struct bfa_itnim_s *) qe;
 472                 bfa_itnim_clear_stats(itnim);
 473         }
 474         fcpim->io_profile = BFA_TRUE;
 475         fcpim->io_profile_start_time = time;
 476         fcpim->profile_comp = bfa_ioim_profile_comp;
 477         fcpim->profile_start = bfa_ioim_profile_start;
 478         return BFA_STATUS_OK;
 479 }
 480
 481 bfa_status_t
 482 bfa_fcpim_profile_off(struct bfa_s *bfa)
 483 {
 484         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 485         fcpim->io_profile = BFA_FALSE;
 486         fcpim->io_profile_start_time = 0;
 487         fcpim->profile_comp = NULL;
 488         fcpim->profile_start = NULL;
 489         return BFA_STATUS_OK;
 490 }
 491
 492 u16
 493 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
 494 {
 495         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
 496
 497         return fcpim->q_depth;
 498 }
 499
 500 /*
 501  *  BFA ITNIM module state machine functions
 502  */
 503
 504 /*
 505  * Beginning/unallocated state - no events expected.
 506  */
 507 static void
 508 bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 509 {
 510         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 511         bfa_trc(itnim->bfa, event);
 512
 513         switch (event) {
 514         case BFA_ITNIM_SM_CREATE:
 515                 bfa_sm_set_state(itnim, bfa_itnim_sm_created);
 516                 itnim->is_online = BFA_FALSE;
 517                 bfa_fcpim_additn(itnim);
 518                 break;
 519
 520         default:
 521                 bfa_sm_fault(itnim->bfa, event);
 522         }
 523 }
 524
 525 /*
 526  * Beginning state, only online event expected.
 527  */
 528 static void
 529 bfa_itnim_sm_created(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 530 {
 531         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 532         bfa_trc(itnim->bfa, event);
 533
 534         switch (event) {
 535         case BFA_ITNIM_SM_ONLINE:
 536                 if (bfa_itnim_send_fwcreate(itnim))
 537                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
 538                 else
 539                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
 540                 break;
 541
 542         case BFA_ITNIM_SM_DELETE:
 543                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 544                 bfa_fcpim_delitn(itnim);
 545                 break;
 546
 547         case BFA_ITNIM_SM_HWFAIL:
 548                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 549                 break;
 550
 551         default:
 552                 bfa_sm_fault(itnim->bfa, event);
 553         }
 554 }
 555
 556 /*
 557  *      Waiting for itnim create response from firmware.
 558  */
 559 static void
 560 bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 561 {
 562         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 563         bfa_trc(itnim->bfa, event);
 564
 565         switch (event) {
 566         case BFA_ITNIM_SM_FWRSP:
 567                 bfa_sm_set_state(itnim, bfa_itnim_sm_online);
 568                 itnim->is_online = BFA_TRUE;
 569                 bfa_itnim_iotov_online(itnim);
 570                 bfa_itnim_online_cb(itnim);
 571                 break;
 572
 573         case BFA_ITNIM_SM_DELETE:
 574                 bfa_sm_set_state(itnim, bfa_itnim_sm_delete_pending);
 575                 break;
 576
 577         case BFA_ITNIM_SM_OFFLINE:
 578                 if (bfa_itnim_send_fwdelete(itnim))
 579                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
 580                 else
 581                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
 582                 break;
 583
 584         case BFA_ITNIM_SM_HWFAIL:
 585                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 586                 break;
 587
 588         default:
 589                 bfa_sm_fault(itnim->bfa, event);
 590         }
 591 }
 592
 593 static void
 594 bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
 595                         enum bfa_itnim_event event)
 596 {
 597         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 598         bfa_trc(itnim->bfa, event);
 599
 600         switch (event) {
 601         case BFA_ITNIM_SM_QRESUME:
 602                 bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
 603                 bfa_itnim_send_fwcreate(itnim);
 604                 break;
 605
 606         case BFA_ITNIM_SM_DELETE:
 607                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 608                 bfa_reqq_wcancel(&itnim->reqq_wait);
 609                 bfa_fcpim_delitn(itnim);
 610                 break;
 611
 612         case BFA_ITNIM_SM_OFFLINE:
 613                 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
 614                 bfa_reqq_wcancel(&itnim->reqq_wait);
 615                 bfa_itnim_offline_cb(itnim);
 616                 break;
 617
 618         case BFA_ITNIM_SM_HWFAIL:
 619                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 620                 bfa_reqq_wcancel(&itnim->reqq_wait);
 621                 break;
 622
 623         default:
 624                 bfa_sm_fault(itnim->bfa, event);
 625         }
 626 }
 627
 628 /*
 629  * Waiting for itnim create response from firmware, a delete is pending.
 630  */
 631 static void
 632 bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
 633                                 enum bfa_itnim_event event)
 634 {
 635         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 636         bfa_trc(itnim->bfa, event);
 637
 638         switch (event) {
 639         case BFA_ITNIM_SM_FWRSP:
 640                 if (bfa_itnim_send_fwdelete(itnim))
 641                         bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
 642                 else
 643                         bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
 644                 break;
 645
 646         case BFA_ITNIM_SM_HWFAIL:
 647                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 648                 bfa_fcpim_delitn(itnim);
 649                 break;
 650
 651         default:
 652                 bfa_sm_fault(itnim->bfa, event);
 653         }
 654 }
 655
 656 /*
 657  * Online state - normal parking state.
 658  */
 659 static void
 660 bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 661 {
 662         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 663         bfa_trc(itnim->bfa, event);
 664
 665         switch (event) {
 666         case BFA_ITNIM_SM_OFFLINE:
 667                 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
 668                 itnim->is_online = BFA_FALSE;
 669                 bfa_itnim_iotov_start(itnim);
 670                 bfa_itnim_cleanup(itnim);
 671                 break;
 672
 673         case BFA_ITNIM_SM_DELETE:
 674                 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
 675                 itnim->is_online = BFA_FALSE;
 676                 bfa_itnim_cleanup(itnim);
 677                 break;
 678
 679         case BFA_ITNIM_SM_SLER:
 680                 bfa_sm_set_state(itnim, bfa_itnim_sm_sler);
 681                 itnim->is_online = BFA_FALSE;
 682                 bfa_itnim_iotov_start(itnim);
 683                 bfa_itnim_sler_cb(itnim);
 684                 break;
 685
 686         case BFA_ITNIM_SM_HWFAIL:
 687                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 688                 itnim->is_online = BFA_FALSE;
 689                 bfa_itnim_iotov_start(itnim);
 690                 bfa_itnim_iocdisable_cleanup(itnim);
 691                 break;
 692
 693         default:
 694                 bfa_sm_fault(itnim->bfa, event);
 695         }
 696 }
 697
 698 /*
 699  * Second level error recovery need.
 700  */
 701 static void
 702 bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 703 {
 704         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 705         bfa_trc(itnim->bfa, event);
 706
 707         switch (event) {
 708         case BFA_ITNIM_SM_OFFLINE:
 709                 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_offline);
 710                 bfa_itnim_cleanup(itnim);
 711                 break;
 712
 713         case BFA_ITNIM_SM_DELETE:
 714                 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
 715                 bfa_itnim_cleanup(itnim);
 716                 bfa_itnim_iotov_delete(itnim);
 717                 break;
 718
 719         case BFA_ITNIM_SM_HWFAIL:
 720                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 721                 bfa_itnim_iocdisable_cleanup(itnim);
 722                 break;
 723
 724         default:
 725                 bfa_sm_fault(itnim->bfa, event);
 726         }
 727 }
 728
 729 /*
 730  * Going offline. Waiting for active IO cleanup.
 731  */
 732 static void
 733 bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
 734                                  enum bfa_itnim_event event)
 735 {
 736         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 737         bfa_trc(itnim->bfa, event);
 738
 739         switch (event) {
 740         case BFA_ITNIM_SM_CLEANUP:
 741                 if (bfa_itnim_send_fwdelete(itnim))
 742                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
 743                 else
 744                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete_qfull);
 745                 break;
 746
 747         case BFA_ITNIM_SM_DELETE:
 748                 bfa_sm_set_state(itnim, bfa_itnim_sm_cleanup_delete);
 749                 bfa_itnim_iotov_delete(itnim);
 750                 break;
 751
 752         case BFA_ITNIM_SM_HWFAIL:
 753                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 754                 bfa_itnim_iocdisable_cleanup(itnim);
 755                 bfa_itnim_offline_cb(itnim);
 756                 break;
 757
 758         case BFA_ITNIM_SM_SLER:
 759                 break;
 760
 761         default:
 762                 bfa_sm_fault(itnim->bfa, event);
 763         }
 764 }
 765
 766 /*
 767  * Deleting itnim. Waiting for active IO cleanup.
 768  */
 769 static void
 770 bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
 771                                 enum bfa_itnim_event event)
 772 {
 773         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 774         bfa_trc(itnim->bfa, event);
 775
 776         switch (event) {
 777         case BFA_ITNIM_SM_CLEANUP:
 778                 if (bfa_itnim_send_fwdelete(itnim))
 779                         bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
 780                 else
 781                         bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
 782                 break;
 783
 784         case BFA_ITNIM_SM_HWFAIL:
 785                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 786                 bfa_itnim_iocdisable_cleanup(itnim);
 787                 break;
 788
 789         default:
 790                 bfa_sm_fault(itnim->bfa, event);
 791         }
 792 }
 793
 794 /*
 795  * Rport offline. Fimrware itnim is being deleted - awaiting f/w response.
 796  */
 797 static void
 798 bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 799 {
 800         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 801         bfa_trc(itnim->bfa, event);
 802
 803         switch (event) {
 804         case BFA_ITNIM_SM_FWRSP:
 805                 bfa_sm_set_state(itnim, bfa_itnim_sm_offline);
 806                 bfa_itnim_offline_cb(itnim);
 807                 break;
 808
 809         case BFA_ITNIM_SM_DELETE:
 810                 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
 811                 break;
 812
 813         case BFA_ITNIM_SM_HWFAIL:
 814                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 815                 bfa_itnim_offline_cb(itnim);
 816                 break;
 817
 818         default:
 819                 bfa_sm_fault(itnim->bfa, event);
 820         }
 821 }
 822
 823 static void
 824 bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
 825                         enum bfa_itnim_event event)
 826 {
 827         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 828         bfa_trc(itnim->bfa, event);
 829
 830         switch (event) {
 831         case BFA_ITNIM_SM_QRESUME:
 832                 bfa_sm_set_state(itnim, bfa_itnim_sm_fwdelete);
 833                 bfa_itnim_send_fwdelete(itnim);
 834                 break;
 835
 836         case BFA_ITNIM_SM_DELETE:
 837                 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting_qfull);
 838                 break;
 839
 840         case BFA_ITNIM_SM_HWFAIL:
 841                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 842                 bfa_reqq_wcancel(&itnim->reqq_wait);
 843                 bfa_itnim_offline_cb(itnim);
 844                 break;
 845
 846         default:
 847                 bfa_sm_fault(itnim->bfa, event);
 848         }
 849 }
 850
 851 /*
 852  * Offline state.
 853  */
 854 static void
 855 bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 856 {
 857         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 858         bfa_trc(itnim->bfa, event);
 859
 860         switch (event) {
 861         case BFA_ITNIM_SM_DELETE:
 862                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 863                 bfa_itnim_iotov_delete(itnim);
 864                 bfa_fcpim_delitn(itnim);
 865                 break;
 866
 867         case BFA_ITNIM_SM_ONLINE:
 868                 if (bfa_itnim_send_fwcreate(itnim))
 869                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
 870                 else
 871                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
 872                 break;
 873
 874         case BFA_ITNIM_SM_HWFAIL:
 875                 bfa_sm_set_state(itnim, bfa_itnim_sm_iocdisable);
 876                 break;
 877
 878         default:
 879                 bfa_sm_fault(itnim->bfa, event);
 880         }
 881 }
 882
 883 static void
 884 bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
 885                                 enum bfa_itnim_event event)
 886 {
 887         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 888         bfa_trc(itnim->bfa, event);
 889
 890         switch (event) {
 891         case BFA_ITNIM_SM_DELETE:
 892                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 893                 bfa_itnim_iotov_delete(itnim);
 894                 bfa_fcpim_delitn(itnim);
 895                 break;
 896
 897         case BFA_ITNIM_SM_OFFLINE:
 898                 bfa_itnim_offline_cb(itnim);
 899                 break;
 900
 901         case BFA_ITNIM_SM_ONLINE:
 902                 if (bfa_itnim_send_fwcreate(itnim))
 903                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate);
 904                 else
 905                         bfa_sm_set_state(itnim, bfa_itnim_sm_fwcreate_qfull);
 906                 break;
 907
 908         case BFA_ITNIM_SM_HWFAIL:
 909                 break;
 910
 911         default:
 912                 bfa_sm_fault(itnim->bfa, event);
 913         }
 914 }
 915
 916 /*
 917  * Itnim is deleted, waiting for firmware response to delete.
 918  */
 919 static void
 920 bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
 921 {
 922         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 923         bfa_trc(itnim->bfa, event);
 924
 925         switch (event) {
 926         case BFA_ITNIM_SM_FWRSP:
 927         case BFA_ITNIM_SM_HWFAIL:
 928                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 929                 bfa_fcpim_delitn(itnim);
 930                 break;
 931
 932         default:
 933                 bfa_sm_fault(itnim->bfa, event);
 934         }
 935 }
 936
 937 static void
 938 bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
 939                 enum bfa_itnim_event event)
 940 {
 941         bfa_trc(itnim->bfa, itnim->rport->rport_tag);
 942         bfa_trc(itnim->bfa, event);
 943
 944         switch (event) {
 945         case BFA_ITNIM_SM_QRESUME:
 946                 bfa_sm_set_state(itnim, bfa_itnim_sm_deleting);
 947                 bfa_itnim_send_fwdelete(itnim);
 948                 break;
 949
 950         case BFA_ITNIM_SM_HWFAIL:
 951                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
 952                 bfa_reqq_wcancel(&itnim->reqq_wait);
 953                 bfa_fcpim_delitn(itnim);
 954                 break;
 955
 956         default:
 957                 bfa_sm_fault(itnim->bfa, event);
 958         }
 959 }
 960
 961 /*
 962  * Initiate cleanup of all IOs on an IOC failure.
 963  */
 964 static void
 965 bfa_itnim_iocdisable_cleanup(struct bfa_itnim_s *itnim)
 966 {
 967         struct bfa_tskim_s *tskim;
 968         struct bfa_ioim_s *ioim;
 969         struct list_head        *qe, *qen;
 970
 971         list_for_each_safe(qe, qen, &itnim->tsk_q) {
 972                 tskim = (struct bfa_tskim_s *) qe;
 973                 bfa_tskim_iocdisable(tskim);
 974         }
 975
 976         list_for_each_safe(qe, qen, &itnim->io_q) {
 977                 ioim = (struct bfa_ioim_s *) qe;
 978                 bfa_ioim_iocdisable(ioim);
 979         }
 980
 981         /*
 982          * For IO request in pending queue, we pretend an early timeout.
 983          */
 984         list_for_each_safe(qe, qen, &itnim->pending_q) {
 985                 ioim = (struct bfa_ioim_s *) qe;
 986                 bfa_ioim_tov(ioim);
 987         }
 988
 989         list_for_each_safe(qe, qen, &itnim->io_cleanup_q) {
 990                 ioim = (struct bfa_ioim_s *) qe;
 991                 bfa_ioim_iocdisable(ioim);
 992         }
 993 }
 994
 995 /*
 996  * IO cleanup completion
 997  */
 998 static void
 999 bfa_itnim_cleanp_comp(void *itnim_cbarg)
1000 {
1001         struct bfa_itnim_s *itnim = itnim_cbarg;
1002
1003         bfa_stats(itnim, cleanup_comps);
1004         bfa_sm_send_event(itnim, BFA_ITNIM_SM_CLEANUP);
1005 }
1006
1007 /*
1008  * Initiate cleanup of all IOs.
1009  */
1010 static void
1011 bfa_itnim_cleanup(struct bfa_itnim_s *itnim)
1012 {
1013         struct bfa_ioim_s  *ioim;
1014         struct bfa_tskim_s *tskim;
1015         struct list_head        *qe, *qen;
1016
1017         bfa_wc_init(&itnim->wc, bfa_itnim_cleanp_comp, itnim);
1018
1019         list_for_each_safe(qe, qen, &itnim->io_q) {
1020                 ioim = (struct bfa_ioim_s *) qe;
1021
1022                 /*
1023                  * Move IO to a cleanup queue from active queue so that a later
1024                  * TM will not pickup this IO.
1025                  */
1026                 list_del(&ioim->qe);
1027                 list_add_tail(&ioim->qe, &itnim->io_cleanup_q);
1028
1029                 bfa_wc_up(&itnim->wc);
1030                 bfa_ioim_cleanup(ioim);
1031         }
1032
1033         list_for_each_safe(qe, qen, &itnim->tsk_q) {
1034                 tskim = (struct bfa_tskim_s *) qe;
1035                 bfa_wc_up(&itnim->wc);
1036                 bfa_tskim_cleanup(tskim);
1037         }
1038
1039         bfa_wc_wait(&itnim->wc);
1040 }
1041
1042 static void
1043 __bfa_cb_itnim_online(void *cbarg, bfa_boolean_t complete)
1044 {
1045         struct bfa_itnim_s *itnim = cbarg;
1046
1047         if (complete)
1048                 bfa_cb_itnim_online(itnim->ditn);
1049 }
1050
1051 static void
1052 __bfa_cb_itnim_offline(void *cbarg, bfa_boolean_t complete)
1053 {
1054         struct bfa_itnim_s *itnim = cbarg;
1055
1056         if (complete)
1057                 bfa_cb_itnim_offline(itnim->ditn);
1058 }
1059
1060 static void
1061 __bfa_cb_itnim_sler(void *cbarg, bfa_boolean_t complete)
1062 {
1063         struct bfa_itnim_s *itnim = cbarg;
1064
1065         if (complete)
1066                 bfa_cb_itnim_sler(itnim->ditn);
1067 }
1068
1069 /*
1070  * Call to resume any I/O requests waiting for room in request queue.
1071  */
1072 static void
1073 bfa_itnim_qresume(void *cbarg)
1074 {
1075         struct bfa_itnim_s *itnim = cbarg;
1076
1077         bfa_sm_send_event(itnim, BFA_ITNIM_SM_QRESUME);
1078 }
1079
1080 /*
1081  *  bfa_itnim_public
1082  */
1083
1084 void
1085 bfa_itnim_iodone(struct bfa_itnim_s *itnim)
1086 {
1087         bfa_wc_down(&itnim->wc);
1088 }
1089
1090 void
1091 bfa_itnim_tskdone(struct bfa_itnim_s *itnim)
1092 {
1093         bfa_wc_down(&itnim->wc);
1094 }
1095
1096 void
1097 bfa_itnim_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *km_len)
1098 {
1099         /*
1100          * ITN memory
1101          */
1102         *km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_itnim_s);
1103 }
1104
1105 void
1106 bfa_itnim_attach(struct bfa_fcpim_s *fcpim)
1107 {
1108         struct bfa_s    *bfa = fcpim->bfa;
1109         struct bfa_fcp_mod_s    *fcp = fcpim->fcp;
1110         struct bfa_itnim_s *itnim;
1111         int     i, j;
1112
1113         INIT_LIST_HEAD(&fcpim->itnim_q);
1114
1115         itnim = (struct bfa_itnim_s *) bfa_mem_kva_curp(fcp);
1116         fcpim->itnim_arr = itnim;
1117
1118         for (i = 0; i < fcpim->num_itnims; i++, itnim++) {
1119                 memset(itnim, 0, sizeof(struct bfa_itnim_s));
1120                 itnim->bfa = bfa;
1121                 itnim->fcpim = fcpim;
1122                 itnim->reqq = BFA_REQQ_QOS_LO;
1123                 itnim->rport = BFA_RPORT_FROM_TAG(bfa, i);
1124                 itnim->iotov_active = BFA_FALSE;
1125                 bfa_reqq_winit(&itnim->reqq_wait, bfa_itnim_qresume, itnim);
1126
1127                 INIT_LIST_HEAD(&itnim->io_q);
1128                 INIT_LIST_HEAD(&itnim->io_cleanup_q);
1129                 INIT_LIST_HEAD(&itnim->pending_q);
1130                 INIT_LIST_HEAD(&itnim->tsk_q);
1131                 INIT_LIST_HEAD(&itnim->delay_comp_q);
1132                 for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1133                         itnim->ioprofile.io_latency.min[j] = ~0;
1134                 bfa_sm_set_state(itnim, bfa_itnim_sm_uninit);
1135         }
1136
1137         bfa_mem_kva_curp(fcp) = (u8 *) itnim;
1138 }
1139
1140 void
1141 bfa_itnim_iocdisable(struct bfa_itnim_s *itnim)
1142 {
1143         bfa_stats(itnim, ioc_disabled);
1144         bfa_sm_send_event(itnim, BFA_ITNIM_SM_HWFAIL);
1145 }
1146
1147 static bfa_boolean_t
1148 bfa_itnim_send_fwcreate(struct bfa_itnim_s *itnim)
1149 {
1150         struct bfi_itn_create_req_s *m;
1151
1152         itnim->msg_no++;
1153
1154         /*
1155          * check for room in queue to send request now
1156          */
1157         m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1158         if (!m) {
1159                 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1160                 return BFA_FALSE;
1161         }
1162
1163         bfi_h2i_set(m->mh, BFI_MC_ITN, BFI_ITN_H2I_CREATE_REQ,
1164                         bfa_fn_lpu(itnim->bfa));
1165         m->fw_handle = itnim->rport->fw_handle;
1166         m->class = FC_CLASS_3;
1167         m->seq_rec = itnim->seq_rec;
1168         m->msg_no = itnim->msg_no;
1169         bfa_stats(itnim, fw_create);
1170
1171         /*
1172          * queue I/O message to firmware
1173          */
1174         bfa_reqq_produce(itnim->bfa, itnim->reqq, m->mh);
1175         return BFA_TRUE;
1176 }
1177
1178 static bfa_boolean_t
1179 bfa_itnim_send_fwdelete(struct bfa_itnim_s *itnim)
1180 {
1181         struct bfi_itn_delete_req_s *m;
1182
1183         /*
1184          * check for room in queue to send request now
1185          */
1186         m = bfa_reqq_next(itnim->bfa, itnim->reqq);
1187         if (!m) {
1188                 bfa_reqq_wait(itnim->bfa, itnim->reqq, &itnim->reqq_wait);
1189                 return BFA_FALSE;
1190         }
1191
1192         bfi_h2i_set(m->mh, BFI_MC_ITN, BFI_ITN_H2I_DELETE_REQ,
1193                         bfa_fn_lpu(itnim->bfa));
1194         m->fw_handle = itnim->rport->fw_handle;
1195         bfa_stats(itnim, fw_delete);
1196
1197         /*
1198          * queue I/O message to firmware
1199          */
1200         bfa_reqq_produce(itnim->bfa, itnim->reqq, m->mh);
1201         return BFA_TRUE;
1202 }
1203
1204 /*
1205  * Cleanup all pending failed inflight requests.
1206  */
1207 static void
1208 bfa_itnim_delayed_comp(struct bfa_itnim_s *itnim, bfa_boolean_t iotov)
1209 {
1210         struct bfa_ioim_s *ioim;
1211         struct list_head *qe, *qen;
1212
1213         list_for_each_safe(qe, qen, &itnim->delay_comp_q) {
1214                 ioim = (struct bfa_ioim_s *)qe;
1215                 bfa_ioim_delayed_comp(ioim, iotov);
1216         }
1217 }
1218
1219 /*
1220  * Start all pending IO requests.
1221  */
1222 static void
1223 bfa_itnim_iotov_online(struct bfa_itnim_s *itnim)
1224 {
1225         struct bfa_ioim_s *ioim;
1226
1227         bfa_itnim_iotov_stop(itnim);
1228
1229         /*
1230          * Abort all inflight IO requests in the queue
1231          */
1232         bfa_itnim_delayed_comp(itnim, BFA_FALSE);
1233
1234         /*
1235          * Start all pending IO requests.
1236          */
1237         while (!list_empty(&itnim->pending_q)) {
1238                 bfa_q_deq(&itnim->pending_q, &ioim);
1239                 list_add_tail(&ioim->qe, &itnim->io_q);
1240                 bfa_ioim_start(ioim);
1241         }
1242 }
1243
1244 /*
1245  * Fail all pending IO requests
1246  */
1247 static void
1248 bfa_itnim_iotov_cleanup(struct bfa_itnim_s *itnim)
1249 {
1250         struct bfa_ioim_s *ioim;
1251
1252         /*
1253          * Fail all inflight IO requests in the queue
1254          */
1255         bfa_itnim_delayed_comp(itnim, BFA_TRUE);
1256
1257         /*
1258          * Fail any pending IO requests.
1259          */
1260         while (!list_empty(&itnim->pending_q)) {
1261                 bfa_q_deq(&itnim->pending_q, &ioim);
1262                 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
1263                 bfa_ioim_tov(ioim);
1264         }
1265 }
1266
1267 /*
1268  * IO TOV timer callback. Fail any pending IO requests.
1269  */
1270 static void
1271 bfa_itnim_iotov(void *itnim_arg)
1272 {
1273         struct bfa_itnim_s *itnim = itnim_arg;
1274
1275         itnim->iotov_active = BFA_FALSE;
1276
1277         bfa_cb_itnim_tov_begin(itnim->ditn);
1278         bfa_itnim_iotov_cleanup(itnim);
1279         bfa_cb_itnim_tov(itnim->ditn);
1280 }
1281
1282 /*
1283  * Start IO TOV timer for failing back pending IO requests in offline state.
1284  */
1285 static void
1286 bfa_itnim_iotov_start(struct bfa_itnim_s *itnim)
1287 {
1288         if (itnim->fcpim->path_tov > 0) {
1289
1290                 itnim->iotov_active = BFA_TRUE;
1291                 WARN_ON(!bfa_itnim_hold_io(itnim));
1292                 bfa_timer_start(itnim->bfa, &itnim->timer,
1293                         bfa_itnim_iotov, itnim, itnim->fcpim->path_tov);
1294         }
1295 }
1296
1297 /*
1298  * Stop IO TOV timer.
1299  */
1300 static void
1301 bfa_itnim_iotov_stop(struct bfa_itnim_s *itnim)
1302 {
1303         if (itnim->iotov_active) {
1304                 itnim->iotov_active = BFA_FALSE;
1305                 bfa_timer_stop(&itnim->timer);
1306         }
1307 }
1308
1309 /*
1310  * Stop IO TOV timer.
1311  */
1312 static void
1313 bfa_itnim_iotov_delete(struct bfa_itnim_s *itnim)
1314 {
1315         bfa_boolean_t pathtov_active = BFA_FALSE;
1316
1317         if (itnim->iotov_active)
1318                 pathtov_active = BFA_TRUE;
1319
1320         bfa_itnim_iotov_stop(itnim);
1321         if (pathtov_active)
1322                 bfa_cb_itnim_tov_begin(itnim->ditn);
1323         bfa_itnim_iotov_cleanup(itnim);
1324         if (pathtov_active)
1325                 bfa_cb_itnim_tov(itnim->ditn);
1326 }
1327
1328 static void
1329 bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim)
1330 {
1331         struct bfa_fcpim_s *fcpim = BFA_FCPIM(itnim->bfa);
1332         fcpim->del_itn_stats.del_itn_iocomp_aborted +=
1333                 itnim->stats.iocomp_aborted;
1334         fcpim->del_itn_stats.del_itn_iocomp_timedout +=
1335                 itnim->stats.iocomp_timedout;
1336         fcpim->del_itn_stats.del_itn_iocom_sqer_needed +=
1337                 itnim->stats.iocom_sqer_needed;
1338         fcpim->del_itn_stats.del_itn_iocom_res_free +=
1339                 itnim->stats.iocom_res_free;
1340         fcpim->del_itn_stats.del_itn_iocom_hostabrts +=
1341                 itnim->stats.iocom_hostabrts;
1342         fcpim->del_itn_stats.del_itn_total_ios += itnim->stats.total_ios;
1343         fcpim->del_itn_stats.del_io_iocdowns += itnim->stats.io_iocdowns;
1344         fcpim->del_itn_stats.del_tm_iocdowns += itnim->stats.tm_iocdowns;
1345 }
1346
1347 /*
1348  * bfa_itnim_public
1349  */
1350
1351 /*
1352  * Itnim interrupt processing.
1353  */
1354 void
1355 bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1356 {
1357         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
1358         union bfi_itn_i2h_msg_u msg;
1359         struct bfa_itnim_s *itnim;
1360
1361         bfa_trc(bfa, m->mhdr.msg_id);
1362
1363         msg.msg = m;
1364
1365         switch (m->mhdr.msg_id) {
1366         case BFI_ITN_I2H_CREATE_RSP:
1367                 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1368                                                 msg.create_rsp->bfa_handle);
1369                 WARN_ON(msg.create_rsp->status != BFA_STATUS_OK);
1370                 bfa_stats(itnim, create_comps);
1371                 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1372                 break;
1373
1374         case BFI_ITN_I2H_DELETE_RSP:
1375                 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1376                                                 msg.delete_rsp->bfa_handle);
1377                 WARN_ON(msg.delete_rsp->status != BFA_STATUS_OK);
1378                 bfa_stats(itnim, delete_comps);
1379                 bfa_sm_send_event(itnim, BFA_ITNIM_SM_FWRSP);
1380                 break;
1381
1382         case BFI_ITN_I2H_SLER_EVENT:
1383                 itnim = BFA_ITNIM_FROM_TAG(fcpim,
1384                                                 msg.sler_event->bfa_handle);
1385                 bfa_stats(itnim, sler_events);
1386                 bfa_sm_send_event(itnim, BFA_ITNIM_SM_SLER);
1387                 break;
1388
1389         default:
1390                 bfa_trc(bfa, m->mhdr.msg_id);
1391                 WARN_ON(1);
1392         }
1393 }
1394
1395 /*
1396  * bfa_itnim_api
1397  */
1398
1399 struct bfa_itnim_s *
1400 bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
1401 {
1402         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
1403         struct bfa_itnim_s *itnim;
1404
1405         bfa_itn_create(bfa, rport, bfa_itnim_isr);
1406
1407         itnim = BFA_ITNIM_FROM_TAG(fcpim, rport->rport_tag);
1408         WARN_ON(itnim->rport != rport);
1409
1410         itnim->ditn = ditn;
1411
1412         bfa_stats(itnim, creates);
1413         bfa_sm_send_event(itnim, BFA_ITNIM_SM_CREATE);
1414
1415         return itnim;
1416 }
1417
1418 void
1419 bfa_itnim_delete(struct bfa_itnim_s *itnim)
1420 {
1421         bfa_stats(itnim, deletes);
1422         bfa_sm_send_event(itnim, BFA_ITNIM_SM_DELETE);
1423 }
1424
1425 void
1426 bfa_itnim_online(struct bfa_itnim_s *itnim, bfa_boolean_t seq_rec)
1427 {
1428         itnim->seq_rec = seq_rec;
1429         bfa_stats(itnim, onlines);
1430         bfa_sm_send_event(itnim, BFA_ITNIM_SM_ONLINE);
1431 }
1432
1433 void
1434 bfa_itnim_offline(struct bfa_itnim_s *itnim)
1435 {
1436         bfa_stats(itnim, offlines);
1437         bfa_sm_send_event(itnim, BFA_ITNIM_SM_OFFLINE);
1438 }
1439
1440 /*
1441  * Return true if itnim is considered offline for holding off IO request.
1442  * IO is not held if itnim is being deleted.
1443  */
1444 bfa_boolean_t
1445 bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
1446 {
1447         return itnim->fcpim->path_tov && itnim->iotov_active &&
1448                 (bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwcreate) ||
1449                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_sler) ||
1450                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_cleanup_offline) ||
1451                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwdelete) ||
1452                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_offline) ||
1453                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable));
1454 }
1455
1456 #define bfa_io_lat_clock_res_div        HZ
1457 #define bfa_io_lat_clock_res_mul        1000
1458 bfa_status_t
1459 bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,
1460                         struct bfa_itnim_ioprofile_s *ioprofile)
1461 {
1462         struct bfa_fcpim_s *fcpim;
1463
1464         if (!itnim)
1465                 return BFA_STATUS_NO_FCPIM_NEXUS;
1466
1467         fcpim = BFA_FCPIM(itnim->bfa);
1468
1469         if (!fcpim->io_profile)
1470                 return BFA_STATUS_IOPROFILE_OFF;
1471
1472         itnim->ioprofile.index = BFA_IOBUCKET_MAX;
1473         /* unsigned 32-bit time_t overflow here in y2106 */
1474         itnim->ioprofile.io_profile_start_time =
1475                                 bfa_io_profile_start_time(itnim->bfa);
1476         itnim->ioprofile.clock_res_mul = bfa_io_lat_clock_res_mul;
1477         itnim->ioprofile.clock_res_div = bfa_io_lat_clock_res_div;
1478         *ioprofile = itnim->ioprofile;
1479
1480         return BFA_STATUS_OK;
1481 }
1482
1483 void
1484 bfa_itnim_clear_stats(struct bfa_itnim_s *itnim)
1485 {
1486         int j;
1487
1488         if (!itnim)
1489                 return;
1490
1491         memset(&itnim->stats, 0, sizeof(itnim->stats));
1492         memset(&itnim->ioprofile, 0, sizeof(itnim->ioprofile));
1493         for (j = 0; j < BFA_IOBUCKET_MAX; j++)
1494                 itnim->ioprofile.io_latency.min[j] = ~0;
1495 }
1496
1497 /*
1498  *  BFA IO module state machine functions
1499  */
1500
1501 /*
1502  * IO is not started (unallocated).
1503  */
1504 static void
1505 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1506 {
1507         switch (event) {
1508         case BFA_IOIM_SM_START:
1509                 if (!bfa_itnim_is_online(ioim->itnim)) {
1510                         if (!bfa_itnim_hold_io(ioim->itnim)) {
1511                                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1512                                 list_del(&ioim->qe);
1513                                 list_add_tail(&ioim->qe,
1514                                         &ioim->fcpim->ioim_comp_q);
1515                                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1516                                                 __bfa_cb_ioim_pathtov, ioim);
1517                         } else {
1518                                 list_del(&ioim->qe);
1519                                 list_add_tail(&ioim->qe,
1520                                         &ioim->itnim->pending_q);
1521                         }
1522                         break;
1523                 }
1524
1525                 if (ioim->nsges > BFI_SGE_INLINE) {
1526                         if (!bfa_ioim_sgpg_alloc(ioim)) {
1527                                 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
1528                                 return;
1529                         }
1530                 }
1531
1532                 if (!bfa_ioim_send_ioreq(ioim)) {
1533                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1534                         break;
1535                 }
1536
1537                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1538                 break;
1539
1540         case BFA_IOIM_SM_IOTOV:
1541                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1542                 bfa_ioim_move_to_comp_q(ioim);
1543                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1544                                 __bfa_cb_ioim_pathtov, ioim);
1545                 break;
1546
1547         case BFA_IOIM_SM_ABORT:
1548                 /*
1549                  * IO in pending queue can get abort requests. Complete abort
1550                  * requests immediately.
1551                  */
1552                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1553                 WARN_ON(!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
1554                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1555                         __bfa_cb_ioim_abort, ioim);
1556                 break;
1557
1558         default:
1559                 bfa_sm_fault(ioim->bfa, event);
1560         }
1561 }
1562
1563 /*
1564  * IO is waiting for SG pages.
1565  */
1566 static void
1567 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1568 {
1569         bfa_trc(ioim->bfa, ioim->iotag);
1570         bfa_trc(ioim->bfa, event);
1571
1572         switch (event) {
1573         case BFA_IOIM_SM_SGALLOCED:
1574                 if (!bfa_ioim_send_ioreq(ioim)) {
1575                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1576                         break;
1577                 }
1578                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1579                 break;
1580
1581         case BFA_IOIM_SM_CLEANUP:
1582                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1583                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1584                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1585                               ioim);
1586                 bfa_ioim_notify_cleanup(ioim);
1587                 break;
1588
1589         case BFA_IOIM_SM_ABORT:
1590                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1591                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1592                 bfa_ioim_move_to_comp_q(ioim);
1593                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1594                               ioim);
1595                 break;
1596
1597         case BFA_IOIM_SM_HWFAIL:
1598                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1599                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
1600                 bfa_ioim_move_to_comp_q(ioim);
1601                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1602                               ioim);
1603                 break;
1604
1605         default:
1606                 bfa_sm_fault(ioim->bfa, event);
1607         }
1608 }
1609
1610 /*
1611  * IO is active.
1612  */
1613 static void
1614 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1615 {
1616         switch (event) {
1617         case BFA_IOIM_SM_COMP_GOOD:
1618                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1619                 bfa_ioim_move_to_comp_q(ioim);
1620                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1621                               __bfa_cb_ioim_good_comp, ioim);
1622                 break;
1623
1624         case BFA_IOIM_SM_COMP:
1625                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1626                 bfa_ioim_move_to_comp_q(ioim);
1627                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1628                               ioim);
1629                 break;
1630
1631         case BFA_IOIM_SM_DONE:
1632                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1633                 bfa_ioim_move_to_comp_q(ioim);
1634                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
1635                               ioim);
1636                 break;
1637
1638         case BFA_IOIM_SM_ABORT:
1639                 ioim->iosp->abort_explicit = BFA_TRUE;
1640                 ioim->io_cbfn = __bfa_cb_ioim_abort;
1641
1642                 if (bfa_ioim_send_abort(ioim))
1643                         bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1644                 else {
1645                         bfa_sm_set_state(ioim, bfa_ioim_sm_abort_qfull);
1646                         bfa_stats(ioim->itnim, qwait);
1647                         bfa_reqq_wait(ioim->bfa, ioim->reqq,
1648                                           &ioim->iosp->reqq_wait);
1649                 }
1650                 break;
1651
1652         case BFA_IOIM_SM_CLEANUP:
1653                 ioim->iosp->abort_explicit = BFA_FALSE;
1654                 ioim->io_cbfn = __bfa_cb_ioim_failed;
1655
1656                 if (bfa_ioim_send_abort(ioim))
1657                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1658                 else {
1659                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1660                         bfa_stats(ioim->itnim, qwait);
1661                         bfa_reqq_wait(ioim->bfa, ioim->reqq,
1662                                           &ioim->iosp->reqq_wait);
1663                 }
1664                 break;
1665
1666         case BFA_IOIM_SM_HWFAIL:
1667                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1668                 bfa_ioim_move_to_comp_q(ioim);
1669                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1670                               ioim);
1671                 break;
1672
1673         case BFA_IOIM_SM_SQRETRY:
1674                 if (bfa_ioim_maxretry_reached(ioim)) {
1675                         /* max retry reached, free IO */
1676                         bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1677                         bfa_ioim_move_to_comp_q(ioim);
1678                         bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1679                                         __bfa_cb_ioim_failed, ioim);
1680                         break;
1681                 }
1682                 /* waiting for IO tag resource free */
1683                 bfa_sm_set_state(ioim, bfa_ioim_sm_cmnd_retry);
1684                 break;
1685
1686         default:
1687                 bfa_sm_fault(ioim->bfa, event);
1688         }
1689 }
1690
1691 /*
1692  * IO is retried with new tag.
1693  */
1694 static void
1695 bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1696 {
1697         switch (event) {
1698         case BFA_IOIM_SM_FREE:
1699                 /* abts and rrq done. Now retry the IO with new tag */
1700                 bfa_ioim_update_iotag(ioim);
1701                 if (!bfa_ioim_send_ioreq(ioim)) {
1702                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
1703                         break;
1704                 }
1705                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1706         break;
1707
1708         case BFA_IOIM_SM_CLEANUP:
1709                 ioim->iosp->abort_explicit = BFA_FALSE;
1710                 ioim->io_cbfn = __bfa_cb_ioim_failed;
1711
1712                 if (bfa_ioim_send_abort(ioim))
1713                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1714                 else {
1715                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1716                         bfa_stats(ioim->itnim, qwait);
1717                         bfa_reqq_wait(ioim->bfa, ioim->reqq,
1718                                           &ioim->iosp->reqq_wait);
1719                 }
1720         break;
1721
1722         case BFA_IOIM_SM_HWFAIL:
1723                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1724                 bfa_ioim_move_to_comp_q(ioim);
1725                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
1726                          __bfa_cb_ioim_failed, ioim);
1727                 break;
1728
1729         case BFA_IOIM_SM_ABORT:
1730                 /* in this state IO abort is done.
1731                  * Waiting for IO tag resource free.
1732                  */
1733                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1734                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1735                               ioim);
1736                 break;
1737
1738         default:
1739                 bfa_sm_fault(ioim->bfa, event);
1740         }
1741 }
1742
1743 /*
1744  * IO is being aborted, waiting for completion from firmware.
1745  */
1746 static void
1747 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1748 {
1749         bfa_trc(ioim->bfa, ioim->iotag);
1750         bfa_trc(ioim->bfa, event);
1751
1752         switch (event) {
1753         case BFA_IOIM_SM_COMP_GOOD:
1754         case BFA_IOIM_SM_COMP:
1755         case BFA_IOIM_SM_DONE:
1756         case BFA_IOIM_SM_FREE:
1757                 break;
1758
1759         case BFA_IOIM_SM_ABORT_DONE:
1760                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1761                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1762                               ioim);
1763                 break;
1764
1765         case BFA_IOIM_SM_ABORT_COMP:
1766                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1767                 bfa_ioim_move_to_comp_q(ioim);
1768                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1769                               ioim);
1770                 break;
1771
1772         case BFA_IOIM_SM_COMP_UTAG:
1773                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1774                 bfa_ioim_move_to_comp_q(ioim);
1775                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1776                               ioim);
1777                 break;
1778
1779         case BFA_IOIM_SM_CLEANUP:
1780                 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1781                 ioim->iosp->abort_explicit = BFA_FALSE;
1782
1783                 if (bfa_ioim_send_abort(ioim))
1784                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1785                 else {
1786                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1787                         bfa_stats(ioim->itnim, qwait);
1788                         bfa_reqq_wait(ioim->bfa, ioim->reqq,
1789                                           &ioim->iosp->reqq_wait);
1790                 }
1791                 break;
1792
1793         case BFA_IOIM_SM_HWFAIL:
1794                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1795                 bfa_ioim_move_to_comp_q(ioim);
1796                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1797                               ioim);
1798                 break;
1799
1800         default:
1801                 bfa_sm_fault(ioim->bfa, event);
1802         }
1803 }
1804
1805 /*
1806  * IO is being cleaned up (implicit abort), waiting for completion from
1807  * firmware.
1808  */
1809 static void
1810 bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1811 {
1812         bfa_trc(ioim->bfa, ioim->iotag);
1813         bfa_trc(ioim->bfa, event);
1814
1815         switch (event) {
1816         case BFA_IOIM_SM_COMP_GOOD:
1817         case BFA_IOIM_SM_COMP:
1818         case BFA_IOIM_SM_DONE:
1819         case BFA_IOIM_SM_FREE:
1820                 break;
1821
1822         case BFA_IOIM_SM_ABORT:
1823                 /*
1824                  * IO is already being aborted implicitly
1825                  */
1826                 ioim->io_cbfn = __bfa_cb_ioim_abort;
1827                 break;
1828
1829         case BFA_IOIM_SM_ABORT_DONE:
1830                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1831                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1832                 bfa_ioim_notify_cleanup(ioim);
1833                 break;
1834
1835         case BFA_IOIM_SM_ABORT_COMP:
1836                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1837                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1838                 bfa_ioim_notify_cleanup(ioim);
1839                 break;
1840
1841         case BFA_IOIM_SM_COMP_UTAG:
1842                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1843                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1844                 bfa_ioim_notify_cleanup(ioim);
1845                 break;
1846
1847         case BFA_IOIM_SM_HWFAIL:
1848                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1849                 bfa_ioim_move_to_comp_q(ioim);
1850                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1851                               ioim);
1852                 break;
1853
1854         case BFA_IOIM_SM_CLEANUP:
1855                 /*
1856                  * IO can be in cleanup state already due to TM command.
1857                  * 2nd cleanup request comes from ITN offline event.
1858                  */
1859                 break;
1860
1861         default:
1862                 bfa_sm_fault(ioim->bfa, event);
1863         }
1864 }
1865
1866 /*
1867  * IO is waiting for room in request CQ
1868  */
1869 static void
1870 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1871 {
1872         bfa_trc(ioim->bfa, ioim->iotag);
1873         bfa_trc(ioim->bfa, event);
1874
1875         switch (event) {
1876         case BFA_IOIM_SM_QRESUME:
1877                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
1878                 bfa_ioim_send_ioreq(ioim);
1879                 break;
1880
1881         case BFA_IOIM_SM_ABORT:
1882                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1883                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1884                 bfa_ioim_move_to_comp_q(ioim);
1885                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1886                               ioim);
1887                 break;
1888
1889         case BFA_IOIM_SM_CLEANUP:
1890                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1891                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1892                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1893                               ioim);
1894                 bfa_ioim_notify_cleanup(ioim);
1895                 break;
1896
1897         case BFA_IOIM_SM_HWFAIL:
1898                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1899                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1900                 bfa_ioim_move_to_comp_q(ioim);
1901                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1902                               ioim);
1903                 break;
1904
1905         default:
1906                 bfa_sm_fault(ioim->bfa, event);
1907         }
1908 }
1909
1910 /*
1911  * Active IO is being aborted, waiting for room in request CQ.
1912  */
1913 static void
1914 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1915 {
1916         bfa_trc(ioim->bfa, ioim->iotag);
1917         bfa_trc(ioim->bfa, event);
1918
1919         switch (event) {
1920         case BFA_IOIM_SM_QRESUME:
1921                 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
1922                 bfa_ioim_send_abort(ioim);
1923                 break;
1924
1925         case BFA_IOIM_SM_CLEANUP:
1926                 WARN_ON(ioim->iosp->abort_explicit != BFA_TRUE);
1927                 ioim->iosp->abort_explicit = BFA_FALSE;
1928                 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
1929                 break;
1930
1931         case BFA_IOIM_SM_COMP_GOOD:
1932         case BFA_IOIM_SM_COMP:
1933                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1934                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1935                 bfa_ioim_move_to_comp_q(ioim);
1936                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1937                               ioim);
1938                 break;
1939
1940         case BFA_IOIM_SM_DONE:
1941                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1942                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1943                 bfa_ioim_move_to_comp_q(ioim);
1944                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
1945                               ioim);
1946                 break;
1947
1948         case BFA_IOIM_SM_HWFAIL:
1949                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1950                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1951                 bfa_ioim_move_to_comp_q(ioim);
1952                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
1953                               ioim);
1954                 break;
1955
1956         default:
1957                 bfa_sm_fault(ioim->bfa, event);
1958         }
1959 }
1960
1961 /*
1962  * Active IO is being cleaned up, waiting for room in request CQ.
1963  */
1964 static void
1965 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
1966 {
1967         bfa_trc(ioim->bfa, ioim->iotag);
1968         bfa_trc(ioim->bfa, event);
1969
1970         switch (event) {
1971         case BFA_IOIM_SM_QRESUME:
1972                 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
1973                 bfa_ioim_send_abort(ioim);
1974                 break;
1975
1976         case BFA_IOIM_SM_ABORT:
1977                 /*
1978                  * IO is already being cleaned up implicitly
1979                  */
1980                 ioim->io_cbfn = __bfa_cb_ioim_abort;
1981                 break;
1982
1983         case BFA_IOIM_SM_COMP_GOOD:
1984         case BFA_IOIM_SM_COMP:
1985                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
1986                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1987                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1988                 bfa_ioim_notify_cleanup(ioim);
1989                 break;
1990
1991         case BFA_IOIM_SM_DONE:
1992                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
1993                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
1994                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1995                 bfa_ioim_notify_cleanup(ioim);
1996                 break;
1997
1998         case BFA_IOIM_SM_HWFAIL:
1999                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2000                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
2001                 bfa_ioim_move_to_comp_q(ioim);
2002                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
2003                               ioim);
2004                 break;
2005
2006         default:
2007                 bfa_sm_fault(ioim->bfa, event);
2008         }
2009 }
2010
2011 /*
2012  * IO bfa callback is pending.
2013  */
2014 static void
2015 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2016 {
2017         switch (event) {
2018         case BFA_IOIM_SM_HCB:
2019                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2020                 bfa_ioim_free(ioim);
2021                 break;
2022
2023         case BFA_IOIM_SM_CLEANUP:
2024                 bfa_ioim_notify_cleanup(ioim);
2025                 break;
2026
2027         case BFA_IOIM_SM_HWFAIL:
2028                 break;
2029
2030         default:
2031                 bfa_sm_fault(ioim->bfa, event);
2032         }
2033 }
2034
2035 /*
2036  * IO bfa callback is pending. IO resource cannot be freed.
2037  */
2038 static void
2039 bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2040 {
2041         bfa_trc(ioim->bfa, ioim->iotag);
2042         bfa_trc(ioim->bfa, event);
2043
2044         switch (event) {
2045         case BFA_IOIM_SM_HCB:
2046                 bfa_sm_set_state(ioim, bfa_ioim_sm_resfree);
2047                 list_del(&ioim->qe);
2048                 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_resfree_q);
2049                 break;
2050
2051         case BFA_IOIM_SM_FREE:
2052                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2053                 break;
2054
2055         case BFA_IOIM_SM_CLEANUP:
2056                 bfa_ioim_notify_cleanup(ioim);
2057                 break;
2058
2059         case BFA_IOIM_SM_HWFAIL:
2060                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
2061                 break;
2062
2063         default:
2064                 bfa_sm_fault(ioim->bfa, event);
2065         }
2066 }
2067
2068 /*
2069  * IO is completed, waiting resource free from firmware.
2070  */
2071 static void
2072 bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
2073 {
2074         bfa_trc(ioim->bfa, ioim->iotag);
2075         bfa_trc(ioim->bfa, event);
2076
2077         switch (event) {
2078         case BFA_IOIM_SM_FREE:
2079                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2080                 bfa_ioim_free(ioim);
2081                 break;
2082
2083         case BFA_IOIM_SM_CLEANUP:
2084                 bfa_ioim_notify_cleanup(ioim);
2085                 break;
2086
2087         case BFA_IOIM_SM_HWFAIL:
2088                 break;
2089
2090         default:
2091                 bfa_sm_fault(ioim->bfa, event);
2092         }
2093 }
2094
2095 /*
2096  * This is called from bfa_fcpim_start after the bfa_init() with flash read
2097  * is complete by driver. now invalidate the stale content of lun mask
2098  * like unit attention, rp tag and lp tag.
2099  */
2100 void
2101 bfa_ioim_lm_init(struct bfa_s *bfa)
2102 {
2103         struct bfa_lun_mask_s *lunm_list;
2104         int     i;
2105
2106         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2107                 return;
2108
2109         lunm_list = bfa_get_lun_mask_list(bfa);
2110         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2111                 lunm_list[i].ua = BFA_IOIM_LM_UA_RESET;
2112                 lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
2113                 lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
2114         }
2115 }
2116
2117 static void
2118 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
2119 {
2120         struct bfa_ioim_s *ioim = cbarg;
2121
2122         if (!complete) {
2123                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2124                 return;
2125         }
2126
2127         bfa_cb_ioim_good_comp(ioim->bfa->bfad, ioim->dio);
2128 }
2129
2130 static void
2131 __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
2132 {
2133         struct bfa_ioim_s       *ioim = cbarg;
2134         struct bfi_ioim_rsp_s *m;
2135         u8      *snsinfo = NULL;
2136         u8      sns_len = 0;
2137         s32     residue = 0;
2138
2139         if (!complete) {
2140                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2141                 return;
2142         }
2143
2144         m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
2145         if (m->io_status == BFI_IOIM_STS_OK) {
2146                 /*
2147                  * setup sense information, if present
2148                  */
2149                 if ((m->scsi_status == SAM_STAT_CHECK_CONDITION) &&
2150                                         m->sns_len) {
2151                         sns_len = m->sns_len;
2152                         snsinfo = BFA_SNSINFO_FROM_TAG(ioim->fcpim->fcp,
2153                                                 ioim->iotag);
2154                 }
2155
2156                 /*
2157                  * setup residue value correctly for normal completions
2158                  */
2159                 if (m->resid_flags == FCP_RESID_UNDER) {
2160                         residue = be32_to_cpu(m->residue);
2161                         bfa_stats(ioim->itnim, iocomp_underrun);
2162                 }
2163                 if (m->resid_flags == FCP_RESID_OVER) {
2164                         residue = be32_to_cpu(m->residue);
2165                         residue = -residue;
2166                         bfa_stats(ioim->itnim, iocomp_overrun);
2167                 }
2168         }
2169
2170         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, m->io_status,
2171                           m->scsi_status, sns_len, snsinfo, residue);
2172 }
2173
2174 void
2175 bfa_fcpim_lunmask_rp_update(struct bfa_s *bfa, wwn_t lp_wwn, wwn_t rp_wwn,
2176                         u16 rp_tag, u8 lp_tag)
2177 {
2178         struct bfa_lun_mask_s *lun_list;
2179         u8      i;
2180
2181         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2182                 return;
2183
2184         lun_list = bfa_get_lun_mask_list(bfa);
2185         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2186                 if (lun_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
2187                         if ((lun_list[i].lp_wwn == lp_wwn) &&
2188                             (lun_list[i].rp_wwn == rp_wwn)) {
2189                                 lun_list[i].rp_tag = rp_tag;
2190                                 lun_list[i].lp_tag = lp_tag;
2191                         }
2192                 }
2193         }
2194 }
2195
2196 /*
2197  * set UA for all active luns in LM DB
2198  */
2199 static void
2200 bfa_ioim_lm_set_ua(struct bfa_s *bfa)
2201 {
2202         struct bfa_lun_mask_s   *lunm_list;
2203         int     i;
2204
2205         lunm_list = bfa_get_lun_mask_list(bfa);
2206         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2207                 if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2208                         continue;
2209                 lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2210         }
2211 }
2212
2213 bfa_status_t
2214 bfa_fcpim_lunmask_update(struct bfa_s *bfa, u32 update)
2215 {
2216         struct bfa_lunmask_cfg_s        *lun_mask;
2217
2218         bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2219         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2220                 return BFA_STATUS_FAILED;
2221
2222         if (bfa_get_lun_mask_status(bfa) == update)
2223                 return BFA_STATUS_NO_CHANGE;
2224
2225         lun_mask = bfa_get_lun_mask(bfa);
2226         lun_mask->status = update;
2227
2228         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_ENABLED)
2229                 bfa_ioim_lm_set_ua(bfa);
2230
2231         return  bfa_dconf_update(bfa);
2232 }
2233
2234 bfa_status_t
2235 bfa_fcpim_lunmask_clear(struct bfa_s *bfa)
2236 {
2237         int i;
2238         struct bfa_lun_mask_s   *lunm_list;
2239
2240         bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2241         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2242                 return BFA_STATUS_FAILED;
2243
2244         lunm_list = bfa_get_lun_mask_list(bfa);
2245         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2246                 if (lunm_list[i].state == BFA_IOIM_LUN_MASK_ACTIVE) {
2247                         if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID)
2248                                 bfa_rport_unset_lunmask(bfa,
2249                                   BFA_RPORT_FROM_TAG(bfa, lunm_list[i].rp_tag));
2250                 }
2251         }
2252
2253         memset(lunm_list, 0, sizeof(struct bfa_lun_mask_s) * MAX_LUN_MASK_CFG);
2254         return bfa_dconf_update(bfa);
2255 }
2256
2257 bfa_status_t
2258 bfa_fcpim_lunmask_query(struct bfa_s *bfa, void *buf)
2259 {
2260         struct bfa_lunmask_cfg_s *lun_mask;
2261
2262         bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2263         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2264                 return BFA_STATUS_FAILED;
2265
2266         lun_mask = bfa_get_lun_mask(bfa);
2267         memcpy(buf, lun_mask, sizeof(struct bfa_lunmask_cfg_s));
2268         return BFA_STATUS_OK;
2269 }
2270
2271 bfa_status_t
2272 bfa_fcpim_lunmask_add(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2273                       wwn_t rpwwn, struct scsi_lun lun)
2274 {
2275         struct bfa_lun_mask_s *lunm_list;
2276         struct bfa_rport_s *rp = NULL;
2277         int i, free_index = MAX_LUN_MASK_CFG + 1;
2278         struct bfa_fcs_lport_s *port = NULL;
2279         struct bfa_fcs_rport_s *rp_fcs;
2280
2281         bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2282         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2283                 return BFA_STATUS_FAILED;
2284
2285         port = bfa_fcs_lookup_port(&((struct bfad_s *)bfa->bfad)->bfa_fcs,
2286                                    vf_id, *pwwn);
2287         if (port) {
2288                 *pwwn = port->port_cfg.pwwn;
2289                 rp_fcs = bfa_fcs_lport_get_rport_by_pwwn(port, rpwwn);
2290                 if (rp_fcs)
2291                         rp = rp_fcs->bfa_rport;
2292         }
2293
2294         lunm_list = bfa_get_lun_mask_list(bfa);
2295         /* if entry exists */
2296         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2297                 if (lunm_list[i].state != BFA_IOIM_LUN_MASK_ACTIVE)
2298                         free_index = i;
2299                 if ((lunm_list[i].lp_wwn == *pwwn) &&
2300                     (lunm_list[i].rp_wwn == rpwwn) &&
2301                     (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
2302                      scsilun_to_int((struct scsi_lun *)&lun)))
2303                         return  BFA_STATUS_ENTRY_EXISTS;
2304         }
2305
2306         if (free_index > MAX_LUN_MASK_CFG)
2307                 return BFA_STATUS_MAX_ENTRY_REACHED;
2308
2309         if (rp) {
2310                 lunm_list[free_index].lp_tag = bfa_lps_get_tag_from_pid(bfa,
2311                                                    rp->rport_info.local_pid);
2312                 lunm_list[free_index].rp_tag = rp->rport_tag;
2313         } else {
2314                 lunm_list[free_index].lp_tag = BFA_LP_TAG_INVALID;
2315                 lunm_list[free_index].rp_tag = BFA_RPORT_TAG_INVALID;
2316         }
2317
2318         lunm_list[free_index].lp_wwn = *pwwn;
2319         lunm_list[free_index].rp_wwn = rpwwn;
2320         lunm_list[free_index].lun = lun;
2321         lunm_list[free_index].state = BFA_IOIM_LUN_MASK_ACTIVE;
2322
2323         /* set for all luns in this rp */
2324         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2325                 if ((lunm_list[i].lp_wwn == *pwwn) &&
2326                     (lunm_list[i].rp_wwn == rpwwn))
2327                         lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2328         }
2329
2330         return bfa_dconf_update(bfa);
2331 }
2332
2333 bfa_status_t
2334 bfa_fcpim_lunmask_delete(struct bfa_s *bfa, u16 vf_id, wwn_t *pwwn,
2335                          wwn_t rpwwn, struct scsi_lun lun)
2336 {
2337         struct bfa_lun_mask_s   *lunm_list;
2338         struct bfa_fcs_lport_s *port = NULL;
2339         int     i;
2340
2341         /* in min cfg lunm_list could be NULL but  no commands should run. */
2342         if (bfa_get_lun_mask_status(bfa) == BFA_LUNMASK_MINCFG)
2343                 return BFA_STATUS_FAILED;
2344
2345         bfa_trc(bfa, bfa_get_lun_mask_status(bfa));
2346         bfa_trc(bfa, *pwwn);
2347         bfa_trc(bfa, rpwwn);
2348         bfa_trc(bfa, scsilun_to_int((struct scsi_lun *)&lun));
2349
2350         if (*pwwn == 0) {
2351                 port = bfa_fcs_lookup_port(
2352                                 &((struct bfad_s *)bfa->bfad)->bfa_fcs,
2353                                 vf_id, *pwwn);
2354                 if (port)
2355                         *pwwn = port->port_cfg.pwwn;
2356         }
2357
2358         lunm_list = bfa_get_lun_mask_list(bfa);
2359         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2360                 if ((lunm_list[i].lp_wwn == *pwwn) &&
2361                     (lunm_list[i].rp_wwn == rpwwn) &&
2362                     (scsilun_to_int((struct scsi_lun *)&lunm_list[i].lun) ==
2363                      scsilun_to_int((struct scsi_lun *)&lun))) {
2364                         lunm_list[i].lp_wwn = 0;
2365                         lunm_list[i].rp_wwn = 0;
2366                         int_to_scsilun(0, &lunm_list[i].lun);
2367                         lunm_list[i].state = BFA_IOIM_LUN_MASK_INACTIVE;
2368                         if (lunm_list[i].rp_tag != BFA_RPORT_TAG_INVALID) {
2369                                 lunm_list[i].rp_tag = BFA_RPORT_TAG_INVALID;
2370                                 lunm_list[i].lp_tag = BFA_LP_TAG_INVALID;
2371                         }
2372                         return bfa_dconf_update(bfa);
2373                 }
2374         }
2375
2376         /* set for all luns in this rp */
2377         for (i = 0; i < MAX_LUN_MASK_CFG; i++) {
2378                 if ((lunm_list[i].lp_wwn == *pwwn) &&
2379                     (lunm_list[i].rp_wwn == rpwwn))
2380                         lunm_list[i].ua = BFA_IOIM_LM_UA_SET;
2381         }
2382
2383         return BFA_STATUS_ENTRY_NOT_EXISTS;
2384 }
2385
2386 static void
2387 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
2388 {
2389         struct bfa_ioim_s *ioim = cbarg;
2390
2391         if (!complete) {
2392                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2393                 return;
2394         }
2395
2396         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
2397                           0, 0, NULL, 0);
2398 }
2399
2400 static void
2401 __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
2402 {
2403         struct bfa_ioim_s *ioim = cbarg;
2404
2405         bfa_stats(ioim->itnim, path_tov_expired);
2406         if (!complete) {
2407                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2408                 return;
2409         }
2410
2411         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
2412                           0, 0, NULL, 0);
2413 }
2414
2415 static void
2416 __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
2417 {
2418         struct bfa_ioim_s *ioim = cbarg;
2419
2420         if (!complete) {
2421                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
2422                 return;
2423         }
2424
2425         bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
2426 }
2427
2428 static void
2429 bfa_ioim_sgpg_alloced(void *cbarg)
2430 {
2431         struct bfa_ioim_s *ioim = cbarg;
2432
2433         ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2434         list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
2435         ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2436         bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
2437 }
2438
2439 /*
2440  * Send I/O request to firmware.
2441  */
2442 static  bfa_boolean_t
2443 bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
2444 {
2445         struct bfa_itnim_s *itnim = ioim->itnim;
2446         struct bfi_ioim_req_s *m;
2447         static struct fcp_cmnd_s cmnd_z0 = { { { 0 } } };
2448         struct bfi_sge_s *sge, *sgpge;
2449         u32     pgdlen = 0;
2450         u32     fcp_dl;
2451         u64 addr;
2452         struct scatterlist *sg;
2453         struct bfa_sgpg_s *sgpg;
2454         struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
2455         u32 i, sge_id, pgcumsz;
2456         enum dma_data_direction dmadir;
2457
2458         /*
2459          * check for room in queue to send request now
2460          */
2461         m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2462         if (!m) {
2463                 bfa_stats(ioim->itnim, qwait);
2464                 bfa_reqq_wait(ioim->bfa, ioim->reqq,
2465                                   &ioim->iosp->reqq_wait);
2466                 return BFA_FALSE;
2467         }
2468
2469         /*
2470          * build i/o request message next
2471          */
2472         m->io_tag = cpu_to_be16(ioim->iotag);
2473         m->rport_hdl = ioim->itnim->rport->fw_handle;
2474         m->io_timeout = 0;
2475
2476         sge = &m->sges[0];
2477         sgpg = ioim->sgpg;
2478         sge_id = 0;
2479         sgpge = NULL;
2480         pgcumsz = 0;
2481         scsi_for_each_sg(cmnd, sg, ioim->nsges, i) {
2482                 if (i == 0) {
2483                         /* build inline IO SG element */
2484                         addr = bfa_sgaddr_le(sg_dma_address(sg));
2485                         sge->sga = *(union bfi_addr_u *) &addr;
2486                         pgdlen = sg_dma_len(sg);
2487                         sge->sg_len = pgdlen;
2488                         sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
2489                                         BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
2490                         bfa_sge_to_be(sge);
2491                         sge++;
2492                 } else {
2493                         if (sge_id == 0)
2494                                 sgpge = sgpg->sgpg->sges;
2495
2496                         addr = bfa_sgaddr_le(sg_dma_address(sg));
2497                         sgpge->sga = *(union bfi_addr_u *) &addr;
2498                         sgpge->sg_len = sg_dma_len(sg);
2499                         pgcumsz += sgpge->sg_len;
2500
2501                         /* set flags */
2502                         if (i < (ioim->nsges - 1) &&
2503                                         sge_id < (BFI_SGPG_DATA_SGES - 1))
2504                                 sgpge->flags = BFI_SGE_DATA;
2505                         else if (i < (ioim->nsges - 1))
2506                                 sgpge->flags = BFI_SGE_DATA_CPL;
2507                         else
2508                                 sgpge->flags = BFI_SGE_DATA_LAST;
2509
2510                         bfa_sge_to_le(sgpge);
2511
2512                         sgpge++;
2513                         if (i == (ioim->nsges - 1)) {
2514                                 sgpge->flags = BFI_SGE_PGDLEN;
2515                                 sgpge->sga.a32.addr_lo = 0;
2516                                 sgpge->sga.a32.addr_hi = 0;
2517                                 sgpge->sg_len = pgcumsz;
2518                                 bfa_sge_to_le(sgpge);
2519                         } else if (++sge_id == BFI_SGPG_DATA_SGES) {
2520                                 sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
2521                                 sgpge->flags = BFI_SGE_LINK;
2522                                 sgpge->sga = sgpg->sgpg_pa;
2523                                 sgpge->sg_len = pgcumsz;
2524                                 bfa_sge_to_le(sgpge);
2525                                 sge_id = 0;
2526                                 pgcumsz = 0;
2527                         }
2528                 }
2529         }
2530
2531         if (ioim->nsges > BFI_SGE_INLINE) {
2532                 sge->sga = ioim->sgpg->sgpg_pa;
2533         } else {
2534                 sge->sga.a32.addr_lo = 0;
2535                 sge->sga.a32.addr_hi = 0;
2536         }
2537         sge->sg_len = pgdlen;
2538         sge->flags = BFI_SGE_PGDLEN;
2539         bfa_sge_to_be(sge);
2540
2541         /*
2542          * set up I/O command parameters
2543          */
2544         m->cmnd = cmnd_z0;
2545         int_to_scsilun(cmnd->device->lun, &m->cmnd.lun);
2546         dmadir = cmnd->sc_data_direction;
2547         if (dmadir == DMA_TO_DEVICE)
2548                 m->cmnd.iodir = FCP_IODIR_WRITE;
2549         else if (dmadir == DMA_FROM_DEVICE)
2550                 m->cmnd.iodir = FCP_IODIR_READ;
2551         else
2552                 m->cmnd.iodir = FCP_IODIR_NONE;
2553
2554         m->cmnd.cdb = *(struct scsi_cdb_s *) cmnd->cmnd;
2555         fcp_dl = scsi_bufflen(cmnd);
2556         m->cmnd.fcp_dl = cpu_to_be32(fcp_dl);
2557
2558         /*
2559          * set up I/O message header
2560          */
2561         switch (m->cmnd.iodir) {
2562         case FCP_IODIR_READ:
2563                 bfi_h2i_set(m->mh, BFI_MC_IOIM_READ, 0, bfa_fn_lpu(ioim->bfa));
2564                 bfa_stats(itnim, input_reqs);
2565                 ioim->itnim->stats.rd_throughput += fcp_dl;
2566                 break;
2567         case FCP_IODIR_WRITE:
2568                 bfi_h2i_set(m->mh, BFI_MC_IOIM_WRITE, 0, bfa_fn_lpu(ioim->bfa));
2569                 bfa_stats(itnim, output_reqs);
2570                 ioim->itnim->stats.wr_throughput += fcp_dl;
2571                 break;
2572         case FCP_IODIR_RW:
2573                 bfa_stats(itnim, input_reqs);
2574                 bfa_stats(itnim, output_reqs);
2575                 fallthrough;
2576         default:
2577                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_fn_lpu(ioim->bfa));
2578         }
2579         if (itnim->seq_rec ||
2580             (scsi_bufflen(cmnd) & (sizeof(u32) - 1)))
2581                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_fn_lpu(ioim->bfa));
2582
2583         /*
2584          * queue I/O message to firmware
2585          */
2586         bfa_reqq_produce(ioim->bfa, ioim->reqq, m->mh);
2587         return BFA_TRUE;
2588 }
2589
2590 /*
2591  * Setup any additional SG pages needed.Inline SG element is setup
2592  * at queuing time.
2593  */
2594 static bfa_boolean_t
2595 bfa_ioim_sgpg_alloc(struct bfa_ioim_s *ioim)
2596 {
2597         u16     nsgpgs;
2598
2599         WARN_ON(ioim->nsges <= BFI_SGE_INLINE);
2600
2601         /*
2602          * allocate SG pages needed
2603          */
2604         nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
2605         if (!nsgpgs)
2606                 return BFA_TRUE;
2607
2608         if (bfa_sgpg_malloc(ioim->bfa, &ioim->sgpg_q, nsgpgs)
2609             != BFA_STATUS_OK) {
2610                 bfa_sgpg_wait(ioim->bfa, &ioim->iosp->sgpg_wqe, nsgpgs);
2611                 return BFA_FALSE;
2612         }
2613
2614         ioim->nsgpgs = nsgpgs;
2615         ioim->sgpg = bfa_q_first(&ioim->sgpg_q);
2616
2617         return BFA_TRUE;
2618 }
2619
2620 /*
2621  * Send I/O abort request to firmware.
2622  */
2623 static  bfa_boolean_t
2624 bfa_ioim_send_abort(struct bfa_ioim_s *ioim)
2625 {
2626         struct bfi_ioim_abort_req_s *m;
2627         enum bfi_ioim_h2i       msgop;
2628
2629         /*
2630          * check for room in queue to send request now
2631          */
2632         m = bfa_reqq_next(ioim->bfa, ioim->reqq);
2633         if (!m)
2634                 return BFA_FALSE;
2635
2636         /*
2637          * build i/o request message next
2638          */
2639         if (ioim->iosp->abort_explicit)
2640                 msgop = BFI_IOIM_H2I_IOABORT_REQ;
2641         else
2642                 msgop = BFI_IOIM_H2I_IOCLEANUP_REQ;
2643
2644         bfi_h2i_set(m->mh, BFI_MC_IOIM, msgop, bfa_fn_lpu(ioim->bfa));
2645         m->io_tag    = cpu_to_be16(ioim->iotag);
2646         m->abort_tag = ++ioim->abort_tag;
2647
2648         /*
2649          * queue I/O message to firmware
2650          */
2651         bfa_reqq_produce(ioim->bfa, ioim->reqq, m->mh);
2652         return BFA_TRUE;
2653 }
2654
2655 /*
2656  * Call to resume any I/O requests waiting for room in request queue.
2657  */
2658 static void
2659 bfa_ioim_qresume(void *cbarg)
2660 {
2661         struct bfa_ioim_s *ioim = cbarg;
2662
2663         bfa_stats(ioim->itnim, qresumes);
2664         bfa_sm_send_event(ioim, BFA_IOIM_SM_QRESUME);
2665 }
2666
2667
2668 static void
2669 bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
2670 {
2671         /*
2672          * Move IO from itnim queue to fcpim global queue since itnim will be
2673          * freed.
2674          */
2675         list_del(&ioim->qe);
2676         list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
2677
2678         if (!ioim->iosp->tskim) {
2679                 if (ioim->fcpim->delay_comp && ioim->itnim->iotov_active) {
2680                         bfa_cb_dequeue(&ioim->hcb_qe);
2681                         list_del(&ioim->qe);
2682                         list_add_tail(&ioim->qe, &ioim->itnim->delay_comp_q);
2683                 }
2684                 bfa_itnim_iodone(ioim->itnim);
2685         } else
2686                 bfa_wc_down(&ioim->iosp->tskim->wc);
2687 }
2688
2689 static bfa_boolean_t
2690 bfa_ioim_is_abortable(struct bfa_ioim_s *ioim)
2691 {
2692         if ((bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit) &&
2693             (!bfa_q_is_on_q(&ioim->itnim->pending_q, ioim)))    ||
2694             (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort))         ||
2695             (bfa_sm_cmp_state(ioim, bfa_ioim_sm_abort_qfull))   ||
2696             (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb))           ||
2697             (bfa_sm_cmp_state(ioim, bfa_ioim_sm_hcb_free))      ||
2698             (bfa_sm_cmp_state(ioim, bfa_ioim_sm_resfree)))
2699                 return BFA_FALSE;
2700
2701         return BFA_TRUE;
2702 }
2703
2704 void
2705 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
2706 {
2707         /*
2708          * If path tov timer expired, failback with PATHTOV status - these
2709          * IO requests are not normally retried by IO stack.
2710          *
2711          * Otherwise device cameback online and fail it with normal failed
2712          * status so that IO stack retries these failed IO requests.
2713          */
2714         if (iotov)
2715                 ioim->io_cbfn = __bfa_cb_ioim_pathtov;
2716         else {
2717                 ioim->io_cbfn = __bfa_cb_ioim_failed;
2718                 bfa_stats(ioim->itnim, iocom_nexus_abort);
2719         }
2720         bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
2721
2722         /*
2723          * Move IO to fcpim global queue since itnim will be
2724          * freed.
2725          */
2726         list_del(&ioim->qe);
2727         list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
2728 }
2729
2730
2731 /*
2732  * Memory allocation and initialization.
2733  */
2734 void
2735 bfa_ioim_attach(struct bfa_fcpim_s *fcpim)
2736 {
2737         struct bfa_ioim_s               *ioim;
2738         struct bfa_fcp_mod_s    *fcp = fcpim->fcp;
2739         struct bfa_ioim_sp_s    *iosp;
2740         u16             i;
2741
2742         /*
2743          * claim memory first
2744          */
2745         ioim = (struct bfa_ioim_s *) bfa_mem_kva_curp(fcp);
2746         fcpim->ioim_arr = ioim;
2747         bfa_mem_kva_curp(fcp) = (u8 *) (ioim + fcpim->fcp->num_ioim_reqs);
2748
2749         iosp = (struct bfa_ioim_sp_s *) bfa_mem_kva_curp(fcp);
2750         fcpim->ioim_sp_arr = iosp;
2751         bfa_mem_kva_curp(fcp) = (u8 *) (iosp + fcpim->fcp->num_ioim_reqs);
2752
2753         /*
2754          * Initialize ioim free queues
2755          */
2756         INIT_LIST_HEAD(&fcpim->ioim_resfree_q);
2757         INIT_LIST_HEAD(&fcpim->ioim_comp_q);
2758
2759         for (i = 0; i < fcpim->fcp->num_ioim_reqs;
2760              i++, ioim++, iosp++) {
2761                 /*
2762                  * initialize IOIM
2763                  */
2764                 memset(ioim, 0, sizeof(struct bfa_ioim_s));
2765                 ioim->iotag   = i;
2766                 ioim->bfa     = fcpim->bfa;
2767                 ioim->fcpim   = fcpim;
2768                 ioim->iosp    = iosp;
2769                 INIT_LIST_HEAD(&ioim->sgpg_q);
2770                 bfa_reqq_winit(&ioim->iosp->reqq_wait,
2771                                    bfa_ioim_qresume, ioim);
2772                 bfa_sgpg_winit(&ioim->iosp->sgpg_wqe,
2773                                    bfa_ioim_sgpg_alloced, ioim);
2774                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
2775         }
2776 }
2777
2778 void
2779 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2780 {
2781         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
2782         struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
2783         struct bfa_ioim_s *ioim;
2784         u16     iotag;
2785         enum bfa_ioim_event evt = BFA_IOIM_SM_COMP;
2786
2787         iotag = be16_to_cpu(rsp->io_tag);
2788
2789         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
2790         WARN_ON(ioim->iotag != iotag);
2791
2792         bfa_trc(ioim->bfa, ioim->iotag);
2793         bfa_trc(ioim->bfa, rsp->io_status);
2794         bfa_trc(ioim->bfa, rsp->reuse_io_tag);
2795
2796         if (bfa_sm_cmp_state(ioim, bfa_ioim_sm_active))
2797                 ioim->iosp->comp_rspmsg = *m;
2798
2799         switch (rsp->io_status) {
2800         case BFI_IOIM_STS_OK:
2801                 bfa_stats(ioim->itnim, iocomp_ok);
2802                 if (rsp->reuse_io_tag == 0)
2803                         evt = BFA_IOIM_SM_DONE;
2804                 else
2805                         evt = BFA_IOIM_SM_COMP;
2806                 break;
2807
2808         case BFI_IOIM_STS_TIMEDOUT:
2809                 bfa_stats(ioim->itnim, iocomp_timedout);
2810                 fallthrough;
2811         case BFI_IOIM_STS_ABORTED:
2812                 rsp->io_status = BFI_IOIM_STS_ABORTED;
2813                 bfa_stats(ioim->itnim, iocomp_aborted);
2814                 if (rsp->reuse_io_tag == 0)
2815                         evt = BFA_IOIM_SM_DONE;
2816                 else
2817                         evt = BFA_IOIM_SM_COMP;
2818                 break;
2819
2820         case BFI_IOIM_STS_PROTO_ERR:
2821                 bfa_stats(ioim->itnim, iocom_proto_err);
2822                 WARN_ON(!rsp->reuse_io_tag);
2823                 evt = BFA_IOIM_SM_COMP;
2824                 break;
2825
2826         case BFI_IOIM_STS_SQER_NEEDED:
2827                 bfa_stats(ioim->itnim, iocom_sqer_needed);
2828                 WARN_ON(rsp->reuse_io_tag != 0);
2829                 evt = BFA_IOIM_SM_SQRETRY;
2830                 break;
2831
2832         case BFI_IOIM_STS_RES_FREE:
2833                 bfa_stats(ioim->itnim, iocom_res_free);
2834                 evt = BFA_IOIM_SM_FREE;
2835                 break;
2836
2837         case BFI_IOIM_STS_HOST_ABORTED:
2838                 bfa_stats(ioim->itnim, iocom_hostabrts);
2839                 if (rsp->abort_tag != ioim->abort_tag) {
2840                         bfa_trc(ioim->bfa, rsp->abort_tag);
2841                         bfa_trc(ioim->bfa, ioim->abort_tag);
2842                         return;
2843                 }
2844
2845                 if (rsp->reuse_io_tag)
2846                         evt = BFA_IOIM_SM_ABORT_COMP;
2847                 else
2848                         evt = BFA_IOIM_SM_ABORT_DONE;
2849                 break;
2850
2851         case BFI_IOIM_STS_UTAG:
2852                 bfa_stats(ioim->itnim, iocom_utags);
2853                 evt = BFA_IOIM_SM_COMP_UTAG;
2854                 break;
2855
2856         default:
2857                 WARN_ON(1);
2858         }
2859
2860         bfa_sm_send_event(ioim, evt);
2861 }
2862
2863 void
2864 bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
2865 {
2866         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
2867         struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
2868         struct bfa_ioim_s *ioim;
2869         u16     iotag;
2870
2871         iotag = be16_to_cpu(rsp->io_tag);
2872
2873         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
2874         WARN_ON(ioim->iotag != iotag);
2875
2876         bfa_ioim_cb_profile_comp(fcpim, ioim);
2877
2878         bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
2879 }
2880
2881 /*
2882  * Called by itnim to clean up IO while going offline.
2883  */
2884 void
2885 bfa_ioim_cleanup(struct bfa_ioim_s *ioim)
2886 {
2887         bfa_trc(ioim->bfa, ioim->iotag);
2888         bfa_stats(ioim->itnim, io_cleanups);
2889
2890         ioim->iosp->tskim = NULL;
2891         bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
2892 }
2893
2894 void
2895 bfa_ioim_cleanup_tm(struct bfa_ioim_s *ioim, struct bfa_tskim_s *tskim)
2896 {
2897         bfa_trc(ioim->bfa, ioim->iotag);
2898         bfa_stats(ioim->itnim, io_tmaborts);
2899
2900         ioim->iosp->tskim = tskim;
2901         bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
2902 }
2903
2904 /*
2905  * IOC failure handling.
2906  */
2907 void
2908 bfa_ioim_iocdisable(struct bfa_ioim_s *ioim)
2909 {
2910         bfa_trc(ioim->bfa, ioim->iotag);
2911         bfa_stats(ioim->itnim, io_iocdowns);
2912         bfa_sm_send_event(ioim, BFA_IOIM_SM_HWFAIL);
2913 }
2914
2915 /*
2916  * IO offline TOV popped. Fail the pending IO.
2917  */
2918 void
2919 bfa_ioim_tov(struct bfa_ioim_s *ioim)
2920 {
2921         bfa_trc(ioim->bfa, ioim->iotag);
2922         bfa_sm_send_event(ioim, BFA_IOIM_SM_IOTOV);
2923 }
2924
2925
2926 /*
2927  * Allocate IOIM resource for initiator mode I/O request.
2928  */
2929 struct bfa_ioim_s *
2930 bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
2931                 struct bfa_itnim_s *itnim, u16 nsges)
2932 {
2933         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
2934         struct bfa_ioim_s *ioim;
2935         struct bfa_iotag_s *iotag = NULL;
2936
2937         /*
2938          * alocate IOIM resource
2939          */
2940         bfa_q_deq(&fcpim->fcp->iotag_ioim_free_q, &iotag);
2941         if (!iotag) {
2942                 bfa_stats(itnim, no_iotags);
2943                 return NULL;
2944         }
2945
2946         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag->tag);
2947
2948         ioim->dio = dio;
2949         ioim->itnim = itnim;
2950         ioim->nsges = nsges;
2951         ioim->nsgpgs = 0;
2952
2953         bfa_stats(itnim, total_ios);
2954         fcpim->ios_active++;
2955
2956         list_add_tail(&ioim->qe, &itnim->io_q);
2957
2958         return ioim;
2959 }
2960
2961 void
2962 bfa_ioim_free(struct bfa_ioim_s *ioim)
2963 {
2964         struct bfa_fcpim_s *fcpim = ioim->fcpim;
2965         struct bfa_iotag_s *iotag;
2966
2967         if (ioim->nsgpgs > 0)
2968                 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
2969
2970         bfa_stats(ioim->itnim, io_comps);
2971         fcpim->ios_active--;
2972
2973         ioim->iotag &= BFA_IOIM_IOTAG_MASK;
2974
2975         WARN_ON(!(ioim->iotag <
2976                 (fcpim->fcp->num_ioim_reqs + fcpim->fcp->num_fwtio_reqs)));
2977         iotag = BFA_IOTAG_FROM_TAG(fcpim->fcp, ioim->iotag);
2978
2979         if (ioim->iotag < fcpim->fcp->num_ioim_reqs)
2980                 list_add_tail(&iotag->qe, &fcpim->fcp->iotag_ioim_free_q);
2981         else
2982                 list_add_tail(&iotag->qe, &fcpim->fcp->iotag_tio_free_q);
2983
2984         list_del(&ioim->qe);
2985 }
2986
2987 void
2988 bfa_ioim_start(struct bfa_ioim_s *ioim)
2989 {
2990         bfa_ioim_cb_profile_start(ioim->fcpim, ioim);
2991
2992         /*
2993          * Obtain the queue over which this request has to be issued
2994          */
2995         ioim->reqq = bfa_fcpim_ioredirect_enabled(ioim->bfa) ?
2996                         BFA_FALSE : bfa_itnim_get_reqq(ioim);
2997
2998         bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
2999 }
3000
3001 /*
3002  * Driver I/O abort request.
3003  */
3004 bfa_status_t
3005 bfa_ioim_abort(struct bfa_ioim_s *ioim)
3006 {
3007
3008         bfa_trc(ioim->bfa, ioim->iotag);
3009
3010         if (!bfa_ioim_is_abortable(ioim))
3011                 return BFA_STATUS_FAILED;
3012
3013         bfa_stats(ioim->itnim, io_aborts);
3014         bfa_sm_send_event(ioim, BFA_IOIM_SM_ABORT);
3015
3016         return BFA_STATUS_OK;
3017 }
3018
3019 /*
3020  *  BFA TSKIM state machine functions
3021  */
3022
3023 /*
3024  * Task management command beginning state.
3025  */
3026 static void
3027 bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3028 {
3029         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3030
3031         switch (event) {
3032         case BFA_TSKIM_SM_START:
3033                 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
3034                 bfa_tskim_gather_ios(tskim);
3035
3036                 /*
3037                  * If device is offline, do not send TM on wire. Just cleanup
3038                  * any pending IO requests and complete TM request.
3039                  */
3040                 if (!bfa_itnim_is_online(tskim->itnim)) {
3041                         bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3042                         tskim->tsk_status = BFI_TSKIM_STS_OK;
3043                         bfa_tskim_cleanup_ios(tskim);
3044                         return;
3045                 }
3046
3047                 if (!bfa_tskim_send(tskim)) {
3048                         bfa_sm_set_state(tskim, bfa_tskim_sm_qfull);
3049                         bfa_stats(tskim->itnim, tm_qwait);
3050                         bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
3051                                           &tskim->reqq_wait);
3052                 }
3053                 break;
3054
3055         default:
3056                 bfa_sm_fault(tskim->bfa, event);
3057         }
3058 }
3059
3060 /*
3061  * TM command is active, awaiting completion from firmware to
3062  * cleanup IO requests in TM scope.
3063  */
3064 static void
3065 bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3066 {
3067         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3068
3069         switch (event) {
3070         case BFA_TSKIM_SM_DONE:
3071                 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3072                 bfa_tskim_cleanup_ios(tskim);
3073                 break;
3074
3075         case BFA_TSKIM_SM_CLEANUP:
3076                 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
3077                 if (!bfa_tskim_send_abort(tskim)) {
3078                         bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup_qfull);
3079                         bfa_stats(tskim->itnim, tm_qwait);
3080                         bfa_reqq_wait(tskim->bfa, tskim->itnim->reqq,
3081                                 &tskim->reqq_wait);
3082                 }
3083                 break;
3084
3085         case BFA_TSKIM_SM_HWFAIL:
3086                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3087                 bfa_tskim_iocdisable_ios(tskim);
3088                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3089                 break;
3090
3091         default:
3092                 bfa_sm_fault(tskim->bfa, event);
3093         }
3094 }
3095
3096 /*
3097  * An active TM is being cleaned up since ITN is offline. Awaiting cleanup
3098  * completion event from firmware.
3099  */
3100 static void
3101 bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3102 {
3103         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3104
3105         switch (event) {
3106         case BFA_TSKIM_SM_DONE:
3107                 /*
3108                  * Ignore and wait for ABORT completion from firmware.
3109                  */
3110                 break;
3111
3112         case BFA_TSKIM_SM_UTAG:
3113         case BFA_TSKIM_SM_CLEANUP_DONE:
3114                 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3115                 bfa_tskim_cleanup_ios(tskim);
3116                 break;
3117
3118         case BFA_TSKIM_SM_HWFAIL:
3119                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3120                 bfa_tskim_iocdisable_ios(tskim);
3121                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3122                 break;
3123
3124         default:
3125                 bfa_sm_fault(tskim->bfa, event);
3126         }
3127 }
3128
3129 static void
3130 bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3131 {
3132         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3133
3134         switch (event) {
3135         case BFA_TSKIM_SM_IOS_DONE:
3136                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3137                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_done);
3138                 break;
3139
3140         case BFA_TSKIM_SM_CLEANUP:
3141                 /*
3142                  * Ignore, TM command completed on wire.
3143                  * Notify TM conmpletion on IO cleanup completion.
3144                  */
3145                 break;
3146
3147         case BFA_TSKIM_SM_HWFAIL:
3148                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3149                 bfa_tskim_iocdisable_ios(tskim);
3150                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3151                 break;
3152
3153         default:
3154                 bfa_sm_fault(tskim->bfa, event);
3155         }
3156 }
3157
3158 /*
3159  * Task management command is waiting for room in request CQ
3160  */
3161 static void
3162 bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3163 {
3164         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3165
3166         switch (event) {
3167         case BFA_TSKIM_SM_QRESUME:
3168                 bfa_sm_set_state(tskim, bfa_tskim_sm_active);
3169                 bfa_tskim_send(tskim);
3170                 break;
3171
3172         case BFA_TSKIM_SM_CLEANUP:
3173                 /*
3174                  * No need to send TM on wire since ITN is offline.
3175                  */
3176                 bfa_sm_set_state(tskim, bfa_tskim_sm_iocleanup);
3177                 bfa_reqq_wcancel(&tskim->reqq_wait);
3178                 bfa_tskim_cleanup_ios(tskim);
3179                 break;
3180
3181         case BFA_TSKIM_SM_HWFAIL:
3182                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3183                 bfa_reqq_wcancel(&tskim->reqq_wait);
3184                 bfa_tskim_iocdisable_ios(tskim);
3185                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3186                 break;
3187
3188         default:
3189                 bfa_sm_fault(tskim->bfa, event);
3190         }
3191 }
3192
3193 /*
3194  * Task management command is active, awaiting for room in request CQ
3195  * to send clean up request.
3196  */
3197 static void
3198 bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
3199                 enum bfa_tskim_event event)
3200 {
3201         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3202
3203         switch (event) {
3204         case BFA_TSKIM_SM_DONE:
3205                 bfa_reqq_wcancel(&tskim->reqq_wait);
3206                 fallthrough;
3207         case BFA_TSKIM_SM_QRESUME:
3208                 bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);
3209                 bfa_tskim_send_abort(tskim);
3210                 break;
3211
3212         case BFA_TSKIM_SM_HWFAIL:
3213                 bfa_sm_set_state(tskim, bfa_tskim_sm_hcb);
3214                 bfa_reqq_wcancel(&tskim->reqq_wait);
3215                 bfa_tskim_iocdisable_ios(tskim);
3216                 bfa_tskim_qcomp(tskim, __bfa_cb_tskim_failed);
3217                 break;
3218
3219         default:
3220                 bfa_sm_fault(tskim->bfa, event);
3221         }
3222 }
3223
3224 /*
3225  * BFA callback is pending
3226  */
3227 static void
3228 bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
3229 {
3230         bfa_trc(tskim->bfa, tskim->tsk_tag << 16 | event);
3231
3232         switch (event) {
3233         case BFA_TSKIM_SM_HCB:
3234                 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
3235                 bfa_tskim_free(tskim);
3236                 break;
3237
3238         case BFA_TSKIM_SM_CLEANUP:
3239                 bfa_tskim_notify_comp(tskim);
3240                 break;
3241
3242         case BFA_TSKIM_SM_HWFAIL:
3243                 break;
3244
3245         default:
3246                 bfa_sm_fault(tskim->bfa, event);
3247         }
3248 }
3249
3250 static void
3251 __bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete)
3252 {
3253         struct bfa_tskim_s *tskim = cbarg;
3254
3255         if (!complete) {
3256                 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
3257                 return;
3258         }
3259
3260         bfa_stats(tskim->itnim, tm_success);
3261         bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk, tskim->tsk_status);
3262 }
3263
3264 static void
3265 __bfa_cb_tskim_failed(void *cbarg, bfa_boolean_t complete)
3266 {
3267         struct bfa_tskim_s *tskim = cbarg;
3268
3269         if (!complete) {
3270                 bfa_sm_send_event(tskim, BFA_TSKIM_SM_HCB);
3271                 return;
3272         }
3273
3274         bfa_stats(tskim->itnim, tm_failures);
3275         bfa_cb_tskim_done(tskim->bfa->bfad, tskim->dtsk,
3276                                 BFI_TSKIM_STS_FAILED);
3277 }
3278
3279 static bfa_boolean_t
3280 bfa_tskim_match_scope(struct bfa_tskim_s *tskim, struct scsi_lun lun)
3281 {
3282         switch (tskim->tm_cmnd) {
3283         case FCP_TM_TARGET_RESET:
3284                 return BFA_TRUE;
3285
3286         case FCP_TM_ABORT_TASK_SET:
3287         case FCP_TM_CLEAR_TASK_SET:
3288         case FCP_TM_LUN_RESET:
3289         case FCP_TM_CLEAR_ACA:
3290                 return !memcmp(&tskim->lun, &lun, sizeof(lun));
3291
3292         default:
3293                 WARN_ON(1);
3294         }
3295
3296         return BFA_FALSE;
3297 }
3298
3299 /*
3300  * Gather affected IO requests and task management commands.
3301  */
3302 static void
3303 bfa_tskim_gather_ios(struct bfa_tskim_s *tskim)
3304 {
3305         struct bfa_itnim_s *itnim = tskim->itnim;
3306         struct bfa_ioim_s *ioim;
3307         struct list_head *qe, *qen;
3308         struct scsi_cmnd *cmnd;
3309         struct scsi_lun scsilun;
3310
3311         INIT_LIST_HEAD(&tskim->io_q);
3312
3313         /*
3314          * Gather any active IO requests first.
3315          */
3316         list_for_each_safe(qe, qen, &itnim->io_q) {
3317                 ioim = (struct bfa_ioim_s *) qe;
3318                 cmnd = (struct scsi_cmnd *) ioim->dio;
3319                 int_to_scsilun(cmnd->device->lun, &scsilun);
3320                 if (bfa_tskim_match_scope(tskim, scsilun)) {
3321                         list_del(&ioim->qe);
3322                         list_add_tail(&ioim->qe, &tskim->io_q);
3323                 }
3324         }
3325
3326         /*
3327          * Failback any pending IO requests immediately.
3328          */
3329         list_for_each_safe(qe, qen, &itnim->pending_q) {
3330                 ioim = (struct bfa_ioim_s *) qe;
3331                 cmnd = (struct scsi_cmnd *) ioim->dio;
3332                 int_to_scsilun(cmnd->device->lun, &scsilun);
3333                 if (bfa_tskim_match_scope(tskim, scsilun)) {
3334                         list_del(&ioim->qe);
3335                         list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
3336                         bfa_ioim_tov(ioim);
3337                 }
3338         }
3339 }
3340
3341 /*
3342  * IO cleanup completion
3343  */
3344 static void
3345 bfa_tskim_cleanp_comp(void *tskim_cbarg)
3346 {
3347         struct bfa_tskim_s *tskim = tskim_cbarg;
3348
3349         bfa_stats(tskim->itnim, tm_io_comps);
3350         bfa_sm_send_event(tskim, BFA_TSKIM_SM_IOS_DONE);
3351 }
3352
3353 /*
3354  * Gather affected IO requests and task management commands.
3355  */
3356 static void
3357 bfa_tskim_cleanup_ios(struct bfa_tskim_s *tskim)
3358 {
3359         struct bfa_ioim_s *ioim;
3360         struct list_head        *qe, *qen;
3361
3362         bfa_wc_init(&tskim->wc, bfa_tskim_cleanp_comp, tskim);
3363
3364         list_for_each_safe(qe, qen, &tskim->io_q) {
3365                 ioim = (struct bfa_ioim_s *) qe;
3366                 bfa_wc_up(&tskim->wc);
3367                 bfa_ioim_cleanup_tm(ioim, tskim);
3368         }
3369
3370         bfa_wc_wait(&tskim->wc);
3371 }
3372
3373 /*
3374  * Send task management request to firmware.
3375  */
3376 static bfa_boolean_t
3377 bfa_tskim_send(struct bfa_tskim_s *tskim)
3378 {
3379         struct bfa_itnim_s *itnim = tskim->itnim;
3380         struct bfi_tskim_req_s *m;
3381
3382         /*
3383          * check for room in queue to send request now
3384          */
3385         m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3386         if (!m)
3387                 return BFA_FALSE;
3388
3389         /*
3390          * build i/o request message next
3391          */
3392         bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_TM_REQ,
3393                         bfa_fn_lpu(tskim->bfa));
3394
3395         m->tsk_tag = cpu_to_be16(tskim->tsk_tag);
3396         m->itn_fhdl = tskim->itnim->rport->fw_handle;
3397         m->t_secs = tskim->tsecs;
3398         m->lun = tskim->lun;
3399         m->tm_flags = tskim->tm_cmnd;
3400
3401         /*
3402          * queue I/O message to firmware
3403          */
3404         bfa_reqq_produce(tskim->bfa, itnim->reqq, m->mh);
3405         return BFA_TRUE;
3406 }
3407
3408 /*
3409  * Send abort request to cleanup an active TM to firmware.
3410  */
3411 static bfa_boolean_t
3412 bfa_tskim_send_abort(struct bfa_tskim_s *tskim)
3413 {
3414         struct bfa_itnim_s      *itnim = tskim->itnim;
3415         struct bfi_tskim_abortreq_s     *m;
3416
3417         /*
3418          * check for room in queue to send request now
3419          */
3420         m = bfa_reqq_next(tskim->bfa, itnim->reqq);
3421         if (!m)
3422                 return BFA_FALSE;
3423
3424         /*
3425          * build i/o request message next
3426          */
3427         bfi_h2i_set(m->mh, BFI_MC_TSKIM, BFI_TSKIM_H2I_ABORT_REQ,
3428                         bfa_fn_lpu(tskim->bfa));
3429
3430         m->tsk_tag  = cpu_to_be16(tskim->tsk_tag);
3431
3432         /*
3433          * queue I/O message to firmware
3434          */
3435         bfa_reqq_produce(tskim->bfa, itnim->reqq, m->mh);
3436         return BFA_TRUE;
3437 }
3438
3439 /*
3440  * Call to resume task management cmnd waiting for room in request queue.
3441  */
3442 static void
3443 bfa_tskim_qresume(void *cbarg)
3444 {
3445         struct bfa_tskim_s *tskim = cbarg;
3446
3447         bfa_stats(tskim->itnim, tm_qresumes);
3448         bfa_sm_send_event(tskim, BFA_TSKIM_SM_QRESUME);
3449 }
3450
3451 /*
3452  * Cleanup IOs associated with a task mangement command on IOC failures.
3453  */
3454 static void
3455 bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim)
3456 {
3457         struct bfa_ioim_s *ioim;
3458         struct list_head        *qe, *qen;
3459
3460         list_for_each_safe(qe, qen, &tskim->io_q) {
3461                 ioim = (struct bfa_ioim_s *) qe;
3462                 bfa_ioim_iocdisable(ioim);
3463         }
3464 }
3465
3466 /*
3467  * Notification on completions from related ioim.
3468  */
3469 void
3470 bfa_tskim_iodone(struct bfa_tskim_s *tskim)
3471 {
3472         bfa_wc_down(&tskim->wc);
3473 }
3474
3475 /*
3476  * Handle IOC h/w failure notification from itnim.
3477  */
3478 void
3479 bfa_tskim_iocdisable(struct bfa_tskim_s *tskim)
3480 {
3481         tskim->notify = BFA_FALSE;
3482         bfa_stats(tskim->itnim, tm_iocdowns);
3483         bfa_sm_send_event(tskim, BFA_TSKIM_SM_HWFAIL);
3484 }
3485
3486 /*
3487  * Cleanup TM command and associated IOs as part of ITNIM offline.
3488  */
3489 void
3490 bfa_tskim_cleanup(struct bfa_tskim_s *tskim)
3491 {
3492         tskim->notify = BFA_TRUE;
3493         bfa_stats(tskim->itnim, tm_cleanups);
3494         bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP);
3495 }
3496
3497 /*
3498  * Memory allocation and initialization.
3499  */
3500 void
3501 bfa_tskim_attach(struct bfa_fcpim_s *fcpim)
3502 {
3503         struct bfa_tskim_s *tskim;
3504         struct bfa_fcp_mod_s    *fcp = fcpim->fcp;
3505         u16     i;
3506
3507         INIT_LIST_HEAD(&fcpim->tskim_free_q);
3508         INIT_LIST_HEAD(&fcpim->tskim_unused_q);
3509
3510         tskim = (struct bfa_tskim_s *) bfa_mem_kva_curp(fcp);
3511         fcpim->tskim_arr = tskim;
3512
3513         for (i = 0; i < fcpim->num_tskim_reqs; i++, tskim++) {
3514                 /*
3515                  * initialize TSKIM
3516                  */
3517                 memset(tskim, 0, sizeof(struct bfa_tskim_s));
3518                 tskim->tsk_tag = i;
3519                 tskim->bfa      = fcpim->bfa;
3520                 tskim->fcpim    = fcpim;
3521                 tskim->notify  = BFA_FALSE;
3522                 bfa_reqq_winit(&tskim->reqq_wait, bfa_tskim_qresume,
3523                                         tskim);
3524                 bfa_sm_set_state(tskim, bfa_tskim_sm_uninit);
3525
3526                 list_add_tail(&tskim->qe, &fcpim->tskim_free_q);
3527         }
3528
3529         bfa_mem_kva_curp(fcp) = (u8 *) tskim;
3530 }
3531
3532 void
3533 bfa_tskim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3534 {
3535         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3536         struct bfi_tskim_rsp_s *rsp = (struct bfi_tskim_rsp_s *) m;
3537         struct bfa_tskim_s *tskim;
3538         u16     tsk_tag = be16_to_cpu(rsp->tsk_tag);
3539
3540         tskim = BFA_TSKIM_FROM_TAG(fcpim, tsk_tag);
3541         WARN_ON(tskim->tsk_tag != tsk_tag);
3542
3543         tskim->tsk_status = rsp->tsk_status;
3544
3545         /*
3546          * Firmware sends BFI_TSKIM_STS_ABORTED status for abort
3547          * requests. All other statuses are for normal completions.
3548          */
3549         if (rsp->tsk_status == BFI_TSKIM_STS_ABORTED) {
3550                 bfa_stats(tskim->itnim, tm_cleanup_comps);
3551                 bfa_sm_send_event(tskim, BFA_TSKIM_SM_CLEANUP_DONE);
3552         } else if (rsp->tsk_status == BFI_TSKIM_STS_UTAG) {
3553                 bfa_sm_send_event(tskim, BFA_TSKIM_SM_UTAG);
3554         } else {
3555                 bfa_stats(tskim->itnim, tm_fw_rsps);
3556                 bfa_sm_send_event(tskim, BFA_TSKIM_SM_DONE);
3557         }
3558 }
3559
3560
3561 struct bfa_tskim_s *
3562 bfa_tskim_alloc(struct bfa_s *bfa, struct bfad_tskim_s *dtsk)
3563 {
3564         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3565         struct bfa_tskim_s *tskim;
3566
3567         bfa_q_deq(&fcpim->tskim_free_q, &tskim);
3568
3569         if (tskim)
3570                 tskim->dtsk = dtsk;
3571
3572         return tskim;
3573 }
3574
3575 void
3576 bfa_tskim_free(struct bfa_tskim_s *tskim)
3577 {
3578         WARN_ON(!bfa_q_is_on_q_func(&tskim->itnim->tsk_q, &tskim->qe));
3579         list_del(&tskim->qe);
3580         list_add_tail(&tskim->qe, &tskim->fcpim->tskim_free_q);
3581 }
3582
3583 /*
3584  * Start a task management command.
3585  *
3586  * @param[in]   tskim   BFA task management command instance
3587  * @param[in]   itnim   i-t nexus for the task management command
3588  * @param[in]   lun     lun, if applicable
3589  * @param[in]   tm_cmnd Task management command code.
3590  * @param[in]   t_secs  Timeout in seconds
3591  *
3592  * @return None.
3593  */
3594 void
3595 bfa_tskim_start(struct bfa_tskim_s *tskim, struct bfa_itnim_s *itnim,
3596                         struct scsi_lun lun,
3597                         enum fcp_tm_cmnd tm_cmnd, u8 tsecs)
3598 {
3599         tskim->itnim    = itnim;
3600         tskim->lun      = lun;
3601         tskim->tm_cmnd = tm_cmnd;
3602         tskim->tsecs    = tsecs;
3603         tskim->notify  = BFA_FALSE;
3604         bfa_stats(itnim, tm_cmnds);
3605
3606         list_add_tail(&tskim->qe, &itnim->tsk_q);
3607         bfa_sm_send_event(tskim, BFA_TSKIM_SM_START);
3608 }
3609
3610 void
3611 bfa_tskim_res_recfg(struct bfa_s *bfa, u16 num_tskim_fw)
3612 {
3613         struct bfa_fcpim_s      *fcpim = BFA_FCPIM(bfa);
3614         struct list_head        *qe;
3615         int     i;
3616
3617         for (i = 0; i < (fcpim->num_tskim_reqs - num_tskim_fw); i++) {
3618                 bfa_q_deq_tail(&fcpim->tskim_free_q, &qe);
3619                 list_add_tail(qe, &fcpim->tskim_unused_q);
3620         }
3621 }
3622
3623 void
3624 bfa_fcp_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *minfo,
3625                 struct bfa_s *bfa)
3626 {
3627         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3628         struct bfa_mem_kva_s *fcp_kva = BFA_MEM_FCP_KVA(bfa);
3629         struct bfa_mem_dma_s *seg_ptr;
3630         u16     nsegs, idx, per_seg_ios, num_io_req;
3631         u32     km_len = 0;
3632
3633         /*
3634          * ZERO for num_ioim_reqs and num_fwtio_reqs is allowed config value.
3635          * So if the values are non zero, adjust them appropriately.
3636          */
3637         if (cfg->fwcfg.num_ioim_reqs &&
3638             cfg->fwcfg.num_ioim_reqs < BFA_IOIM_MIN)
3639                 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN;
3640         else if (cfg->fwcfg.num_ioim_reqs > BFA_IOIM_MAX)
3641                 cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MAX;
3642
3643         if (cfg->fwcfg.num_fwtio_reqs > BFA_FWTIO_MAX)
3644                 cfg->fwcfg.num_fwtio_reqs = BFA_FWTIO_MAX;
3645
3646         num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
3647         if (num_io_req > BFA_IO_MAX) {
3648                 if (cfg->fwcfg.num_ioim_reqs && cfg->fwcfg.num_fwtio_reqs) {
3649                         cfg->fwcfg.num_ioim_reqs = BFA_IO_MAX/2;
3650                         cfg->fwcfg.num_fwtio_reqs = BFA_IO_MAX/2;
3651                 } else if (cfg->fwcfg.num_fwtio_reqs)
3652                         cfg->fwcfg.num_fwtio_reqs = BFA_FWTIO_MAX;
3653                 else
3654                         cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MAX;
3655         }
3656
3657         bfa_fcpim_meminfo(cfg, &km_len);
3658
3659         num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
3660         km_len += num_io_req * sizeof(struct bfa_iotag_s);
3661         km_len += cfg->fwcfg.num_rports * sizeof(struct bfa_itn_s);
3662
3663         /* dma memory */
3664         nsegs = BFI_MEM_DMA_NSEGS(num_io_req, BFI_IOIM_SNSLEN);
3665         per_seg_ios = BFI_MEM_NREQS_SEG(BFI_IOIM_SNSLEN);
3666
3667         bfa_mem_dma_seg_iter(fcp, seg_ptr, nsegs, idx) {
3668                 if (num_io_req >= per_seg_ios) {
3669                         num_io_req -= per_seg_ios;
3670                         bfa_mem_dma_setup(minfo, seg_ptr,
3671                                 per_seg_ios * BFI_IOIM_SNSLEN);
3672                 } else
3673                         bfa_mem_dma_setup(minfo, seg_ptr,
3674                                 num_io_req * BFI_IOIM_SNSLEN);
3675         }
3676
3677         /* kva memory */
3678         bfa_mem_kva_setup(minfo, fcp_kva, km_len);
3679 }
3680
3681 void
3682 bfa_fcp_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
3683                 struct bfa_pcidev_s *pcidev)
3684 {
3685         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3686         struct bfa_mem_dma_s *seg_ptr;
3687         u16     idx, nsegs, num_io_req;
3688
3689         fcp->max_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
3690         fcp->num_ioim_reqs = cfg->fwcfg.num_ioim_reqs;
3691         fcp->num_fwtio_reqs  = cfg->fwcfg.num_fwtio_reqs;
3692         fcp->num_itns   = cfg->fwcfg.num_rports;
3693         fcp->bfa = bfa;
3694
3695         /*
3696          * Setup the pool of snsbase addr's, that is passed to fw as
3697          * part of bfi_iocfc_cfg_s.
3698          */
3699         num_io_req = (cfg->fwcfg.num_ioim_reqs + cfg->fwcfg.num_fwtio_reqs);
3700         nsegs = BFI_MEM_DMA_NSEGS(num_io_req, BFI_IOIM_SNSLEN);
3701
3702         bfa_mem_dma_seg_iter(fcp, seg_ptr, nsegs, idx) {
3703
3704                 if (!bfa_mem_dma_virt(seg_ptr))
3705                         break;
3706
3707                 fcp->snsbase[idx].pa = bfa_mem_dma_phys(seg_ptr);
3708                 fcp->snsbase[idx].kva = bfa_mem_dma_virt(seg_ptr);
3709                 bfa_iocfc_set_snsbase(bfa, idx, fcp->snsbase[idx].pa);
3710         }
3711
3712         fcp->throttle_update_required = 1;
3713         bfa_fcpim_attach(fcp, bfad, cfg, pcidev);
3714
3715         bfa_iotag_attach(fcp);
3716
3717         fcp->itn_arr = (struct bfa_itn_s *) bfa_mem_kva_curp(fcp);
3718         bfa_mem_kva_curp(fcp) = (u8 *)fcp->itn_arr +
3719                         (fcp->num_itns * sizeof(struct bfa_itn_s));
3720         memset(fcp->itn_arr, 0,
3721                         (fcp->num_itns * sizeof(struct bfa_itn_s)));
3722 }
3723
3724 void
3725 bfa_fcp_iocdisable(struct bfa_s *bfa)
3726 {
3727         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3728
3729         bfa_fcpim_iocdisable(fcp);
3730 }
3731
3732 void
3733 bfa_fcp_res_recfg(struct bfa_s *bfa, u16 num_ioim_fw, u16 max_ioim_fw)
3734 {
3735         struct bfa_fcp_mod_s    *mod = BFA_FCP_MOD(bfa);
3736         struct list_head        *qe;
3737         int     i;
3738
3739         /* Update io throttle value only once during driver load time */
3740         if (!mod->throttle_update_required)
3741                 return;
3742
3743         for (i = 0; i < (mod->num_ioim_reqs - num_ioim_fw); i++) {
3744                 bfa_q_deq_tail(&mod->iotag_ioim_free_q, &qe);
3745                 list_add_tail(qe, &mod->iotag_unused_q);
3746         }
3747
3748         if (mod->num_ioim_reqs != num_ioim_fw) {
3749                 bfa_trc(bfa, mod->num_ioim_reqs);
3750                 bfa_trc(bfa, num_ioim_fw);
3751         }
3752
3753         mod->max_ioim_reqs = max_ioim_fw;
3754         mod->num_ioim_reqs = num_ioim_fw;
3755         mod->throttle_update_required = 0;
3756 }
3757
3758 void
3759 bfa_itn_create(struct bfa_s *bfa, struct bfa_rport_s *rport,
3760                 void (*isr)(struct bfa_s *bfa, struct bfi_msg_s *m))
3761 {
3762         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3763         struct bfa_itn_s *itn;
3764
3765         itn =  BFA_ITN_FROM_TAG(fcp, rport->rport_tag);
3766         itn->isr = isr;
3767 }
3768
3769 /*
3770  * Itn interrupt processing.
3771  */
3772 void
3773 bfa_itn_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
3774 {
3775         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3776         union bfi_itn_i2h_msg_u msg;
3777         struct bfa_itn_s *itn;
3778
3779         msg.msg = m;
3780         itn =  BFA_ITN_FROM_TAG(fcp, msg.create_rsp->bfa_handle);
3781
3782         if (itn->isr)
3783                 itn->isr(bfa, m);
3784         else
3785                 WARN_ON(1);
3786 }
3787
3788 void
3789 bfa_iotag_attach(struct bfa_fcp_mod_s *fcp)
3790 {
3791         struct bfa_iotag_s *iotag;
3792         u16     num_io_req, i;
3793
3794         iotag = (struct bfa_iotag_s *) bfa_mem_kva_curp(fcp);
3795         fcp->iotag_arr = iotag;
3796
3797         INIT_LIST_HEAD(&fcp->iotag_ioim_free_q);
3798         INIT_LIST_HEAD(&fcp->iotag_tio_free_q);
3799         INIT_LIST_HEAD(&fcp->iotag_unused_q);
3800
3801         num_io_req = fcp->num_ioim_reqs + fcp->num_fwtio_reqs;
3802         for (i = 0; i < num_io_req; i++, iotag++) {
3803                 memset(iotag, 0, sizeof(struct bfa_iotag_s));
3804                 iotag->tag = i;
3805                 if (i < fcp->num_ioim_reqs)
3806                         list_add_tail(&iotag->qe, &fcp->iotag_ioim_free_q);
3807                 else
3808                         list_add_tail(&iotag->qe, &fcp->iotag_tio_free_q);
3809         }
3810
3811         bfa_mem_kva_curp(fcp) = (u8 *) iotag;
3812 }
3813
3814
3815 /*
3816  * To send config req, first try to use throttle value from flash
3817  * If 0, then use driver parameter
3818  * We need to use min(flash_val, drv_val) because
3819  * memory allocation was done based on this cfg'd value
3820  */
3821 u16
3822 bfa_fcpim_get_throttle_cfg(struct bfa_s *bfa, u16 drv_cfg_param)
3823 {
3824         u16 tmp;
3825         struct bfa_fcp_mod_s *fcp = BFA_FCP_MOD(bfa);
3826
3827         /*
3828          * If throttle value from flash is already in effect after driver is
3829          * loaded then until next load, always return current value instead
3830          * of actual flash value
3831          */
3832         if (!fcp->throttle_update_required)
3833                 return (u16)fcp->num_ioim_reqs;
3834
3835         tmp = bfa_dconf_read_data_valid(bfa) ? bfa_fcpim_read_throttle(bfa) : 0;
3836         if (!tmp || (tmp > drv_cfg_param))
3837                 tmp = drv_cfg_param;
3838
3839         return tmp;
3840 }
3841
3842 bfa_status_t
3843 bfa_fcpim_write_throttle(struct bfa_s *bfa, u16 value)
3844 {
3845         if (!bfa_dconf_get_min_cfg(bfa)) {
3846                 BFA_DCONF_MOD(bfa)->dconf->throttle_cfg.value = value;
3847                 BFA_DCONF_MOD(bfa)->dconf->throttle_cfg.is_valid = 1;
3848                 return BFA_STATUS_OK;
3849         }
3850
3851         return BFA_STATUS_FAILED;
3852 }
3853
3854 u16
3855 bfa_fcpim_read_throttle(struct bfa_s *bfa)
3856 {
3857         struct bfa_throttle_cfg_s *throttle_cfg =
3858                         &(BFA_DCONF_MOD(bfa)->dconf->throttle_cfg);
3859
3860         return ((!bfa_dconf_get_min_cfg(bfa)) ?
3861                ((throttle_cfg->is_valid == 1) ? (throttle_cfg->value) : 0) : 0);
3862 }
3863
3864 bfa_status_t
3865 bfa_fcpim_throttle_set(struct bfa_s *bfa, u16 value)
3866 {
3867         /* in min cfg no commands should run. */
3868         if ((bfa_dconf_get_min_cfg(bfa) == BFA_TRUE) ||
3869             (!bfa_dconf_read_data_valid(bfa)))
3870                 return BFA_STATUS_FAILED;
3871
3872         bfa_fcpim_write_throttle(bfa, value);
3873
3874         return bfa_dconf_update(bfa);
3875 }
3876
3877 bfa_status_t
3878 bfa_fcpim_throttle_get(struct bfa_s *bfa, void *buf)
3879 {
3880         struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
3881         struct bfa_defs_fcpim_throttle_s throttle;
3882
3883         if ((bfa_dconf_get_min_cfg(bfa) == BFA_TRUE) ||
3884             (!bfa_dconf_read_data_valid(bfa)))
3885                 return BFA_STATUS_FAILED;
3886
3887         memset(&throttle, 0, sizeof(struct bfa_defs_fcpim_throttle_s));
3888
3889         throttle.cur_value = (u16)(fcpim->fcp->num_ioim_reqs);
3890         throttle.cfg_value = bfa_fcpim_read_throttle(bfa);
3891         if (!throttle.cfg_value)
3892                 throttle.cfg_value = throttle.cur_value;
3893         throttle.max_value = (u16)(fcpim->fcp->max_ioim_reqs);
3894         memcpy(buf, &throttle, sizeof(struct bfa_defs_fcpim_throttle_s));
3895
3896         return BFA_STATUS_OK;
3897 }