drivers/scsi/bfa/bfa_fcpim.c

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