drivers/scsi/bfa/bfa_ioim.c

   1 /*
   2  * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
   3  * All rights reserved
   4  * www.brocade.com
   5  *
   6  * Linux driver for Brocade Fibre Channel Host Bus Adapter.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License (GPL) Version 2 as
  10  * published by the Free Software Foundation
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  */
  17
  18 #include <bfa.h>
  19 #include <cs/bfa_debug.h>
  20 #include <bfa_cb_ioim_macros.h>
  21
  22 BFA_TRC_FILE(HAL, IOIM);
  23
  24 /*
  25  * forward declarations.
  26  */
  27 static bfa_boolean_t    bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim);
  28 static bfa_boolean_t    bfa_ioim_sge_setup(struct bfa_ioim_s *ioim);
  29 static void             bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim);
  30 static bfa_boolean_t    bfa_ioim_send_abort(struct bfa_ioim_s *ioim);
  31 static void             bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim);
  32 static void __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete);
  33 static void __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete);
  34 static void __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete);
  35 static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete);
  36 static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);
  37
  38 /**
  39  *  bfa_ioim_sm
  40  */
  41
  42 /**
  43  * IO state machine events
  44  */
  45 enum bfa_ioim_event {
  46         BFA_IOIM_SM_START = 1,          /*  io start request from host */
  47         BFA_IOIM_SM_COMP_GOOD = 2,      /*  io good comp, resource free */
  48         BFA_IOIM_SM_COMP = 3,           /*  io comp, resource is free */
  49         BFA_IOIM_SM_COMP_UTAG = 4,      /*  io comp, resource is free */
  50         BFA_IOIM_SM_DONE = 5,           /*  io comp, resource not free */
  51         BFA_IOIM_SM_FREE = 6,           /*  io resource is freed */
  52         BFA_IOIM_SM_ABORT = 7,          /*  abort request from scsi stack */
  53         BFA_IOIM_SM_ABORT_COMP = 8,     /*  abort from f/w */
  54         BFA_IOIM_SM_ABORT_DONE = 9,     /*  abort completion from f/w */
  55         BFA_IOIM_SM_QRESUME = 10,       /*  CQ space available to queue IO */
  56         BFA_IOIM_SM_SGALLOCED = 11,     /*  SG page allocation successful */
  57         BFA_IOIM_SM_SQRETRY = 12,       /*  sequence recovery retry */
  58         BFA_IOIM_SM_HCB = 13,           /*  bfa callback complete */
  59         BFA_IOIM_SM_CLEANUP = 14,       /*  IO cleanup from itnim */
  60         BFA_IOIM_SM_TMSTART = 15,       /*  IO cleanup from tskim */
  61         BFA_IOIM_SM_TMDONE = 16,        /*  IO cleanup from tskim */
  62         BFA_IOIM_SM_HWFAIL = 17,        /*  IOC h/w failure event */
  63         BFA_IOIM_SM_IOTOV = 18,         /*  ITN offline TOV       */
  64 };
  65
  66 /*
  67  * forward declaration of IO state machine
  68  */
  69 static void     bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim,
  70                                        enum bfa_ioim_event event);
  71 static void     bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim,
  72                                         enum bfa_ioim_event event);
  73 static void     bfa_ioim_sm_active(struct bfa_ioim_s *ioim,
  74                                        enum bfa_ioim_event event);
  75 static void     bfa_ioim_sm_abort(struct bfa_ioim_s *ioim,
  76                                       enum bfa_ioim_event event);
  77 static void     bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim,
  78                                         enum bfa_ioim_event event);
  79 static void     bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim,
  80                                       enum bfa_ioim_event event);
  81 static void     bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim,
  82                                             enum bfa_ioim_event event);
  83 static void     bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim,
  84                                               enum bfa_ioim_event event);
  85 static void     bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim,
  86                                     enum bfa_ioim_event event);
  87 static void     bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim,
  88                                          enum bfa_ioim_event event);
  89 static void     bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim,
  90                                         enum bfa_ioim_event event);
  91
  92 /**
  93  *              IO is not started (unallocated).
  94  */
  95 static void
  96 bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
  97 {
  98         bfa_trc_fp(ioim->bfa, ioim->iotag);
  99         bfa_trc_fp(ioim->bfa, event);
 100
 101         switch (event) {
 102         case BFA_IOIM_SM_START:
 103                 if (!bfa_itnim_is_online(ioim->itnim)) {
 104                         if (!bfa_itnim_hold_io(ioim->itnim)) {
 105                                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 106                                 list_del(&ioim->qe);
 107                                 list_add_tail(&ioim->qe,
 108                                                 &ioim->fcpim->ioim_comp_q);
 109                                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
 110                                                 __bfa_cb_ioim_pathtov, ioim);
 111                         } else {
 112                                 list_del(&ioim->qe);
 113                                 list_add_tail(&ioim->qe,
 114                                                 &ioim->itnim->pending_q);
 115                         }
 116                         break;
 117                 }
 118
 119                 if (ioim->nsges > BFI_SGE_INLINE) {
 120                         if (!bfa_ioim_sge_setup(ioim)) {
 121                                 bfa_sm_set_state(ioim, bfa_ioim_sm_sgalloc);
 122                                 return;
 123                         }
 124                 }
 125
 126                 if (!bfa_ioim_send_ioreq(ioim)) {
 127                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
 128                         break;
 129                 }
 130
 131                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
 132                 break;
 133
 134         case BFA_IOIM_SM_IOTOV:
 135                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 136                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
 137                                 __bfa_cb_ioim_pathtov, ioim);
 138                 break;
 139
 140         case BFA_IOIM_SM_ABORT:
 141                 /**
 142                  * IO in pending queue can get abort requests. Complete abort
 143                  * requests immediately.
 144                  */
 145                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 146                 bfa_assert(bfa_q_is_on_q(&ioim->itnim->pending_q, ioim));
 147                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 148                                 ioim);
 149                 break;
 150
 151         default:
 152                 bfa_sm_fault(ioim->bfa, event);
 153         }
 154 }
 155
 156 /**
 157  *              IO is waiting for SG pages.
 158  */
 159 static void
 160 bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 161 {
 162         bfa_trc(ioim->bfa, ioim->iotag);
 163         bfa_trc(ioim->bfa, event);
 164
 165         switch (event) {
 166         case BFA_IOIM_SM_SGALLOCED:
 167                 if (!bfa_ioim_send_ioreq(ioim)) {
 168                         bfa_sm_set_state(ioim, bfa_ioim_sm_qfull);
 169                         break;
 170                 }
 171                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
 172                 break;
 173
 174         case BFA_IOIM_SM_CLEANUP:
 175                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 176                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
 177                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 178                               ioim);
 179                 bfa_ioim_notify_cleanup(ioim);
 180                 break;
 181
 182         case BFA_IOIM_SM_ABORT:
 183                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 184                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
 185                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 186                               ioim);
 187                 break;
 188
 189         case BFA_IOIM_SM_HWFAIL:
 190                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 191                 bfa_sgpg_wcancel(ioim->bfa, &ioim->iosp->sgpg_wqe);
 192                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 193                               ioim);
 194                 break;
 195
 196         default:
 197                 bfa_sm_fault(ioim->bfa, event);
 198         }
 199 }
 200
 201 /**
 202  *              IO is active.
 203  */
 204 static void
 205 bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 206 {
 207         bfa_trc_fp(ioim->bfa, ioim->iotag);
 208         bfa_trc_fp(ioim->bfa, event);
 209
 210         switch (event) {
 211         case BFA_IOIM_SM_COMP_GOOD:
 212                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 213                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
 214                               __bfa_cb_ioim_good_comp, ioim);
 215                 break;
 216
 217         case BFA_IOIM_SM_COMP:
 218                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 219                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
 220                               ioim);
 221                 break;
 222
 223         case BFA_IOIM_SM_DONE:
 224                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
 225                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_comp,
 226                               ioim);
 227                 break;
 228
 229         case BFA_IOIM_SM_ABORT:
 230                 ioim->iosp->abort_explicit = BFA_TRUE;
 231                 ioim->io_cbfn = __bfa_cb_ioim_abort;
 232
 233                 if (bfa_ioim_send_abort(ioim))
 234                         bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
 235                 else {
 236                         bfa_sm_set_state(ioim, bfa_ioim_sm_abort_qfull);
 237                         bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
 238                                           &ioim->iosp->reqq_wait);
 239                 }
 240                 break;
 241
 242         case BFA_IOIM_SM_CLEANUP:
 243                 ioim->iosp->abort_explicit = BFA_FALSE;
 244                 ioim->io_cbfn = __bfa_cb_ioim_failed;
 245
 246                 if (bfa_ioim_send_abort(ioim))
 247                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
 248                 else {
 249                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
 250                         bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
 251                                           &ioim->iosp->reqq_wait);
 252                 }
 253                 break;
 254
 255         case BFA_IOIM_SM_HWFAIL:
 256                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 257                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 258                               ioim);
 259                 break;
 260
 261         default:
 262                 bfa_sm_fault(ioim->bfa, event);
 263         }
 264 }
 265
 266 /**
 267  *              IO is being aborted, waiting for completion from firmware.
 268  */
 269 static void
 270 bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 271 {
 272         bfa_trc(ioim->bfa, ioim->iotag);
 273         bfa_trc(ioim->bfa, event);
 274
 275         switch (event) {
 276         case BFA_IOIM_SM_COMP_GOOD:
 277         case BFA_IOIM_SM_COMP:
 278         case BFA_IOIM_SM_DONE:
 279         case BFA_IOIM_SM_FREE:
 280                 break;
 281
 282         case BFA_IOIM_SM_ABORT_DONE:
 283                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
 284                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 285                               ioim);
 286                 break;
 287
 288         case BFA_IOIM_SM_ABORT_COMP:
 289                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 290                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 291                               ioim);
 292                 break;
 293
 294         case BFA_IOIM_SM_COMP_UTAG:
 295                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 296                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 297                               ioim);
 298                 break;
 299
 300         case BFA_IOIM_SM_CLEANUP:
 301                 bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
 302                 ioim->iosp->abort_explicit = BFA_FALSE;
 303
 304                 if (bfa_ioim_send_abort(ioim))
 305                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
 306                 else {
 307                         bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
 308                         bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
 309                                           &ioim->iosp->reqq_wait);
 310                 }
 311                 break;
 312
 313         case BFA_IOIM_SM_HWFAIL:
 314                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 315                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 316                               ioim);
 317                 break;
 318
 319         default:
 320                 bfa_sm_fault(ioim->bfa, event);
 321         }
 322 }
 323
 324 /**
 325  * IO is being cleaned up (implicit abort), waiting for completion from
 326  * firmware.
 327  */
 328 static void
 329 bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 330 {
 331         bfa_trc(ioim->bfa, ioim->iotag);
 332         bfa_trc(ioim->bfa, event);
 333
 334         switch (event) {
 335         case BFA_IOIM_SM_COMP_GOOD:
 336         case BFA_IOIM_SM_COMP:
 337         case BFA_IOIM_SM_DONE:
 338         case BFA_IOIM_SM_FREE:
 339                 break;
 340
 341         case BFA_IOIM_SM_ABORT:
 342                 /**
 343                  * IO is already being aborted implicitly
 344                  */
 345                 ioim->io_cbfn = __bfa_cb_ioim_abort;
 346                 break;
 347
 348         case BFA_IOIM_SM_ABORT_DONE:
 349                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
 350                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
 351                 bfa_ioim_notify_cleanup(ioim);
 352                 break;
 353
 354         case BFA_IOIM_SM_ABORT_COMP:
 355                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 356                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
 357                 bfa_ioim_notify_cleanup(ioim);
 358                 break;
 359
 360         case BFA_IOIM_SM_COMP_UTAG:
 361                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 362                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
 363                 bfa_ioim_notify_cleanup(ioim);
 364                 break;
 365
 366         case BFA_IOIM_SM_HWFAIL:
 367                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 368                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 369                               ioim);
 370                 break;
 371
 372         case BFA_IOIM_SM_CLEANUP:
 373                 /**
 374                  * IO can be in cleanup state already due to TM command. 2nd cleanup
 375                  * request comes from ITN offline event.
 376                  */
 377                 break;
 378
 379         default:
 380                 bfa_sm_fault(ioim->bfa, event);
 381         }
 382 }
 383
 384 /**
 385  *              IO is waiting for room in request CQ
 386  */
 387 static void
 388 bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 389 {
 390         bfa_trc(ioim->bfa, ioim->iotag);
 391         bfa_trc(ioim->bfa, event);
 392
 393         switch (event) {
 394         case BFA_IOIM_SM_QRESUME:
 395                 bfa_sm_set_state(ioim, bfa_ioim_sm_active);
 396                 bfa_ioim_send_ioreq(ioim);
 397                 break;
 398
 399         case BFA_IOIM_SM_ABORT:
 400                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 401                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 402                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 403                               ioim);
 404                 break;
 405
 406         case BFA_IOIM_SM_CLEANUP:
 407                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 408                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 409                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 410                               ioim);
 411                 bfa_ioim_notify_cleanup(ioim);
 412                 break;
 413
 414         case BFA_IOIM_SM_HWFAIL:
 415                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 416                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 417                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 418                               ioim);
 419                 break;
 420
 421         default:
 422                 bfa_sm_fault(ioim->bfa, event);
 423         }
 424 }
 425
 426 /**
 427  *              Active IO is being aborted, waiting for room in request CQ.
 428  */
 429 static void
 430 bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 431 {
 432         bfa_trc(ioim->bfa, ioim->iotag);
 433         bfa_trc(ioim->bfa, event);
 434
 435         switch (event) {
 436         case BFA_IOIM_SM_QRESUME:
 437                 bfa_sm_set_state(ioim, bfa_ioim_sm_abort);
 438                 bfa_ioim_send_abort(ioim);
 439                 break;
 440
 441         case BFA_IOIM_SM_CLEANUP:
 442                 bfa_assert(ioim->iosp->abort_explicit == BFA_TRUE);
 443                 ioim->iosp->abort_explicit = BFA_FALSE;
 444                 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup_qfull);
 445                 break;
 446
 447         case BFA_IOIM_SM_COMP_GOOD:
 448         case BFA_IOIM_SM_COMP:
 449                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 450                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 451                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 452                               ioim);
 453                 break;
 454
 455         case BFA_IOIM_SM_DONE:
 456                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
 457                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 458                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_abort,
 459                               ioim);
 460                 break;
 461
 462         case BFA_IOIM_SM_HWFAIL:
 463                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 464                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 465                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 466                               ioim);
 467                 break;
 468
 469         default:
 470                 bfa_sm_fault(ioim->bfa, event);
 471         }
 472 }
 473
 474 /**
 475  *              Active IO is being cleaned up, waiting for room in request CQ.
 476  */
 477 static void
 478 bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 479 {
 480         bfa_trc(ioim->bfa, ioim->iotag);
 481         bfa_trc(ioim->bfa, event);
 482
 483         switch (event) {
 484         case BFA_IOIM_SM_QRESUME:
 485                 bfa_sm_set_state(ioim, bfa_ioim_sm_cleanup);
 486                 bfa_ioim_send_abort(ioim);
 487                 break;
 488
 489         case BFA_IOIM_SM_ABORT:
 490                 /**
 491                  * IO is alraedy being cleaned up implicitly
 492                  */
 493                 ioim->io_cbfn = __bfa_cb_ioim_abort;
 494                 break;
 495
 496         case BFA_IOIM_SM_COMP_GOOD:
 497         case BFA_IOIM_SM_COMP:
 498                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 499                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 500                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
 501                 bfa_ioim_notify_cleanup(ioim);
 502                 break;
 503
 504         case BFA_IOIM_SM_DONE:
 505                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb_free);
 506                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 507                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
 508                 bfa_ioim_notify_cleanup(ioim);
 509                 break;
 510
 511         case BFA_IOIM_SM_HWFAIL:
 512                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 513                 bfa_reqq_wcancel(&ioim->iosp->reqq_wait);
 514                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, __bfa_cb_ioim_failed,
 515                               ioim);
 516                 break;
 517
 518         default:
 519                 bfa_sm_fault(ioim->bfa, event);
 520         }
 521 }
 522
 523 /**
 524  * IO bfa callback is pending.
 525  */
 526 static void
 527 bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 528 {
 529         bfa_trc_fp(ioim->bfa, ioim->iotag);
 530         bfa_trc_fp(ioim->bfa, event);
 531
 532         switch (event) {
 533         case BFA_IOIM_SM_HCB:
 534                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
 535                 bfa_ioim_free(ioim);
 536                 bfa_cb_ioim_resfree(ioim->bfa->bfad);
 537                 break;
 538
 539         case BFA_IOIM_SM_CLEANUP:
 540                 bfa_ioim_notify_cleanup(ioim);
 541                 break;
 542
 543         case BFA_IOIM_SM_HWFAIL:
 544                 break;
 545
 546         default:
 547                 bfa_sm_fault(ioim->bfa, event);
 548         }
 549 }
 550
 551 /**
 552  * IO bfa callback is pending. IO resource cannot be freed.
 553  */
 554 static void
 555 bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 556 {
 557         bfa_trc(ioim->bfa, ioim->iotag);
 558         bfa_trc(ioim->bfa, event);
 559
 560         switch (event) {
 561         case BFA_IOIM_SM_HCB:
 562                 bfa_sm_set_state(ioim, bfa_ioim_sm_resfree);
 563                 list_del(&ioim->qe);
 564                 list_add_tail(&ioim->qe, &ioim->fcpim->ioim_resfree_q);
 565                 break;
 566
 567         case BFA_IOIM_SM_FREE:
 568                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 569                 break;
 570
 571         case BFA_IOIM_SM_CLEANUP:
 572                 bfa_ioim_notify_cleanup(ioim);
 573                 break;
 574
 575         case BFA_IOIM_SM_HWFAIL:
 576                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
 577                 break;
 578
 579         default:
 580                 bfa_sm_fault(ioim->bfa, event);
 581         }
 582 }
 583
 584 /**
 585  * IO is completed, waiting resource free from firmware.
 586  */
 587 static void
 588 bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 589 {
 590         bfa_trc(ioim->bfa, ioim->iotag);
 591         bfa_trc(ioim->bfa, event);
 592
 593         switch (event) {
 594         case BFA_IOIM_SM_FREE:
 595                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
 596                 bfa_ioim_free(ioim);
 597                 bfa_cb_ioim_resfree(ioim->bfa->bfad);
 598                 break;
 599
 600         case BFA_IOIM_SM_CLEANUP:
 601                 bfa_ioim_notify_cleanup(ioim);
 602                 break;
 603
 604         case BFA_IOIM_SM_HWFAIL:
 605                 break;
 606
 607         default:
 608                 bfa_sm_fault(ioim->bfa, event);
 609         }
 610 }
 611
 612
 613
 614 /**
 615  *  bfa_ioim_private
 616  */
 617
 618 static void
 619 __bfa_cb_ioim_good_comp(void *cbarg, bfa_boolean_t complete)
 620 {
 621         struct bfa_ioim_s *ioim = cbarg;
 622
 623         if (!complete) {
 624                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
 625                 return;
 626         }
 627
 628         bfa_cb_ioim_good_comp(ioim->bfa->bfad, ioim->dio);
 629 }
 630
 631 static void
 632 __bfa_cb_ioim_comp(void *cbarg, bfa_boolean_t complete)
 633 {
 634         struct bfa_ioim_s       *ioim = cbarg;
 635         struct bfi_ioim_rsp_s *m;
 636         u8              *snsinfo = NULL;
 637         u8         sns_len = 0;
 638         s32         residue = 0;
 639
 640         if (!complete) {
 641                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
 642                 return;
 643         }
 644
 645         m = (struct bfi_ioim_rsp_s *) &ioim->iosp->comp_rspmsg;
 646         if (m->io_status == BFI_IOIM_STS_OK) {
 647                 /**
 648                  * setup sense information, if present
 649                  */
 650                 if (m->scsi_status == SCSI_STATUS_CHECK_CONDITION
 651                                         && m->sns_len) {
 652                         sns_len = m->sns_len;
 653                         snsinfo = ioim->iosp->snsinfo;
 654                 }
 655
 656                 /**
 657                  * setup residue value correctly for normal completions
 658                  */
 659                 if (m->resid_flags == FCP_RESID_UNDER)
 660                         residue = bfa_os_ntohl(m->residue);
 661                 if (m->resid_flags == FCP_RESID_OVER) {
 662                         residue = bfa_os_ntohl(m->residue);
 663                         residue = -residue;
 664                 }
 665         }
 666
 667         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, m->io_status,
 668                           m->scsi_status, sns_len, snsinfo, residue);
 669 }
 670
 671 static void
 672 __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete)
 673 {
 674         struct bfa_ioim_s *ioim = cbarg;
 675
 676         if (!complete) {
 677                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
 678                 return;
 679         }
 680
 681         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_ABORTED,
 682                           0, 0, NULL, 0);
 683 }
 684
 685 static void
 686 __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete)
 687 {
 688         struct bfa_ioim_s *ioim = cbarg;
 689
 690         if (!complete) {
 691                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
 692                 return;
 693         }
 694
 695         bfa_cb_ioim_done(ioim->bfa->bfad, ioim->dio, BFI_IOIM_STS_PATHTOV,
 696                           0, 0, NULL, 0);
 697 }
 698
 699 static void
 700 __bfa_cb_ioim_abort(void *cbarg, bfa_boolean_t complete)
 701 {
 702         struct bfa_ioim_s *ioim = cbarg;
 703
 704         if (!complete) {
 705                 bfa_sm_send_event(ioim, BFA_IOIM_SM_HCB);
 706                 return;
 707         }
 708
 709         bfa_cb_ioim_abort(ioim->bfa->bfad, ioim->dio);
 710 }
 711
 712 static void
 713 bfa_ioim_sgpg_alloced(void *cbarg)
 714 {
 715         struct bfa_ioim_s *ioim = cbarg;
 716
 717         ioim->nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
 718         list_splice_tail_init(&ioim->iosp->sgpg_wqe.sgpg_q, &ioim->sgpg_q);
 719         bfa_ioim_sgpg_setup(ioim);
 720         bfa_sm_send_event(ioim, BFA_IOIM_SM_SGALLOCED);
 721 }
 722
 723 /**
 724  * Send I/O request to firmware.
 725  */
 726 static          bfa_boolean_t
 727 bfa_ioim_send_ioreq(struct bfa_ioim_s *ioim)
 728 {
 729         struct bfa_itnim_s *itnim = ioim->itnim;
 730         struct bfi_ioim_req_s *m;
 731         static struct fcp_cmnd_s cmnd_z0 = { 0 };
 732         struct bfi_sge_s      *sge;
 733         u32        pgdlen = 0;
 734         u64 addr;
 735         struct scatterlist *sg;
 736         struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
 737
 738         /**
 739          * check for room in queue to send request now
 740          */
 741         m = bfa_reqq_next(ioim->bfa, itnim->reqq);
 742         if (!m) {
 743                 bfa_reqq_wait(ioim->bfa, ioim->itnim->reqq,
 744                                   &ioim->iosp->reqq_wait);
 745                 return BFA_FALSE;
 746         }
 747
 748         /**
 749          * build i/o request message next
 750          */
 751         m->io_tag = bfa_os_htons(ioim->iotag);
 752         m->rport_hdl = ioim->itnim->rport->fw_handle;
 753         m->io_timeout = bfa_cb_ioim_get_timeout(ioim->dio);
 754
 755         /**
 756          * build inline IO SG element here
 757          */
 758         sge = &m->sges[0];
 759         if (ioim->nsges) {
 760                 sg = (struct scatterlist *)scsi_sglist(cmnd);
 761                 addr = bfa_os_sgaddr(sg_dma_address(sg));
 762                 sge->sga = *(union bfi_addr_u *) &addr;
 763                 pgdlen = sg_dma_len(sg);
 764                 sge->sg_len = pgdlen;
 765                 sge->flags = (ioim->nsges > BFI_SGE_INLINE) ?
 766                                         BFI_SGE_DATA_CPL : BFI_SGE_DATA_LAST;
 767                 bfa_sge_to_be(sge);
 768                 sge++;
 769         }
 770
 771         if (ioim->nsges > BFI_SGE_INLINE) {
 772                 sge->sga = ioim->sgpg->sgpg_pa;
 773         } else {
 774                 sge->sga.a32.addr_lo = 0;
 775                 sge->sga.a32.addr_hi = 0;
 776         }
 777         sge->sg_len = pgdlen;
 778         sge->flags = BFI_SGE_PGDLEN;
 779         bfa_sge_to_be(sge);
 780
 781         /**
 782          * set up I/O command parameters
 783          */
 784         bfa_os_assign(m->cmnd, cmnd_z0);
 785         m->cmnd.lun = bfa_cb_ioim_get_lun(ioim->dio);
 786         m->cmnd.iodir = bfa_cb_ioim_get_iodir(ioim->dio);
 787         bfa_os_assign(m->cmnd.cdb,
 788                         *(struct scsi_cdb_s *)bfa_cb_ioim_get_cdb(ioim->dio));
 789         m->cmnd.fcp_dl = bfa_os_htonl(bfa_cb_ioim_get_size(ioim->dio));
 790
 791         /**
 792          * set up I/O message header
 793          */
 794         switch (m->cmnd.iodir) {
 795         case FCP_IODIR_READ:
 796                 bfi_h2i_set(m->mh, BFI_MC_IOIM_READ, 0, bfa_lpuid(ioim->bfa));
 797                 bfa_stats(itnim, input_reqs);
 798                 break;
 799         case FCP_IODIR_WRITE:
 800                 bfi_h2i_set(m->mh, BFI_MC_IOIM_WRITE, 0, bfa_lpuid(ioim->bfa));
 801                 bfa_stats(itnim, output_reqs);
 802                 break;
 803         case FCP_IODIR_RW:
 804                 bfa_stats(itnim, input_reqs);
 805                 bfa_stats(itnim, output_reqs);
 806         default:
 807                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
 808         }
 809         if (itnim->seq_rec ||
 810             (bfa_cb_ioim_get_size(ioim->dio) & (sizeof(u32) - 1)))
 811                 bfi_h2i_set(m->mh, BFI_MC_IOIM_IO, 0, bfa_lpuid(ioim->bfa));
 812
 813 #ifdef IOIM_ADVANCED
 814         m->cmnd.crn = bfa_cb_ioim_get_crn(ioim->dio);
 815         m->cmnd.priority = bfa_cb_ioim_get_priority(ioim->dio);
 816         m->cmnd.taskattr = bfa_cb_ioim_get_taskattr(ioim->dio);
 817
 818         /**
 819          * Handle large CDB (>16 bytes).
 820          */
 821         m->cmnd.addl_cdb_len = (bfa_cb_ioim_get_cdblen(ioim->dio) -
 822                                         FCP_CMND_CDB_LEN) / sizeof(u32);
 823         if (m->cmnd.addl_cdb_len) {
 824                 bfa_os_memcpy(&m->cmnd.cdb + 1, (struct scsi_cdb_s *)
 825                                 bfa_cb_ioim_get_cdb(ioim->dio) + 1,
 826                                 m->cmnd.addl_cdb_len * sizeof(u32));
 827                 fcp_cmnd_fcpdl(&m->cmnd) =
 828                                 bfa_os_htonl(bfa_cb_ioim_get_size(ioim->dio));
 829         }
 830 #endif
 831
 832         /**
 833          * queue I/O message to firmware
 834          */
 835         bfa_reqq_produce(ioim->bfa, itnim->reqq);
 836         return BFA_TRUE;
 837 }
 838
 839 /**
 840  * Setup any additional SG pages needed.Inline SG element is setup
 841  * at queuing time.
 842  */
 843 static bfa_boolean_t
 844 bfa_ioim_sge_setup(struct bfa_ioim_s *ioim)
 845 {
 846         u16        nsgpgs;
 847
 848         bfa_assert(ioim->nsges > BFI_SGE_INLINE);
 849
 850         /**
 851          * allocate SG pages needed
 852          */
 853         nsgpgs = BFA_SGPG_NPAGE(ioim->nsges);
 854         if (!nsgpgs)
 855                 return BFA_TRUE;
 856
 857         if (bfa_sgpg_malloc(ioim->bfa, &ioim->sgpg_q, nsgpgs)
 858             != BFA_STATUS_OK) {
 859                 bfa_sgpg_wait(ioim->bfa, &ioim->iosp->sgpg_wqe, nsgpgs);
 860                 return BFA_FALSE;
 861         }
 862
 863         ioim->nsgpgs = nsgpgs;
 864         bfa_ioim_sgpg_setup(ioim);
 865
 866         return BFA_TRUE;
 867 }
 868
 869 static void
 870 bfa_ioim_sgpg_setup(struct bfa_ioim_s *ioim)
 871 {
 872         int             sgeid, nsges, i;
 873         struct bfi_sge_s      *sge;
 874         struct bfa_sgpg_s *sgpg;
 875         u32        pgcumsz;
 876         u64        addr;
 877         struct scatterlist *sg;
 878         struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;
 879
 880         sgeid = BFI_SGE_INLINE;
 881         ioim->sgpg = sgpg = bfa_q_first(&ioim->sgpg_q);
 882
 883         sg = scsi_sglist(cmnd);
 884         sg = sg_next(sg);
 885
 886         do {
 887                 sge = sgpg->sgpg->sges;
 888                 nsges = ioim->nsges - sgeid;
 889                 if (nsges > BFI_SGPG_DATA_SGES)
 890                         nsges = BFI_SGPG_DATA_SGES;
 891
 892                 pgcumsz = 0;
 893                 for (i = 0; i < nsges; i++, sge++, sgeid++, sg = sg_next(sg)) {
 894                         addr = bfa_os_sgaddr(sg_dma_address(sg));
 895                         sge->sga = *(union bfi_addr_u *) &addr;
 896                         sge->sg_len = sg_dma_len(sg);
 897                         pgcumsz += sge->sg_len;
 898
 899                         /**
 900                          * set flags
 901                          */
 902                         if (i < (nsges - 1))
 903                                 sge->flags = BFI_SGE_DATA;
 904                         else if (sgeid < (ioim->nsges - 1))
 905                                 sge->flags = BFI_SGE_DATA_CPL;
 906                         else
 907                                 sge->flags = BFI_SGE_DATA_LAST;
 908                 }
 909
 910                 sgpg = (struct bfa_sgpg_s *) bfa_q_next(sgpg);
 911
 912                 /**
 913                  * set the link element of each page
 914                  */
 915                 if (sgeid == ioim->nsges) {
 916                         sge->flags = BFI_SGE_PGDLEN;
 917                         sge->sga.a32.addr_lo = 0;
 918                         sge->sga.a32.addr_hi = 0;
 919                 } else {
 920                         sge->flags = BFI_SGE_LINK;
 921                         sge->sga = sgpg->sgpg_pa;
 922                 }
 923                 sge->sg_len = pgcumsz;
 924         } while (sgeid < ioim->nsges);
 925 }
 926
 927 /**
 928  * Send I/O abort request to firmware.
 929  */
 930 static          bfa_boolean_t
 931 bfa_ioim_send_abort(struct bfa_ioim_s *ioim)
 932 {
 933         struct bfa_itnim_s          *itnim = ioim->itnim;
 934         struct bfi_ioim_abort_req_s *m;
 935         enum bfi_ioim_h2i       msgop;
 936
 937         /**
 938          * check for room in queue to send request now
 939          */
 940         m = bfa_reqq_next(ioim->bfa, itnim->reqq);
 941         if (!m)
 942                 return BFA_FALSE;
 943
 944         /**
 945          * build i/o request message next
 946          */
 947         if (ioim->iosp->abort_explicit)
 948                 msgop = BFI_IOIM_H2I_IOABORT_REQ;
 949         else
 950                 msgop = BFI_IOIM_H2I_IOCLEANUP_REQ;
 951
 952         bfi_h2i_set(m->mh, BFI_MC_IOIM, msgop, bfa_lpuid(ioim->bfa));
 953         m->io_tag    = bfa_os_htons(ioim->iotag);
 954         m->abort_tag = ++ioim->abort_tag;
 955
 956         /**
 957          * queue I/O message to firmware
 958          */
 959         bfa_reqq_produce(ioim->bfa, itnim->reqq);
 960         return BFA_TRUE;
 961 }
 962
 963 /**
 964  * Call to resume any I/O requests waiting for room in request queue.
 965  */
 966 static void
 967 bfa_ioim_qresume(void *cbarg)
 968 {
 969         struct bfa_ioim_s *ioim = cbarg;
 970
 971         bfa_fcpim_stats(ioim->fcpim, qresumes);
 972         bfa_sm_send_event(ioim, BFA_IOIM_SM_QRESUME);
 973 }
 974
 975
 976 static void
 977 bfa_ioim_notify_cleanup(struct bfa_ioim_s *ioim)
 978 {
 979         /**
 980          * Move IO from itnim queue to fcpim global queue since itnim will be
 981          * freed.
 982          */
 983         list_del(&ioim->qe);
 984         list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
 985
 986         if (!ioim->iosp->tskim) {
 987                 if (ioim->fcpim->delay_comp && ioim->itnim->iotov_active) {
 988                         bfa_cb_dequeue(&ioim->hcb_qe);
 989                         list_del(&ioim->qe);
 990                         list_add_tail(&ioim->qe, &ioim->itnim->delay_comp_q);
 991                 }
 992                 bfa_itnim_iodone(ioim->itnim);
 993         } else
 994                 bfa_tskim_iodone(ioim->iosp->tskim);
 995 }
 996
 997 /**
 998  *                or after the link comes back.
 999  */
1000 void
1001 bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)
1002 {
1003         /**
1004          * If path tov timer expired, failback with PATHTOV status - these
1005          * IO requests are not normally retried by IO stack.
1006          *
1007          * Otherwise device cameback online and fail it with normal failed
1008          * status so that IO stack retries these failed IO requests.
1009          */
1010         if (iotov)
1011                 ioim->io_cbfn = __bfa_cb_ioim_pathtov;
1012         else
1013                 ioim->io_cbfn = __bfa_cb_ioim_failed;
1014
1015         bfa_cb_queue(ioim->bfa, &ioim->hcb_qe, ioim->io_cbfn, ioim);
1016
1017     /**
1018      * Move IO to fcpim global queue since itnim will be
1019      * freed.
1020      */
1021     list_del(&ioim->qe);
1022     list_add_tail(&ioim->qe, &ioim->fcpim->ioim_comp_q);
1023 }
1024
1025
1026
1027 /**
1028  *  bfa_ioim_friend
1029  */
1030
1031 /**
1032  * Memory allocation and initialization.
1033  */
1034 void
1035 bfa_ioim_attach(struct bfa_fcpim_mod_s *fcpim, struct bfa_meminfo_s *minfo)
1036 {
1037         struct bfa_ioim_s               *ioim;
1038         struct bfa_ioim_sp_s    *iosp;
1039         u16             i;
1040         u8                      *snsinfo;
1041         u32             snsbufsz;
1042
1043         /**
1044          * claim memory first
1045          */
1046         ioim = (struct bfa_ioim_s *) bfa_meminfo_kva(minfo);
1047         fcpim->ioim_arr = ioim;
1048         bfa_meminfo_kva(minfo) = (u8 *) (ioim + fcpim->num_ioim_reqs);
1049
1050         iosp = (struct bfa_ioim_sp_s *) bfa_meminfo_kva(minfo);
1051         fcpim->ioim_sp_arr = iosp;
1052         bfa_meminfo_kva(minfo) = (u8 *) (iosp + fcpim->num_ioim_reqs);
1053
1054         /**
1055          * Claim DMA memory for per IO sense data.
1056          */
1057         snsbufsz = fcpim->num_ioim_reqs * BFI_IOIM_SNSLEN;
1058         fcpim->snsbase.pa  = bfa_meminfo_dma_phys(minfo);
1059         bfa_meminfo_dma_phys(minfo) += snsbufsz;
1060
1061         fcpim->snsbase.kva = bfa_meminfo_dma_virt(minfo);
1062         bfa_meminfo_dma_virt(minfo) += snsbufsz;
1063         snsinfo = fcpim->snsbase.kva;
1064         bfa_iocfc_set_snsbase(fcpim->bfa, fcpim->snsbase.pa);
1065
1066         /**
1067          * Initialize ioim free queues
1068          */
1069         INIT_LIST_HEAD(&fcpim->ioim_free_q);
1070         INIT_LIST_HEAD(&fcpim->ioim_resfree_q);
1071         INIT_LIST_HEAD(&fcpim->ioim_comp_q);
1072
1073         for (i = 0; i < fcpim->num_ioim_reqs;
1074              i++, ioim++, iosp++, snsinfo += BFI_IOIM_SNSLEN) {
1075                 /*
1076                  * initialize IOIM
1077                  */
1078                 bfa_os_memset(ioim, 0, sizeof(struct bfa_ioim_s));
1079                 ioim->iotag   = i;
1080                 ioim->bfa     = fcpim->bfa;
1081                 ioim->fcpim   = fcpim;
1082                 ioim->iosp    = iosp;
1083                 iosp->snsinfo = snsinfo;
1084                 INIT_LIST_HEAD(&ioim->sgpg_q);
1085                 bfa_reqq_winit(&ioim->iosp->reqq_wait,
1086                                    bfa_ioim_qresume, ioim);
1087                 bfa_sgpg_winit(&ioim->iosp->sgpg_wqe,
1088                                    bfa_ioim_sgpg_alloced, ioim);
1089                 bfa_sm_set_state(ioim, bfa_ioim_sm_uninit);
1090
1091                 list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
1092         }
1093 }
1094
1095 /**
1096  * Driver detach time call.
1097  */
1098 void
1099 bfa_ioim_detach(struct bfa_fcpim_mod_s *fcpim)
1100 {
1101 }
1102
1103 void
1104 bfa_ioim_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1105 {
1106         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1107         struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
1108         struct bfa_ioim_s *ioim;
1109         u16        iotag;
1110         enum bfa_ioim_event evt = BFA_IOIM_SM_COMP;
1111
1112         iotag = bfa_os_ntohs(rsp->io_tag);
1113
1114         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
1115         bfa_assert(ioim->iotag == iotag);
1116
1117         bfa_trc(ioim->bfa, ioim->iotag);
1118         bfa_trc(ioim->bfa, rsp->io_status);
1119         bfa_trc(ioim->bfa, rsp->reuse_io_tag);
1120
1121         if (bfa_sm_cmp_state(ioim, bfa_ioim_sm_active))
1122                 bfa_os_assign(ioim->iosp->comp_rspmsg, *m);
1123
1124         switch (rsp->io_status) {
1125         case BFI_IOIM_STS_OK:
1126                 bfa_fcpim_stats(fcpim, iocomp_ok);
1127                 if (rsp->reuse_io_tag == 0)
1128                         evt = BFA_IOIM_SM_DONE;
1129                 else
1130                         evt = BFA_IOIM_SM_COMP;
1131                 break;
1132
1133         case BFI_IOIM_STS_TIMEDOUT:
1134         case BFI_IOIM_STS_ABORTED:
1135                 rsp->io_status = BFI_IOIM_STS_ABORTED;
1136                 bfa_fcpim_stats(fcpim, iocomp_aborted);
1137                 if (rsp->reuse_io_tag == 0)
1138                         evt = BFA_IOIM_SM_DONE;
1139                 else
1140                         evt = BFA_IOIM_SM_COMP;
1141                 break;
1142
1143         case BFI_IOIM_STS_PROTO_ERR:
1144                 bfa_fcpim_stats(fcpim, iocom_proto_err);
1145                 bfa_assert(rsp->reuse_io_tag);
1146                 evt = BFA_IOIM_SM_COMP;
1147                 break;
1148
1149         case BFI_IOIM_STS_SQER_NEEDED:
1150                 bfa_fcpim_stats(fcpim, iocom_sqer_needed);
1151                 bfa_assert(rsp->reuse_io_tag == 0);
1152                 evt = BFA_IOIM_SM_SQRETRY;
1153                 break;
1154
1155         case BFI_IOIM_STS_RES_FREE:
1156                 bfa_fcpim_stats(fcpim, iocom_res_free);
1157                 evt = BFA_IOIM_SM_FREE;
1158                 break;
1159
1160         case BFI_IOIM_STS_HOST_ABORTED:
1161                 bfa_fcpim_stats(fcpim, iocom_hostabrts);
1162                 if (rsp->abort_tag != ioim->abort_tag) {
1163                         bfa_trc(ioim->bfa, rsp->abort_tag);
1164                         bfa_trc(ioim->bfa, ioim->abort_tag);
1165                         return;
1166                 }
1167
1168                 if (rsp->reuse_io_tag)
1169                         evt = BFA_IOIM_SM_ABORT_COMP;
1170                 else
1171                         evt = BFA_IOIM_SM_ABORT_DONE;
1172                 break;
1173
1174         case BFI_IOIM_STS_UTAG:
1175                 bfa_fcpim_stats(fcpim, iocom_utags);
1176                 evt = BFA_IOIM_SM_COMP_UTAG;
1177                 break;
1178
1179         default:
1180                 bfa_assert(0);
1181         }
1182
1183         bfa_sm_send_event(ioim, evt);
1184 }
1185
1186 void
1187 bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
1188 {
1189         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1190         struct bfi_ioim_rsp_s *rsp = (struct bfi_ioim_rsp_s *) m;
1191         struct bfa_ioim_s *ioim;
1192         u16        iotag;
1193
1194         iotag = bfa_os_ntohs(rsp->io_tag);
1195
1196         ioim = BFA_IOIM_FROM_TAG(fcpim, iotag);
1197         bfa_assert(ioim->iotag == iotag);
1198
1199         bfa_trc_fp(ioim->bfa, ioim->iotag);
1200         bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);
1201 }
1202
1203 /**
1204  * Called by itnim to clean up IO while going offline.
1205  */
1206 void
1207 bfa_ioim_cleanup(struct bfa_ioim_s *ioim)
1208 {
1209         bfa_trc(ioim->bfa, ioim->iotag);
1210         bfa_fcpim_stats(ioim->fcpim, io_cleanups);
1211
1212         ioim->iosp->tskim = NULL;
1213         bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
1214 }
1215
1216 void
1217 bfa_ioim_cleanup_tm(struct bfa_ioim_s *ioim, struct bfa_tskim_s *tskim)
1218 {
1219         bfa_trc(ioim->bfa, ioim->iotag);
1220         bfa_fcpim_stats(ioim->fcpim, io_tmaborts);
1221
1222         ioim->iosp->tskim = tskim;
1223         bfa_sm_send_event(ioim, BFA_IOIM_SM_CLEANUP);
1224 }
1225
1226 /**
1227  * IOC failure handling.
1228  */
1229 void
1230 bfa_ioim_iocdisable(struct bfa_ioim_s *ioim)
1231 {
1232         bfa_sm_send_event(ioim, BFA_IOIM_SM_HWFAIL);
1233 }
1234
1235 /**
1236  * IO offline TOV popped. Fail the pending IO.
1237  */
1238 void
1239 bfa_ioim_tov(struct bfa_ioim_s *ioim)
1240 {
1241         bfa_sm_send_event(ioim, BFA_IOIM_SM_IOTOV);
1242 }
1243
1244
1245
1246 /**
1247  *  bfa_ioim_api
1248  */
1249
1250 /**
1251  * Allocate IOIM resource for initiator mode I/O request.
1252  */
1253 struct bfa_ioim_s *
1254 bfa_ioim_alloc(struct bfa_s *bfa, struct bfad_ioim_s *dio,
1255                 struct bfa_itnim_s *itnim, u16 nsges)
1256 {
1257         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
1258         struct bfa_ioim_s *ioim;
1259
1260         /**
1261          * alocate IOIM resource
1262          */
1263         bfa_q_deq(&fcpim->ioim_free_q, &ioim);
1264         if (!ioim) {
1265                 bfa_fcpim_stats(fcpim, no_iotags);
1266                 return NULL;
1267         }
1268
1269         ioim->dio = dio;
1270         ioim->itnim = itnim;
1271         ioim->nsges = nsges;
1272         ioim->nsgpgs = 0;
1273
1274         bfa_stats(fcpim, total_ios);
1275         bfa_stats(itnim, ios);
1276         fcpim->ios_active++;
1277
1278         list_add_tail(&ioim->qe, &itnim->io_q);
1279         bfa_trc_fp(ioim->bfa, ioim->iotag);
1280
1281         return ioim;
1282 }
1283
1284 void
1285 bfa_ioim_free(struct bfa_ioim_s *ioim)
1286 {
1287         struct bfa_fcpim_mod_s *fcpim = ioim->fcpim;
1288
1289         bfa_trc_fp(ioim->bfa, ioim->iotag);
1290         bfa_assert_fp(bfa_sm_cmp_state(ioim, bfa_ioim_sm_uninit));
1291
1292         bfa_assert_fp(list_empty(&ioim->sgpg_q)
1293                    || (ioim->nsges > BFI_SGE_INLINE));
1294
1295         if (ioim->nsgpgs > 0)
1296                 bfa_sgpg_mfree(ioim->bfa, &ioim->sgpg_q, ioim->nsgpgs);
1297
1298         bfa_stats(ioim->itnim, io_comps);
1299         fcpim->ios_active--;
1300
1301         list_del(&ioim->qe);
1302         list_add_tail(&ioim->qe, &fcpim->ioim_free_q);
1303 }
1304
1305 void
1306 bfa_ioim_start(struct bfa_ioim_s *ioim)
1307 {
1308         bfa_trc_fp(ioim->bfa, ioim->iotag);
1309         bfa_sm_send_event(ioim, BFA_IOIM_SM_START);
1310 }
1311
1312 /**
1313  * Driver I/O abort request.
1314  */
1315 void
1316 bfa_ioim_abort(struct bfa_ioim_s *ioim)
1317 {
1318         bfa_trc(ioim->bfa, ioim->iotag);
1319         bfa_fcpim_stats(ioim->fcpim, io_aborts);
1320         bfa_sm_send_event(ioim, BFA_IOIM_SM_ABORT);
1321 }
1322
1323