kernel/drivers/scsi/bfa/bfa_fcs_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 /*
  19  *  fcpim.c - FCP initiator mode i-t nexus state machine
  20  */
  21
  22 #include "bfad_drv.h"
  23 #include "bfa_fcs.h"
  24 #include "bfa_fcbuild.h"
  25 #include "bfad_im.h"
  26
  27 BFA_TRC_FILE(FCS, FCPIM);
  28
  29 /*
  30  * forward declarations
  31  */
  32 static void     bfa_fcs_itnim_timeout(void *arg);
  33 static void     bfa_fcs_itnim_free(struct bfa_fcs_itnim_s *itnim);
  34 static void     bfa_fcs_itnim_send_prli(void *itnim_cbarg,
  35                                         struct bfa_fcxp_s *fcxp_alloced);
  36 static void     bfa_fcs_itnim_prli_response(void *fcsarg,
  37                          struct bfa_fcxp_s *fcxp, void *cbarg,
  38                             bfa_status_t req_status, u32 rsp_len,
  39                             u32 resid_len, struct fchs_s *rsp_fchs);
  40 static void     bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
  41                         enum bfa_itnim_aen_event event);
  42
  43 static void     bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
  44                                          enum bfa_fcs_itnim_event event);
  45 static void     bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
  46                                            enum bfa_fcs_itnim_event event);
  47 static void     bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
  48                                       enum bfa_fcs_itnim_event event);
  49 static void     bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
  50                                             enum bfa_fcs_itnim_event event);
  51 static void     bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
  52                                             enum bfa_fcs_itnim_event event);
  53 static void     bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
  54                                         enum bfa_fcs_itnim_event event);
  55 static void     bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
  56                                         enum bfa_fcs_itnim_event event);
  57 static void     bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
  58                                              enum bfa_fcs_itnim_event event);
  59 static void     bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
  60                                            enum bfa_fcs_itnim_event event);
  61
  62 static struct bfa_sm_table_s itnim_sm_table[] = {
  63         {BFA_SM(bfa_fcs_itnim_sm_offline), BFA_ITNIM_OFFLINE},
  64         {BFA_SM(bfa_fcs_itnim_sm_prli_send), BFA_ITNIM_PRLI_SEND},
  65         {BFA_SM(bfa_fcs_itnim_sm_prli), BFA_ITNIM_PRLI_SENT},
  66         {BFA_SM(bfa_fcs_itnim_sm_prli_retry), BFA_ITNIM_PRLI_RETRY},
  67         {BFA_SM(bfa_fcs_itnim_sm_hcb_online), BFA_ITNIM_HCB_ONLINE},
  68         {BFA_SM(bfa_fcs_itnim_sm_online), BFA_ITNIM_ONLINE},
  69         {BFA_SM(bfa_fcs_itnim_sm_hcb_offline), BFA_ITNIM_HCB_OFFLINE},
  70         {BFA_SM(bfa_fcs_itnim_sm_initiator), BFA_ITNIM_INITIATIOR},
  71 };
  72
  73 /*
  74  *  fcs_itnim_sm FCS itnim state machine
  75  */
  76
  77 static void
  78 bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
  79                  enum bfa_fcs_itnim_event event)
  80 {
  81         bfa_trc(itnim->fcs, itnim->rport->pwwn);
  82         bfa_trc(itnim->fcs, event);
  83
  84         switch (event) {
  85         case BFA_FCS_ITNIM_SM_FCS_ONLINE:
  86                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_send);
  87                 itnim->prli_retries = 0;
  88                 bfa_fcs_itnim_send_prli(itnim, NULL);
  89                 break;
  90
  91         case BFA_FCS_ITNIM_SM_OFFLINE:
  92                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
  93                 break;
  94
  95         case BFA_FCS_ITNIM_SM_INITIATOR:
  96                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
  97                 break;
  98
  99         case BFA_FCS_ITNIM_SM_DELETE:
 100                 bfa_fcs_itnim_free(itnim);
 101                 break;
 102
 103         default:
 104                 bfa_sm_fault(itnim->fcs, event);
 105         }
 106
 107 }
 108
 109 static void
 110 bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
 111                  enum bfa_fcs_itnim_event event)
 112 {
 113         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 114         bfa_trc(itnim->fcs, event);
 115
 116         switch (event) {
 117         case BFA_FCS_ITNIM_SM_FRMSENT:
 118                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli);
 119                 break;
 120
 121         case BFA_FCS_ITNIM_SM_INITIATOR:
 122                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
 123                 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
 124                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
 125                 break;
 126
 127         case BFA_FCS_ITNIM_SM_OFFLINE:
 128                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 129                 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
 130                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 131                 break;
 132
 133         case BFA_FCS_ITNIM_SM_DELETE:
 134                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 135                 bfa_fcxp_walloc_cancel(itnim->fcs->bfa, &itnim->fcxp_wqe);
 136                 bfa_fcs_itnim_free(itnim);
 137                 break;
 138
 139         default:
 140                 bfa_sm_fault(itnim->fcs, event);
 141         }
 142 }
 143
 144 static void
 145 bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
 146                  enum bfa_fcs_itnim_event event)
 147 {
 148         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 149         bfa_trc(itnim->fcs, event);
 150
 151         switch (event) {
 152         case BFA_FCS_ITNIM_SM_RSP_OK:
 153                 if (itnim->rport->scsi_function == BFA_RPORT_INITIATOR)
 154                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
 155                 else
 156                         bfa_sm_set_state(itnim,
 157                                 bfa_fcs_itnim_sm_hal_rport_online);
 158
 159                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
 160                 break;
 161
 162         case BFA_FCS_ITNIM_SM_RSP_ERROR:
 163                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_retry);
 164                 bfa_timer_start(itnim->fcs->bfa, &itnim->timer,
 165                                 bfa_fcs_itnim_timeout, itnim,
 166                                 BFA_FCS_RETRY_TIMEOUT);
 167                 break;
 168
 169         case BFA_FCS_ITNIM_SM_RSP_NOT_SUPP:
 170                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 171                 break;
 172
 173         case BFA_FCS_ITNIM_SM_OFFLINE:
 174                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 175                 bfa_fcxp_discard(itnim->fcxp);
 176                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 177                 break;
 178
 179         case BFA_FCS_ITNIM_SM_INITIATOR:
 180                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
 181                 bfa_fcxp_discard(itnim->fcxp);
 182                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
 183                 break;
 184
 185         case BFA_FCS_ITNIM_SM_DELETE:
 186                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 187                 bfa_fcxp_discard(itnim->fcxp);
 188                 bfa_fcs_itnim_free(itnim);
 189                 break;
 190
 191         default:
 192                 bfa_sm_fault(itnim->fcs, event);
 193         }
 194 }
 195
 196 static void
 197 bfa_fcs_itnim_sm_hal_rport_online(struct bfa_fcs_itnim_s *itnim,
 198                                 enum bfa_fcs_itnim_event event)
 199 {
 200         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 201         bfa_trc(itnim->fcs, event);
 202
 203         switch (event) {
 204         case BFA_FCS_ITNIM_SM_HAL_ONLINE:
 205                 if (!itnim->bfa_itnim)
 206                         itnim->bfa_itnim = bfa_itnim_create(itnim->fcs->bfa,
 207                                         itnim->rport->bfa_rport, itnim);
 208
 209                 if (itnim->bfa_itnim) {
 210                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_online);
 211                         bfa_itnim_online(itnim->bfa_itnim, itnim->seq_rec);
 212                 } else {
 213                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 214                         bfa_sm_send_event(itnim->rport, RPSM_EVENT_DELETE);
 215                 }
 216
 217                 break;
 218
 219         case BFA_FCS_ITNIM_SM_OFFLINE:
 220                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 221                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 222                 break;
 223
 224         case BFA_FCS_ITNIM_SM_DELETE:
 225                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 226                 bfa_fcs_itnim_free(itnim);
 227                 break;
 228
 229         default:
 230                 bfa_sm_fault(itnim->fcs, event);
 231         }
 232 }
 233
 234 static void
 235 bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
 236                             enum bfa_fcs_itnim_event event)
 237 {
 238         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 239         bfa_trc(itnim->fcs, event);
 240
 241         switch (event) {
 242         case BFA_FCS_ITNIM_SM_TIMEOUT:
 243                 if (itnim->prli_retries < BFA_FCS_RPORT_MAX_RETRIES) {
 244                         itnim->prli_retries++;
 245                         bfa_trc(itnim->fcs, itnim->prli_retries);
 246                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_prli_send);
 247                         bfa_fcs_itnim_send_prli(itnim, NULL);
 248                 } else {
 249                         /* invoke target offline */
 250                         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 251                         bfa_sm_send_event(itnim->rport, RPSM_EVENT_LOGO_IMP);
 252                 }
 253                 break;
 254
 255
 256         case BFA_FCS_ITNIM_SM_OFFLINE:
 257                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 258                 bfa_timer_stop(&itnim->timer);
 259                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 260                 break;
 261
 262         case BFA_FCS_ITNIM_SM_INITIATOR:
 263                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_initiator);
 264                 bfa_timer_stop(&itnim->timer);
 265                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
 266                 break;
 267
 268         case BFA_FCS_ITNIM_SM_DELETE:
 269                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 270                 bfa_timer_stop(&itnim->timer);
 271                 bfa_fcs_itnim_free(itnim);
 272                 break;
 273
 274         default:
 275                 bfa_sm_fault(itnim->fcs, event);
 276         }
 277 }
 278
 279 static void
 280 bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
 281                             enum bfa_fcs_itnim_event event)
 282 {
 283         struct bfad_s *bfad = (struct bfad_s *)itnim->fcs->bfad;
 284         char    lpwwn_buf[BFA_STRING_32];
 285         char    rpwwn_buf[BFA_STRING_32];
 286
 287         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 288         bfa_trc(itnim->fcs, event);
 289
 290         switch (event) {
 291         case BFA_FCS_ITNIM_SM_HCB_ONLINE:
 292                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_online);
 293                 bfa_fcb_itnim_online(itnim->itnim_drv);
 294                 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(itnim->rport->port));
 295                 wwn2str(rpwwn_buf, itnim->rport->pwwn);
 296                 BFA_LOG(KERN_INFO, bfad, bfa_log_level,
 297                 "Target (WWN = %s) is online for initiator (WWN = %s)\n",
 298                 rpwwn_buf, lpwwn_buf);
 299                 bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_ONLINE);
 300                 break;
 301
 302         case BFA_FCS_ITNIM_SM_OFFLINE:
 303                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline);
 304                 bfa_itnim_offline(itnim->bfa_itnim);
 305                 break;
 306
 307         case BFA_FCS_ITNIM_SM_DELETE:
 308                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 309                 bfa_fcs_itnim_free(itnim);
 310                 break;
 311
 312         default:
 313                 bfa_sm_fault(itnim->fcs, event);
 314         }
 315 }
 316
 317 static void
 318 bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
 319                  enum bfa_fcs_itnim_event event)
 320 {
 321         struct bfad_s *bfad = (struct bfad_s *)itnim->fcs->bfad;
 322         char    lpwwn_buf[BFA_STRING_32];
 323         char    rpwwn_buf[BFA_STRING_32];
 324
 325         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 326         bfa_trc(itnim->fcs, event);
 327
 328         switch (event) {
 329         case BFA_FCS_ITNIM_SM_OFFLINE:
 330                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline);
 331                 bfa_fcb_itnim_offline(itnim->itnim_drv);
 332                 bfa_itnim_offline(itnim->bfa_itnim);
 333                 wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(itnim->rport->port));
 334                 wwn2str(rpwwn_buf, itnim->rport->pwwn);
 335                 if (bfa_fcs_lport_is_online(itnim->rport->port) == BFA_TRUE) {
 336                         BFA_LOG(KERN_ERR, bfad, bfa_log_level,
 337                         "Target (WWN = %s) connectivity lost for "
 338                         "initiator (WWN = %s)\n", rpwwn_buf, lpwwn_buf);
 339                         bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_DISCONNECT);
 340                 } else {
 341                         BFA_LOG(KERN_INFO, bfad, bfa_log_level,
 342                         "Target (WWN = %s) offlined by initiator (WWN = %s)\n",
 343                         rpwwn_buf, lpwwn_buf);
 344                         bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_OFFLINE);
 345                 }
 346                 break;
 347
 348         case BFA_FCS_ITNIM_SM_DELETE:
 349                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 350                 bfa_fcs_itnim_free(itnim);
 351                 break;
 352
 353         default:
 354                 bfa_sm_fault(itnim->fcs, event);
 355         }
 356 }
 357
 358 static void
 359 bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
 360                              enum bfa_fcs_itnim_event event)
 361 {
 362         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 363         bfa_trc(itnim->fcs, event);
 364
 365         switch (event) {
 366         case BFA_FCS_ITNIM_SM_HCB_OFFLINE:
 367                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 368                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 369                 break;
 370
 371         case BFA_FCS_ITNIM_SM_DELETE:
 372                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 373                 bfa_fcs_itnim_free(itnim);
 374                 break;
 375
 376         default:
 377                 bfa_sm_fault(itnim->fcs, event);
 378         }
 379 }
 380
 381 /*
 382  * This state is set when a discovered rport is also in intiator mode.
 383  * This ITN is marked as no_op and is not active and will not be truned into
 384  * online state.
 385  */
 386 static void
 387 bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
 388                  enum bfa_fcs_itnim_event event)
 389 {
 390         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 391         bfa_trc(itnim->fcs, event);
 392
 393         switch (event) {
 394         case BFA_FCS_ITNIM_SM_OFFLINE:
 395                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 396                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_OFFLINE);
 397                 break;
 398
 399         /*
 400          * fcs_online is expected here for well known initiator ports
 401          */
 402         case BFA_FCS_ITNIM_SM_FCS_ONLINE:
 403                 bfa_sm_send_event(itnim->rport, RPSM_EVENT_FC4_FCS_ONLINE);
 404                 break;
 405
 406         case BFA_FCS_ITNIM_SM_RSP_ERROR:
 407         case BFA_FCS_ITNIM_SM_INITIATOR:
 408                 break;
 409
 410         case BFA_FCS_ITNIM_SM_DELETE:
 411                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 412                 bfa_fcs_itnim_free(itnim);
 413                 break;
 414
 415         default:
 416                 bfa_sm_fault(itnim->fcs, event);
 417         }
 418 }
 419
 420 static void
 421 bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
 422                         enum bfa_itnim_aen_event event)
 423 {
 424         struct bfa_fcs_rport_s *rport = itnim->rport;
 425         struct bfad_s *bfad = (struct bfad_s *)itnim->fcs->bfad;
 426         struct bfa_aen_entry_s  *aen_entry;
 427
 428         /* Don't post events for well known addresses */
 429         if (BFA_FCS_PID_IS_WKA(rport->pid))
 430                 return;
 431
 432         bfad_get_aen_entry(bfad, aen_entry);
 433         if (!aen_entry)
 434                 return;
 435
 436         aen_entry->aen_data.itnim.vf_id = rport->port->fabric->vf_id;
 437         aen_entry->aen_data.itnim.ppwwn = bfa_fcs_lport_get_pwwn(
 438                                         bfa_fcs_get_base_port(itnim->fcs));
 439         aen_entry->aen_data.itnim.lpwwn = bfa_fcs_lport_get_pwwn(rport->port);
 440         aen_entry->aen_data.itnim.rpwwn = rport->pwwn;
 441
 442         /* Send the AEN notification */
 443         bfad_im_post_vendor_event(aen_entry, bfad, ++rport->fcs->fcs_aen_seq,
 444                                   BFA_AEN_CAT_ITNIM, event);
 445 }
 446
 447 static void
 448 bfa_fcs_itnim_send_prli(void *itnim_cbarg, struct bfa_fcxp_s *fcxp_alloced)
 449 {
 450         struct bfa_fcs_itnim_s *itnim = itnim_cbarg;
 451         struct bfa_fcs_rport_s *rport = itnim->rport;
 452         struct bfa_fcs_lport_s *port = rport->port;
 453         struct fchs_s   fchs;
 454         struct bfa_fcxp_s *fcxp;
 455         int             len;
 456
 457         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 458
 459         fcxp = fcxp_alloced ? fcxp_alloced :
 460                bfa_fcs_fcxp_alloc(port->fcs, BFA_TRUE);
 461         if (!fcxp) {
 462                 itnim->stats.fcxp_alloc_wait++;
 463                 bfa_fcs_fcxp_alloc_wait(port->fcs->bfa, &itnim->fcxp_wqe,
 464                                 bfa_fcs_itnim_send_prli, itnim, BFA_TRUE);
 465                 return;
 466         }
 467         itnim->fcxp = fcxp;
 468
 469         len = fc_prli_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
 470                             itnim->rport->pid, bfa_fcs_lport_get_fcid(port), 0);
 471
 472         bfa_fcxp_send(fcxp, rport->bfa_rport, port->fabric->vf_id, port->lp_tag,
 473                       BFA_FALSE, FC_CLASS_3, len, &fchs,
 474                       bfa_fcs_itnim_prli_response, (void *)itnim,
 475                       FC_MAX_PDUSZ, FC_ELS_TOV);
 476
 477         itnim->stats.prli_sent++;
 478         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_FRMSENT);
 479 }
 480
 481 static void
 482 bfa_fcs_itnim_prli_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
 483                             bfa_status_t req_status, u32 rsp_len,
 484                             u32 resid_len, struct fchs_s *rsp_fchs)
 485 {
 486         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cbarg;
 487         struct fc_els_cmd_s *els_cmd;
 488         struct fc_prli_s *prli_resp;
 489         struct fc_ls_rjt_s *ls_rjt;
 490         struct fc_prli_params_s *sparams;
 491
 492         bfa_trc(itnim->fcs, req_status);
 493
 494         /*
 495          * Sanity Checks
 496          */
 497         if (req_status != BFA_STATUS_OK) {
 498                 itnim->stats.prli_rsp_err++;
 499                 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_RSP_ERROR);
 500                 return;
 501         }
 502
 503         els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
 504
 505         if (els_cmd->els_code == FC_ELS_ACC) {
 506                 prli_resp = (struct fc_prli_s *) els_cmd;
 507
 508                 if (fc_prli_rsp_parse(prli_resp, rsp_len) != FC_PARSE_OK) {
 509                         bfa_trc(itnim->fcs, rsp_len);
 510                         /*
 511                          * Check if this  r-port is also in Initiator mode.
 512                          * If so, we need to set this ITN as a no-op.
 513                          */
 514                         if (prli_resp->parampage.servparams.initiator) {
 515                                 bfa_trc(itnim->fcs, prli_resp->parampage.type);
 516                                 itnim->rport->scsi_function =
 517                                                 BFA_RPORT_INITIATOR;
 518                                 itnim->stats.prli_rsp_acc++;
 519                                 itnim->stats.initiator++;
 520                                 bfa_sm_send_event(itnim,
 521                                                   BFA_FCS_ITNIM_SM_RSP_OK);
 522                                 return;
 523                         }
 524
 525                         itnim->stats.prli_rsp_parse_err++;
 526                         return;
 527                 }
 528                 itnim->rport->scsi_function = BFA_RPORT_TARGET;
 529
 530                 sparams = &prli_resp->parampage.servparams;
 531                 itnim->seq_rec       = sparams->retry;
 532                 itnim->rec_support   = sparams->rec_support;
 533                 itnim->task_retry_id = sparams->task_retry_id;
 534                 itnim->conf_comp     = sparams->confirm;
 535
 536                 itnim->stats.prli_rsp_acc++;
 537                 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_RSP_OK);
 538         } else {
 539                 ls_rjt = (struct fc_ls_rjt_s *) BFA_FCXP_RSP_PLD(fcxp);
 540
 541                 bfa_trc(itnim->fcs, ls_rjt->reason_code);
 542                 bfa_trc(itnim->fcs, ls_rjt->reason_code_expl);
 543
 544                 itnim->stats.prli_rsp_rjt++;
 545                 if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP) {
 546                         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_RSP_NOT_SUPP);
 547                         return;
 548                 }
 549                 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_RSP_ERROR);
 550         }
 551 }
 552
 553 static void
 554 bfa_fcs_itnim_timeout(void *arg)
 555 {
 556         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) arg;
 557
 558         itnim->stats.timeout++;
 559         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_TIMEOUT);
 560 }
 561
 562 static void
 563 bfa_fcs_itnim_free(struct bfa_fcs_itnim_s *itnim)
 564 {
 565         if (itnim->bfa_itnim) {
 566                 bfa_itnim_delete(itnim->bfa_itnim);
 567                 itnim->bfa_itnim = NULL;
 568         }
 569
 570         bfa_fcb_itnim_free(itnim->fcs->bfad, itnim->itnim_drv);
 571 }
 572
 573
 574
 575 /*
 576  *  itnim_public FCS ITNIM public interfaces
 577  */
 578
 579 /*
 580  *      Called by rport when a new rport is created.
 581  *
 582  * @param[in] rport     -  remote port.
 583  */
 584 struct bfa_fcs_itnim_s *
 585 bfa_fcs_itnim_create(struct bfa_fcs_rport_s *rport)
 586 {
 587         struct bfa_fcs_lport_s *port = rport->port;
 588         struct bfa_fcs_itnim_s *itnim;
 589         struct bfad_itnim_s   *itnim_drv;
 590
 591         /*
 592          * call bfad to allocate the itnim
 593          */
 594         bfa_fcb_itnim_alloc(port->fcs->bfad, &itnim, &itnim_drv);
 595         if (itnim == NULL) {
 596                 bfa_trc(port->fcs, rport->pwwn);
 597                 return NULL;
 598         }
 599
 600         /*
 601          * Initialize itnim
 602          */
 603         itnim->rport = rport;
 604         itnim->fcs = rport->fcs;
 605         itnim->itnim_drv = itnim_drv;
 606
 607         itnim->bfa_itnim     = NULL;
 608         itnim->seq_rec       = BFA_FALSE;
 609         itnim->rec_support   = BFA_FALSE;
 610         itnim->conf_comp     = BFA_FALSE;
 611         itnim->task_retry_id = BFA_FALSE;
 612
 613         /*
 614          * Set State machine
 615          */
 616         bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_offline);
 617
 618         return itnim;
 619 }
 620
 621 /*
 622  *      Called by rport to delete  the instance of FCPIM.
 623  *
 624  * @param[in] rport     -  remote port.
 625  */
 626 void
 627 bfa_fcs_itnim_delete(struct bfa_fcs_itnim_s *itnim)
 628 {
 629         bfa_trc(itnim->fcs, itnim->rport->pid);
 630         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_DELETE);
 631 }
 632
 633 /*
 634  * Notification from rport that PLOGI is complete to initiate FC-4 session.
 635  */
 636 void
 637 bfa_fcs_itnim_brp_online(struct bfa_fcs_itnim_s *itnim)
 638 {
 639         itnim->stats.onlines++;
 640
 641         if (!BFA_FCS_PID_IS_WKA(itnim->rport->pid))
 642                 bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_HAL_ONLINE);
 643 }
 644
 645 /*
 646  * Called by rport to handle a remote device offline.
 647  */
 648 void
 649 bfa_fcs_itnim_rport_offline(struct bfa_fcs_itnim_s *itnim)
 650 {
 651         itnim->stats.offlines++;
 652         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_OFFLINE);
 653 }
 654
 655 /*
 656  * Called by rport when remote port is known to be an initiator from
 657  * PRLI received.
 658  */
 659 void
 660 bfa_fcs_itnim_is_initiator(struct bfa_fcs_itnim_s *itnim)
 661 {
 662         bfa_trc(itnim->fcs, itnim->rport->pid);
 663         itnim->stats.initiator++;
 664         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_INITIATOR);
 665 }
 666
 667 /*
 668  * Called by rport to check if the itnim is online.
 669  */
 670 bfa_status_t
 671 bfa_fcs_itnim_get_online_state(struct bfa_fcs_itnim_s *itnim)
 672 {
 673         bfa_trc(itnim->fcs, itnim->rport->pid);
 674         switch (bfa_sm_to_state(itnim_sm_table, itnim->sm)) {
 675         case BFA_ITNIM_ONLINE:
 676         case BFA_ITNIM_INITIATIOR:
 677                 return BFA_STATUS_OK;
 678
 679         default:
 680                 return BFA_STATUS_NO_FCPIM_NEXUS;
 681         }
 682 }
 683
 684 /*
 685  * BFA completion callback for bfa_itnim_online().
 686  */
 687 void
 688 bfa_cb_itnim_online(void *cbarg)
 689 {
 690         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cbarg;
 691
 692         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 693         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_HCB_ONLINE);
 694 }
 695
 696 /*
 697  * BFA completion callback for bfa_itnim_offline().
 698  */
 699 void
 700 bfa_cb_itnim_offline(void *cb_arg)
 701 {
 702         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cb_arg;
 703
 704         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 705         bfa_sm_send_event(itnim, BFA_FCS_ITNIM_SM_HCB_OFFLINE);
 706 }
 707
 708 /*
 709  * Mark the beginning of PATH TOV handling. IO completion callbacks
 710  * are still pending.
 711  */
 712 void
 713 bfa_cb_itnim_tov_begin(void *cb_arg)
 714 {
 715         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cb_arg;
 716
 717         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 718 }
 719
 720 /*
 721  * Mark the end of PATH TOV handling. All pending IOs are already cleaned up.
 722  */
 723 void
 724 bfa_cb_itnim_tov(void *cb_arg)
 725 {
 726         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cb_arg;
 727         struct bfad_itnim_s *itnim_drv = itnim->itnim_drv;
 728
 729         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 730         itnim_drv->state = ITNIM_STATE_TIMEOUT;
 731 }
 732
 733 /*
 734  *              BFA notification to FCS/driver for second level error recovery.
 735  *
 736  * Atleast one I/O request has timedout and target is unresponsive to
 737  * repeated abort requests. Second level error recovery should be initiated
 738  * by starting implicit logout and recovery procedures.
 739  */
 740 void
 741 bfa_cb_itnim_sler(void *cb_arg)
 742 {
 743         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *) cb_arg;
 744
 745         itnim->stats.sler++;
 746         bfa_trc(itnim->fcs, itnim->rport->pwwn);
 747         bfa_sm_send_event(itnim->rport, RPSM_EVENT_LOGO_IMP);
 748 }
 749
 750 struct bfa_fcs_itnim_s *
 751 bfa_fcs_itnim_lookup(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
 752 {
 753         struct bfa_fcs_rport_s *rport;
 754         rport = bfa_fcs_rport_lookup(port, rpwwn);
 755
 756         if (!rport)
 757                 return NULL;
 758
 759         WARN_ON(rport->itnim == NULL);
 760         return rport->itnim;
 761 }
 762
 763 bfa_status_t
 764 bfa_fcs_itnim_attr_get(struct bfa_fcs_lport_s *port, wwn_t rpwwn,
 765                        struct bfa_itnim_attr_s *attr)
 766 {
 767         struct bfa_fcs_itnim_s *itnim = NULL;
 768
 769         itnim = bfa_fcs_itnim_lookup(port, rpwwn);
 770
 771         if (itnim == NULL)
 772                 return BFA_STATUS_NO_FCPIM_NEXUS;
 773
 774         attr->state         = bfa_sm_to_state(itnim_sm_table, itnim->sm);
 775         attr->retry         = itnim->seq_rec;
 776         attr->rec_support   = itnim->rec_support;
 777         attr->conf_comp     = itnim->conf_comp;
 778         attr->task_retry_id = itnim->task_retry_id;
 779         return BFA_STATUS_OK;
 780 }
 781
 782 bfa_status_t
 783 bfa_fcs_itnim_stats_get(struct bfa_fcs_lport_s *port, wwn_t rpwwn,
 784                         struct bfa_itnim_stats_s *stats)
 785 {
 786         struct bfa_fcs_itnim_s *itnim = NULL;
 787
 788         WARN_ON(port == NULL);
 789
 790         itnim = bfa_fcs_itnim_lookup(port, rpwwn);
 791
 792         if (itnim == NULL)
 793                 return BFA_STATUS_NO_FCPIM_NEXUS;
 794
 795         memcpy(stats, &itnim->stats, sizeof(struct bfa_itnim_stats_s));
 796
 797         return BFA_STATUS_OK;
 798 }
 799
 800 bfa_status_t
 801 bfa_fcs_itnim_stats_clear(struct bfa_fcs_lport_s *port, wwn_t rpwwn)
 802 {
 803         struct bfa_fcs_itnim_s *itnim = NULL;
 804
 805         WARN_ON(port == NULL);
 806
 807         itnim = bfa_fcs_itnim_lookup(port, rpwwn);
 808
 809         if (itnim == NULL)
 810                 return BFA_STATUS_NO_FCPIM_NEXUS;
 811
 812         memset(&itnim->stats, 0, sizeof(struct bfa_itnim_stats_s));
 813         return BFA_STATUS_OK;
 814 }
 815
 816 void
 817 bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim,
 818                         struct fchs_s *fchs, u16 len)
 819 {
 820         struct fc_els_cmd_s *els_cmd;
 821
 822         bfa_trc(itnim->fcs, fchs->type);
 823
 824         if (fchs->type != FC_TYPE_ELS)
 825                 return;
 826
 827         els_cmd = (struct fc_els_cmd_s *) (fchs + 1);
 828
 829         bfa_trc(itnim->fcs, els_cmd->els_code);
 830
 831         switch (els_cmd->els_code) {
 832         case FC_ELS_PRLO:
 833                 bfa_fcs_rport_prlo(itnim->rport, fchs->ox_id);
 834                 break;
 835
 836         default:
 837                 WARN_ON(1);
 838         }
 839 }