drivers/scsi/bfa/bfa_fcpim.c

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