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