drivers/scsi/lpfc/lpfc_hbadisc.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2004-2008 Emulex.  All rights reserved.           *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
   8  *                                                                 *
   9  * This program is free software; you can redistribute it and/or   *
  10  * modify it under the terms of version 2 of the GNU General       *
  11  * Public License as published by the Free Software Foundation.    *
  12  * This program is distributed in the hope that it will be useful. *
  13  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  14  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  15  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  16  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  17  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  18  * more details, a copy of which can be found in the file COPYING  *
  19  * included with this package.                                     *
  20  *******************************************************************/
  21
  22 #include <linux/blkdev.h>
  23 #include <linux/pci.h>
  24 #include <linux/kthread.h>
  25 #include <linux/interrupt.h>
  26
  27 #include <scsi/scsi.h>
  28 #include <scsi/scsi_device.h>
  29 #include <scsi/scsi_host.h>
  30 #include <scsi/scsi_transport_fc.h>
  31
  32 #include "lpfc_hw.h"
  33 #include "lpfc_disc.h"
  34 #include "lpfc_sli.h"
  35 #include "lpfc_scsi.h"
  36 #include "lpfc.h"
  37 #include "lpfc_logmsg.h"
  38 #include "lpfc_crtn.h"
  39 #include "lpfc_vport.h"
  40 #include "lpfc_debugfs.h"
  41
  42 /* AlpaArray for assignment of scsid for scan-down and bind_method */
  43 static uint8_t lpfcAlpaArray[] = {
  44         0xEF, 0xE8, 0xE4, 0xE2, 0xE1, 0xE0, 0xDC, 0xDA, 0xD9, 0xD6,
  45         0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA,
  46         0xC9, 0xC7, 0xC6, 0xC5, 0xC3, 0xBC, 0xBA, 0xB9, 0xB6, 0xB5,
  47         0xB4, 0xB3, 0xB2, 0xB1, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9,
  48         0xA7, 0xA6, 0xA5, 0xA3, 0x9F, 0x9E, 0x9D, 0x9B, 0x98, 0x97,
  49         0x90, 0x8F, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7C, 0x7A, 0x79,
  50         0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6E, 0x6D, 0x6C, 0x6B,
  51         0x6A, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5C, 0x5A, 0x59, 0x56,
  52         0x55, 0x54, 0x53, 0x52, 0x51, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A,
  53         0x49, 0x47, 0x46, 0x45, 0x43, 0x3C, 0x3A, 0x39, 0x36, 0x35,
  54         0x34, 0x33, 0x32, 0x31, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29,
  55         0x27, 0x26, 0x25, 0x23, 0x1F, 0x1E, 0x1D, 0x1B, 0x18, 0x17,
  56         0x10, 0x0F, 0x08, 0x04, 0x02, 0x01
  57 };
  58
  59 static void lpfc_disc_timeout_handler(struct lpfc_vport *);
  60 static void lpfc_disc_flush_list(struct lpfc_vport *vport);
  61
  62 void
  63 lpfc_terminate_rport_io(struct fc_rport *rport)
  64 {
  65         struct lpfc_rport_data *rdata;
  66         struct lpfc_nodelist * ndlp;
  67         struct lpfc_hba *phba;
  68
  69         rdata = rport->dd_data;
  70         ndlp = rdata->pnode;
  71
  72         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
  73                 if (rport->roles & FC_RPORT_ROLE_FCP_TARGET)
  74                         printk(KERN_ERR "Cannot find remote node"
  75                         " to terminate I/O Data x%x\n",
  76                         rport->port_id);
  77                 return;
  78         }
  79
  80         phba  = ndlp->vport->phba;
  81
  82         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT,
  83                 "rport terminate: sid:x%x did:x%x flg:x%x",
  84                 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag);
  85
  86         if (ndlp->nlp_sid != NLP_NO_SID) {
  87                 lpfc_sli_abort_iocb(ndlp->vport,
  88                         &phba->sli.ring[phba->sli.fcp_ring],
  89                         ndlp->nlp_sid, 0, LPFC_CTX_TGT);
  90         }
  91 }
  92
  93 /*
  94  * This function will be called when dev_loss_tmo fire.
  95  */
  96 void
  97 lpfc_dev_loss_tmo_callbk(struct fc_rport *rport)
  98 {
  99         struct lpfc_rport_data *rdata;
 100         struct lpfc_nodelist * ndlp;
 101         struct lpfc_vport *vport;
 102         struct lpfc_hba   *phba;
 103         struct lpfc_work_evt *evtp;
 104         int  put_node;
 105         int  put_rport;
 106
 107         rdata = rport->dd_data;
 108         ndlp = rdata->pnode;
 109         if (!ndlp || !NLP_CHK_NODE_ACT(ndlp))
 110                 return;
 111
 112         vport = ndlp->vport;
 113         phba  = vport->phba;
 114
 115         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
 116                 "rport devlosscb: sid:x%x did:x%x flg:x%x",
 117                 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag);
 118
 119         /* Don't defer this if we are in the process of deleting the vport
 120          * or unloading the driver. The unload will cleanup the node
 121          * appropriately we just need to cleanup the ndlp rport info here.
 122          */
 123         if (vport->load_flag & FC_UNLOADING) {
 124                 put_node = rdata->pnode != NULL;
 125                 put_rport = ndlp->rport != NULL;
 126                 rdata->pnode = NULL;
 127                 ndlp->rport = NULL;
 128                 if (put_node)
 129                         lpfc_nlp_put(ndlp);
 130                 if (put_rport)
 131                         put_device(&rport->dev);
 132                 return;
 133         }
 134
 135         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE)
 136                 return;
 137
 138         evtp = &ndlp->dev_loss_evt;
 139
 140         if (!list_empty(&evtp->evt_listp))
 141                 return;
 142
 143         spin_lock_irq(&phba->hbalock);
 144         /* We need to hold the node by incrementing the reference
 145          * count until this queued work is done
 146          */
 147         evtp->evt_arg1  = lpfc_nlp_get(ndlp);
 148         if (evtp->evt_arg1) {
 149                 evtp->evt = LPFC_EVT_DEV_LOSS;
 150                 list_add_tail(&evtp->evt_listp, &phba->work_list);
 151                 lpfc_worker_wake_up(phba);
 152         }
 153         spin_unlock_irq(&phba->hbalock);
 154
 155         return;
 156 }
 157
 158 /*
 159  * This function is called from the worker thread when dev_loss_tmo
 160  * expire.
 161  */
 162 static void
 163 lpfc_dev_loss_tmo_handler(struct lpfc_nodelist *ndlp)
 164 {
 165         struct lpfc_rport_data *rdata;
 166         struct fc_rport   *rport;
 167         struct lpfc_vport *vport;
 168         struct lpfc_hba   *phba;
 169         uint8_t *name;
 170         int  put_node;
 171         int  put_rport;
 172         int warn_on = 0;
 173
 174         rport = ndlp->rport;
 175
 176         if (!rport)
 177                 return;
 178
 179         rdata = rport->dd_data;
 180         name = (uint8_t *) &ndlp->nlp_portname;
 181         vport = ndlp->vport;
 182         phba  = vport->phba;
 183
 184         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
 185                 "rport devlosstmo:did:x%x type:x%x id:x%x",
 186                 ndlp->nlp_DID, ndlp->nlp_type, rport->scsi_target_id);
 187
 188         /* Don't defer this if we are in the process of deleting the vport
 189          * or unloading the driver. The unload will cleanup the node
 190          * appropriately we just need to cleanup the ndlp rport info here.
 191          */
 192         if (vport->load_flag & FC_UNLOADING) {
 193                 if (ndlp->nlp_sid != NLP_NO_SID) {
 194                         /* flush the target */
 195                         lpfc_sli_abort_iocb(vport,
 196                                         &phba->sli.ring[phba->sli.fcp_ring],
 197                                         ndlp->nlp_sid, 0, LPFC_CTX_TGT);
 198                 }
 199                 put_node = rdata->pnode != NULL;
 200                 put_rport = ndlp->rport != NULL;
 201                 rdata->pnode = NULL;
 202                 ndlp->rport = NULL;
 203                 if (put_node)
 204                         lpfc_nlp_put(ndlp);
 205                 if (put_rport)
 206                         put_device(&rport->dev);
 207                 return;
 208         }
 209
 210         if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) {
 211                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 212                                  "0284 Devloss timeout Ignored on "
 213                                  "WWPN %x:%x:%x:%x:%x:%x:%x:%x "
 214                                  "NPort x%x\n",
 215                                  *name, *(name+1), *(name+2), *(name+3),
 216                                  *(name+4), *(name+5), *(name+6), *(name+7),
 217                                  ndlp->nlp_DID);
 218                 return;
 219         }
 220
 221         if (ndlp->nlp_type & NLP_FABRIC) {
 222                 /* We will clean up these Nodes in linkup */
 223                 put_node = rdata->pnode != NULL;
 224                 put_rport = ndlp->rport != NULL;
 225                 rdata->pnode = NULL;
 226                 ndlp->rport = NULL;
 227                 if (put_node)
 228                         lpfc_nlp_put(ndlp);
 229                 if (put_rport)
 230                         put_device(&rport->dev);
 231                 return;
 232         }
 233
 234         if (ndlp->nlp_sid != NLP_NO_SID) {
 235                 warn_on = 1;
 236                 /* flush the target */
 237                 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring],
 238                                     ndlp->nlp_sid, 0, LPFC_CTX_TGT);
 239         }
 240
 241         if (warn_on) {
 242                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 243                                  "0203 Devloss timeout on "
 244                                  "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 245                                  "NPort x%06x Data: x%x x%x x%x\n",
 246                                  *name, *(name+1), *(name+2), *(name+3),
 247                                  *(name+4), *(name+5), *(name+6), *(name+7),
 248                                  ndlp->nlp_DID, ndlp->nlp_flag,
 249                                  ndlp->nlp_state, ndlp->nlp_rpi);
 250         } else {
 251                 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 252                                  "0204 Devloss timeout on "
 253                                  "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x "
 254                                  "NPort x%06x Data: x%x x%x x%x\n",
 255                                  *name, *(name+1), *(name+2), *(name+3),
 256                                  *(name+4), *(name+5), *(name+6), *(name+7),
 257                                  ndlp->nlp_DID, ndlp->nlp_flag,
 258                                  ndlp->nlp_state, ndlp->nlp_rpi);
 259         }
 260
 261         put_node = rdata->pnode != NULL;
 262         put_rport = ndlp->rport != NULL;
 263         rdata->pnode = NULL;
 264         ndlp->rport = NULL;
 265         if (put_node)
 266                 lpfc_nlp_put(ndlp);
 267         if (put_rport)
 268                 put_device(&rport->dev);
 269
 270         if (!(vport->load_flag & FC_UNLOADING) &&
 271             !(ndlp->nlp_flag & NLP_DELAY_TMO) &&
 272             !(ndlp->nlp_flag & NLP_NPR_2B_DISC) &&
 273             (ndlp->nlp_state != NLP_STE_UNMAPPED_NODE))
 274                 lpfc_disc_state_machine(vport, ndlp, NULL, NLP_EVT_DEVICE_RM);
 275 }
 276
 277 static void
 278 lpfc_work_list_done(struct lpfc_hba *phba)
 279 {
 280         struct lpfc_work_evt  *evtp = NULL;
 281         struct lpfc_nodelist  *ndlp;
 282         int free_evt;
 283
 284         spin_lock_irq(&phba->hbalock);
 285         while (!list_empty(&phba->work_list)) {
 286                 list_remove_head((&phba->work_list), evtp, typeof(*evtp),
 287                                  evt_listp);
 288                 spin_unlock_irq(&phba->hbalock);
 289                 free_evt = 1;
 290                 switch (evtp->evt) {
 291                 case LPFC_EVT_ELS_RETRY:
 292                         ndlp = (struct lpfc_nodelist *) (evtp->evt_arg1);
 293                         lpfc_els_retry_delay_handler(ndlp);
 294                         free_evt = 0; /* evt is part of ndlp */
 295                         /* decrement the node reference count held
 296                          * for this queued work
 297                          */
 298                         lpfc_nlp_put(ndlp);
 299                         break;
 300                 case LPFC_EVT_DEV_LOSS:
 301                         ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1);
 302                         lpfc_dev_loss_tmo_handler(ndlp);
 303                         free_evt = 0;
 304                         /* decrement the node reference count held for
 305                          * this queued work
 306                          */
 307                         lpfc_nlp_put(ndlp);
 308                         break;
 309                 case LPFC_EVT_ONLINE:
 310                         if (phba->link_state < LPFC_LINK_DOWN)
 311                                 *(int *) (evtp->evt_arg1) = lpfc_online(phba);
 312                         else
 313                                 *(int *) (evtp->evt_arg1) = 0;
 314                         complete((struct completion *)(evtp->evt_arg2));
 315                         break;
 316                 case LPFC_EVT_OFFLINE_PREP:
 317                         if (phba->link_state >= LPFC_LINK_DOWN)
 318                                 lpfc_offline_prep(phba);
 319                         *(int *)(evtp->evt_arg1) = 0;
 320                         complete((struct completion *)(evtp->evt_arg2));
 321                         break;
 322                 case LPFC_EVT_OFFLINE:
 323                         lpfc_offline(phba);
 324                         lpfc_sli_brdrestart(phba);
 325                         *(int *)(evtp->evt_arg1) =
 326                                 lpfc_sli_brdready(phba, HS_FFRDY | HS_MBRDY);
 327                         lpfc_unblock_mgmt_io(phba);
 328                         complete((struct completion *)(evtp->evt_arg2));
 329                         break;
 330                 case LPFC_EVT_WARM_START:
 331                         lpfc_offline(phba);
 332                         lpfc_reset_barrier(phba);
 333                         lpfc_sli_brdreset(phba);
 334                         lpfc_hba_down_post(phba);
 335                         *(int *)(evtp->evt_arg1) =
 336                                 lpfc_sli_brdready(phba, HS_MBRDY);
 337                         lpfc_unblock_mgmt_io(phba);
 338                         complete((struct completion *)(evtp->evt_arg2));
 339                         break;
 340                 case LPFC_EVT_KILL:
 341                         lpfc_offline(phba);
 342                         *(int *)(evtp->evt_arg1)
 343                                 = (phba->pport->stopped)
 344                                         ? 0 : lpfc_sli_brdkill(phba);
 345                         lpfc_unblock_mgmt_io(phba);
 346                         complete((struct completion *)(evtp->evt_arg2));
 347                         break;
 348                 }
 349                 if (free_evt)
 350                         kfree(evtp);
 351                 spin_lock_irq(&phba->hbalock);
 352         }
 353         spin_unlock_irq(&phba->hbalock);
 354
 355 }
 356
 357 static void
 358 lpfc_work_done(struct lpfc_hba *phba)
 359 {
 360         struct lpfc_sli_ring *pring;
 361         uint32_t ha_copy, status, control, work_port_events;
 362         struct lpfc_vport **vports;
 363         struct lpfc_vport *vport;
 364         int i;
 365
 366         spin_lock_irq(&phba->hbalock);
 367         ha_copy = phba->work_ha;
 368         phba->work_ha = 0;
 369         spin_unlock_irq(&phba->hbalock);
 370
 371         if (ha_copy & HA_ERATT)
 372                 lpfc_handle_eratt(phba);
 373
 374         if (ha_copy & HA_MBATT)
 375                 lpfc_sli_handle_mb_event(phba);
 376
 377         if (ha_copy & HA_LATT)
 378                 lpfc_handle_latt(phba);
 379         vports = lpfc_create_vport_work_array(phba);
 380         if (vports != NULL)
 381                 for(i = 0; i <= phba->max_vpi; i++) {
 382                         /*
 383                          * We could have no vports in array if unloading, so if
 384                          * this happens then just use the pport
 385                          */
 386                         if (vports[i] == NULL && i == 0)
 387                                 vport = phba->pport;
 388                         else
 389                                 vport = vports[i];
 390                         if (vport == NULL)
 391                                 break;
 392                         spin_lock_irq(&vport->work_port_lock);
 393                         work_port_events = vport->work_port_events;
 394                         vport->work_port_events &= ~work_port_events;
 395                         spin_unlock_irq(&vport->work_port_lock);
 396                         if (work_port_events & WORKER_DISC_TMO)
 397                                 lpfc_disc_timeout_handler(vport);
 398                         if (work_port_events & WORKER_ELS_TMO)
 399                                 lpfc_els_timeout_handler(vport);
 400                         if (work_port_events & WORKER_HB_TMO)
 401                                 lpfc_hb_timeout_handler(phba);
 402                         if (work_port_events & WORKER_MBOX_TMO)
 403                                 lpfc_mbox_timeout_handler(phba);
 404                         if (work_port_events & WORKER_FABRIC_BLOCK_TMO)
 405                                 lpfc_unblock_fabric_iocbs(phba);
 406                         if (work_port_events & WORKER_FDMI_TMO)
 407                                 lpfc_fdmi_timeout_handler(vport);
 408                         if (work_port_events & WORKER_RAMP_DOWN_QUEUE)
 409                                 lpfc_ramp_down_queue_handler(phba);
 410                         if (work_port_events & WORKER_RAMP_UP_QUEUE)
 411                                 lpfc_ramp_up_queue_handler(phba);
 412                 }
 413         lpfc_destroy_vport_work_array(phba, vports);
 414
 415         pring = &phba->sli.ring[LPFC_ELS_RING];
 416         status = (ha_copy & (HA_RXMASK  << (4*LPFC_ELS_RING)));
 417         status >>= (4*LPFC_ELS_RING);
 418         if ((status & HA_RXMASK)
 419                 || (pring->flag & LPFC_DEFERRED_RING_EVENT)) {
 420                 if (pring->flag & LPFC_STOP_IOCB_EVENT) {
 421                         pring->flag |= LPFC_DEFERRED_RING_EVENT;
 422                         /* Set the lpfc data pending flag */
 423                         set_bit(LPFC_DATA_READY, &phba->data_flags);
 424                 } else {
 425                         pring->flag &= ~LPFC_DEFERRED_RING_EVENT;
 426                         lpfc_sli_handle_slow_ring_event(phba, pring,
 427                                                         (status &
 428                                                          HA_RXMASK));
 429                 }
 430                 /*
 431                  * Turn on Ring interrupts
 432                  */
 433                 spin_lock_irq(&phba->hbalock);
 434                 control = readl(phba->HCregaddr);
 435                 if (!(control & (HC_R0INT_ENA << LPFC_ELS_RING))) {
 436                         lpfc_debugfs_slow_ring_trc(phba,
 437                                 "WRK Enable ring: cntl:x%x hacopy:x%x",
 438                                 control, ha_copy, 0);
 439
 440                         control |= (HC_R0INT_ENA << LPFC_ELS_RING);
 441                         writel(control, phba->HCregaddr);
 442                         readl(phba->HCregaddr); /* flush */
 443                 }
 444                 else {
 445                         lpfc_debugfs_slow_ring_trc(phba,
 446                                 "WRK Ring ok:     cntl:x%x hacopy:x%x",
 447                                 control, ha_copy, 0);
 448                 }
 449                 spin_unlock_irq(&phba->hbalock);
 450         }
 451         lpfc_work_list_done(phba);
 452 }
 453
 454 int
 455 lpfc_do_work(void *p)
 456 {
 457         struct lpfc_hba *phba = p;
 458         int rc;
 459
 460         set_user_nice(current, -20);
 461         phba->data_flags = 0;
 462
 463         while (1) {
 464                 /* wait and check worker queue activities */
 465                 rc = wait_event_interruptible(phba->work_waitq,
 466                                         (test_and_clear_bit(LPFC_DATA_READY,
 467                                                             &phba->data_flags)
 468                                          || kthread_should_stop()));
 469                 BUG_ON(rc);
 470
 471                 if (kthread_should_stop())
 472                         break;
 473
 474                 /* Attend pending lpfc data processing */
 475                 lpfc_work_done(phba);
 476         }
 477         return 0;
 478 }
 479
 480 /*
 481  * This is only called to handle FC worker events. Since this a rare
 482  * occurance, we allocate a struct lpfc_work_evt structure here instead of
 483  * embedding it in the IOCB.
 484  */
 485 int
 486 lpfc_workq_post_event(struct lpfc_hba *phba, void *arg1, void *arg2,
 487                       uint32_t evt)
 488 {
 489         struct lpfc_work_evt  *evtp;
 490         unsigned long flags;
 491
 492         /*
 493          * All Mailbox completions and LPFC_ELS_RING rcv ring IOCB events will
 494          * be queued to worker thread for processing
 495          */
 496         evtp = kmalloc(sizeof(struct lpfc_work_evt), GFP_ATOMIC);
 497         if (!evtp)
 498                 return 0;
 499
 500         evtp->evt_arg1  = arg1;
 501         evtp->evt_arg2  = arg2;
 502         evtp->evt       = evt;
 503
 504         spin_lock_irqsave(&phba->hbalock, flags);
 505         list_add_tail(&evtp->evt_listp, &phba->work_list);
 506         spin_unlock_irqrestore(&phba->hbalock, flags);
 507
 508         lpfc_worker_wake_up(phba);
 509
 510         return 1;
 511 }
 512
 513 void
 514 lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove)
 515 {
 516         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 517         struct lpfc_hba  *phba = vport->phba;
 518         struct lpfc_nodelist *ndlp, *next_ndlp;
 519         int  rc;
 520
 521         list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
 522                 if (!NLP_CHK_NODE_ACT(ndlp))
 523                         continue;
 524                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
 525                         continue;
 526                 if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) ||
 527                         ((vport->port_type == LPFC_NPIV_PORT) &&
 528                         (ndlp->nlp_DID == NameServer_DID)))
 529                         lpfc_unreg_rpi(vport, ndlp);
 530
 531                 /* Leave Fabric nodes alone on link down */
 532                 if (!remove && ndlp->nlp_type & NLP_FABRIC)
 533                         continue;
 534                 rc = lpfc_disc_state_machine(vport, ndlp, NULL,
 535                                              remove
 536                                              ? NLP_EVT_DEVICE_RM
 537                                              : NLP_EVT_DEVICE_RECOVERY);
 538         }
 539         if (phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) {
 540                 lpfc_mbx_unreg_vpi(vport);
 541                 spin_lock_irq(shost->host_lock);
 542                 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
 543                 spin_unlock_irq(shost->host_lock);
 544         }
 545 }
 546
 547 void
 548 lpfc_port_link_failure(struct lpfc_vport *vport)
 549 {
 550         /* Cleanup any outstanding RSCN activity */
 551         lpfc_els_flush_rscn(vport);
 552
 553         /* Cleanup any outstanding ELS commands */
 554         lpfc_els_flush_cmd(vport);
 555
 556         lpfc_cleanup_rpis(vport, 0);
 557
 558         /* Turn off discovery timer if its running */
 559         lpfc_can_disctmo(vport);
 560 }
 561
 562 static void
 563 lpfc_linkdown_port(struct lpfc_vport *vport)
 564 {
 565         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 566
 567         fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKDOWN, 0);
 568
 569         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 570                 "Link Down:       state:x%x rtry:x%x flg:x%x",
 571                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
 572
 573         lpfc_port_link_failure(vport);
 574
 575 }
 576
 577 int
 578 lpfc_linkdown(struct lpfc_hba *phba)
 579 {
 580         struct lpfc_vport *vport = phba->pport;
 581         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 582         struct lpfc_vport **vports;
 583         LPFC_MBOXQ_t          *mb;
 584         int i;
 585
 586         if (phba->link_state == LPFC_LINK_DOWN)
 587                 return 0;
 588         spin_lock_irq(&phba->hbalock);
 589         if (phba->link_state > LPFC_LINK_DOWN) {
 590                 phba->link_state = LPFC_LINK_DOWN;
 591                 phba->pport->fc_flag &= ~FC_LBIT;
 592         }
 593         spin_unlock_irq(&phba->hbalock);
 594         vports = lpfc_create_vport_work_array(phba);
 595         if (vports != NULL)
 596                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
 597                         /* Issue a LINK DOWN event to all nodes */
 598                         lpfc_linkdown_port(vports[i]);
 599                 }
 600         lpfc_destroy_vport_work_array(phba, vports);
 601         /* Clean up any firmware default rpi's */
 602         mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 603         if (mb) {
 604                 lpfc_unreg_did(phba, 0xffff, 0xffffffff, mb);
 605                 mb->vport = vport;
 606                 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 607                 if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT)
 608                     == MBX_NOT_FINISHED) {
 609                         mempool_free(mb, phba->mbox_mem_pool);
 610                 }
 611         }
 612
 613         /* Setup myDID for link up if we are in pt2pt mode */
 614         if (phba->pport->fc_flag & FC_PT2PT) {
 615                 phba->pport->fc_myDID = 0;
 616                 mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 617                 if (mb) {
 618                         lpfc_config_link(phba, mb);
 619                         mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
 620                         mb->vport = vport;
 621                         if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT)
 622                             == MBX_NOT_FINISHED) {
 623                                 mempool_free(mb, phba->mbox_mem_pool);
 624                         }
 625                 }
 626                 spin_lock_irq(shost->host_lock);
 627                 phba->pport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI);
 628                 spin_unlock_irq(shost->host_lock);
 629         }
 630
 631         return 0;
 632 }
 633
 634 static void
 635 lpfc_linkup_cleanup_nodes(struct lpfc_vport *vport)
 636 {
 637         struct lpfc_nodelist *ndlp;
 638
 639         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 640                 if (!NLP_CHK_NODE_ACT(ndlp))
 641                         continue;
 642                 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
 643                         continue;
 644                 if (ndlp->nlp_type & NLP_FABRIC) {
 645                         /* On Linkup its safe to clean up the ndlp
 646                          * from Fabric connections.
 647                          */
 648                         if (ndlp->nlp_DID != Fabric_DID)
 649                                 lpfc_unreg_rpi(vport, ndlp);
 650                         lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
 651                 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
 652                         /* Fail outstanding IO now since device is
 653                          * marked for PLOGI.
 654                          */
 655                         lpfc_unreg_rpi(vport, ndlp);
 656                 }
 657         }
 658 }
 659
 660 static void
 661 lpfc_linkup_port(struct lpfc_vport *vport)
 662 {
 663         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 664         struct lpfc_hba  *phba = vport->phba;
 665
 666         if ((vport->load_flag & FC_UNLOADING) != 0)
 667                 return;
 668
 669         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
 670                 "Link Up:         top:x%x speed:x%x flg:x%x",
 671                 phba->fc_topology, phba->fc_linkspeed, phba->link_flag);
 672
 673         /* If NPIV is not enabled, only bring the physical port up */
 674         if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
 675                 (vport != phba->pport))
 676                 return;
 677
 678         fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKUP, 0);
 679
 680         spin_lock_irq(shost->host_lock);
 681         vport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI | FC_ABORT_DISCOVERY |
 682                             FC_RSCN_MODE | FC_NLP_MORE | FC_RSCN_DISCOVERY);
 683         vport->fc_flag |= FC_NDISC_ACTIVE;
 684         vport->fc_ns_retry = 0;
 685         spin_unlock_irq(shost->host_lock);
 686
 687         if (vport->fc_flag & FC_LBIT)
 688                 lpfc_linkup_cleanup_nodes(vport);
 689
 690 }
 691
 692 static int
 693 lpfc_linkup(struct lpfc_hba *phba)
 694 {
 695         struct lpfc_vport **vports;
 696         int i;
 697
 698         phba->link_state = LPFC_LINK_UP;
 699
 700         /* Unblock fabric iocbs if they are blocked */
 701         clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
 702         del_timer_sync(&phba->fabric_block_timer);
 703
 704         vports = lpfc_create_vport_work_array(phba);
 705         if (vports != NULL)
 706                 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++)
 707                         lpfc_linkup_port(vports[i]);
 708         lpfc_destroy_vport_work_array(phba, vports);
 709         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
 710                 lpfc_issue_clear_la(phba, phba->pport);
 711
 712         return 0;
 713 }
 714
 715 /*
 716  * This routine handles processing a CLEAR_LA mailbox
 717  * command upon completion. It is setup in the LPFC_MBOXQ
 718  * as the completion routine when the command is
 719  * handed off to the SLI layer.
 720  */
 721 static void
 722 lpfc_mbx_cmpl_clear_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 723 {
 724         struct lpfc_vport *vport = pmb->vport;
 725         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
 726         struct lpfc_sli   *psli = &phba->sli;
 727         MAILBOX_t *mb = &pmb->mb;
 728         uint32_t control;
 729
 730         /* Since we don't do discovery right now, turn these off here */
 731         psli->ring[psli->extra_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
 732         psli->ring[psli->fcp_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
 733         psli->ring[psli->next_ring].flag &= ~LPFC_STOP_IOCB_EVENT;
 734
 735         /* Check for error */
 736         if ((mb->mbxStatus) && (mb->mbxStatus != 0x1601)) {
 737                 /* CLEAR_LA mbox error <mbxStatus> state <hba_state> */
 738                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
 739                                  "0320 CLEAR_LA mbxStatus error x%x hba "
 740                                  "state x%x\n",
 741                                  mb->mbxStatus, vport->port_state);
 742                 phba->link_state = LPFC_HBA_ERROR;
 743                 goto out;
 744         }
 745
 746         if (vport->port_type == LPFC_PHYSICAL_PORT)
 747                 phba->link_state = LPFC_HBA_READY;
 748
 749         spin_lock_irq(&phba->hbalock);
 750         psli->sli_flag |= LPFC_PROCESS_LA;
 751         control = readl(phba->HCregaddr);
 752         control |= HC_LAINT_ENA;
 753         writel(control, phba->HCregaddr);
 754         readl(phba->HCregaddr); /* flush */
 755         spin_unlock_irq(&phba->hbalock);
 756         mempool_free(pmb, phba->mbox_mem_pool);
 757         return;
 758
 759 out:
 760         /* Device Discovery completes */
 761         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
 762                          "0225 Device Discovery completes\n");
 763         mempool_free(pmb, phba->mbox_mem_pool);
 764
 765         spin_lock_irq(shost->host_lock);
 766         vport->fc_flag &= ~FC_ABORT_DISCOVERY;
 767         spin_unlock_irq(shost->host_lock);
 768
 769         lpfc_can_disctmo(vport);
 770
 771         /* turn on Link Attention interrupts */
 772
 773         spin_lock_irq(&phba->hbalock);
 774         psli->sli_flag |= LPFC_PROCESS_LA;
 775         control = readl(phba->HCregaddr);
 776         control |= HC_LAINT_ENA;
 777         writel(control, phba->HCregaddr);
 778         readl(phba->HCregaddr); /* flush */
 779         spin_unlock_irq(&phba->hbalock);
 780
 781         return;
 782 }
 783
 784
 785 static void
 786 lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 787 {
 788         struct lpfc_vport *vport = pmb->vport;
 789
 790         if (pmb->mb.mbxStatus)
 791                 goto out;
 792
 793         mempool_free(pmb, phba->mbox_mem_pool);
 794
 795         if (phba->fc_topology == TOPOLOGY_LOOP &&
 796             vport->fc_flag & FC_PUBLIC_LOOP &&
 797             !(vport->fc_flag & FC_LBIT)) {
 798                         /* Need to wait for FAN - use discovery timer
 799                          * for timeout.  port_state is identically
 800                          * LPFC_LOCAL_CFG_LINK while waiting for FAN
 801                          */
 802                         lpfc_set_disctmo(vport);
 803                         return;
 804         }
 805
 806         /* Start discovery by sending a FLOGI. port_state is identically
 807          * LPFC_FLOGI while waiting for FLOGI cmpl
 808          */
 809         if (vport->port_state != LPFC_FLOGI) {
 810                 lpfc_initial_flogi(vport);
 811         }
 812         return;
 813
 814 out:
 815         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
 816                          "0306 CONFIG_LINK mbxStatus error x%x "
 817                          "HBA state x%x\n",
 818                          pmb->mb.mbxStatus, vport->port_state);
 819         mempool_free(pmb, phba->mbox_mem_pool);
 820
 821         lpfc_linkdown(phba);
 822
 823         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
 824                          "0200 CONFIG_LINK bad hba state x%x\n",
 825                          vport->port_state);
 826
 827         lpfc_issue_clear_la(phba, vport);
 828         return;
 829 }
 830
 831 static void
 832 lpfc_mbx_cmpl_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 833 {
 834         MAILBOX_t *mb = &pmb->mb;
 835         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) pmb->context1;
 836         struct lpfc_vport  *vport = pmb->vport;
 837
 838
 839         /* Check for error */
 840         if (mb->mbxStatus) {
 841                 /* READ_SPARAM mbox error <mbxStatus> state <hba_state> */
 842                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
 843                                  "0319 READ_SPARAM mbxStatus error x%x "
 844                                  "hba state x%x>\n",
 845                                  mb->mbxStatus, vport->port_state);
 846                 lpfc_linkdown(phba);
 847                 goto out;
 848         }
 849
 850         memcpy((uint8_t *) &vport->fc_sparam, (uint8_t *) mp->virt,
 851                sizeof (struct serv_parm));
 852         if (phba->cfg_soft_wwnn)
 853                 u64_to_wwn(phba->cfg_soft_wwnn,
 854                            vport->fc_sparam.nodeName.u.wwn);
 855         if (phba->cfg_soft_wwpn)
 856                 u64_to_wwn(phba->cfg_soft_wwpn,
 857                            vport->fc_sparam.portName.u.wwn);
 858         memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
 859                sizeof(vport->fc_nodename));
 860         memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
 861                sizeof(vport->fc_portname));
 862         if (vport->port_type == LPFC_PHYSICAL_PORT) {
 863                 memcpy(&phba->wwnn, &vport->fc_nodename, sizeof(phba->wwnn));
 864                 memcpy(&phba->wwpn, &vport->fc_portname, sizeof(phba->wwnn));
 865         }
 866
 867         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 868         kfree(mp);
 869         mempool_free(pmb, phba->mbox_mem_pool);
 870         return;
 871
 872 out:
 873         pmb->context1 = NULL;
 874         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 875         kfree(mp);
 876         lpfc_issue_clear_la(phba, vport);
 877         mempool_free(pmb, phba->mbox_mem_pool);
 878         return;
 879 }
 880
 881 static void
 882 lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
 883 {
 884         struct lpfc_vport *vport = phba->pport;
 885         LPFC_MBOXQ_t *sparam_mbox, *cfglink_mbox;
 886         int i;
 887         struct lpfc_dmabuf *mp;
 888         int rc;
 889
 890         sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 891         cfglink_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
 892
 893         spin_lock_irq(&phba->hbalock);
 894         switch (la->UlnkSpeed) {
 895         case LA_1GHZ_LINK:
 896                 phba->fc_linkspeed = LA_1GHZ_LINK;
 897                 break;
 898         case LA_2GHZ_LINK:
 899                 phba->fc_linkspeed = LA_2GHZ_LINK;
 900                 break;
 901         case LA_4GHZ_LINK:
 902                 phba->fc_linkspeed = LA_4GHZ_LINK;
 903                 break;
 904         case LA_8GHZ_LINK:
 905                 phba->fc_linkspeed = LA_8GHZ_LINK;
 906                 break;
 907         default:
 908                 phba->fc_linkspeed = LA_UNKNW_LINK;
 909                 break;
 910         }
 911
 912         phba->fc_topology = la->topology;
 913         phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
 914
 915         if (phba->fc_topology == TOPOLOGY_LOOP) {
 916                 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
 917
 918                 if (phba->cfg_enable_npiv)
 919                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
 920                                 "1309 Link Up Event npiv not supported in loop "
 921                                 "topology\n");
 922                                 /* Get Loop Map information */
 923                 if (la->il)
 924                         vport->fc_flag |= FC_LBIT;
 925
 926                 vport->fc_myDID = la->granted_AL_PA;
 927                 i = la->un.lilpBde64.tus.f.bdeSize;
 928
 929                 if (i == 0) {
 930                         phba->alpa_map[0] = 0;
 931                 } else {
 932                         if (vport->cfg_log_verbose & LOG_LINK_EVENT) {
 933                                 int numalpa, j, k;
 934                                 union {
 935                                         uint8_t pamap[16];
 936                                         struct {
 937                                                 uint32_t wd1;
 938                                                 uint32_t wd2;
 939                                                 uint32_t wd3;
 940                                                 uint32_t wd4;
 941                                         } pa;
 942                                 } un;
 943                                 numalpa = phba->alpa_map[0];
 944                                 j = 0;
 945                                 while (j < numalpa) {
 946                                         memset(un.pamap, 0, 16);
 947                                         for (k = 1; j < numalpa; k++) {
 948                                                 un.pamap[k - 1] =
 949                                                         phba->alpa_map[j + 1];
 950                                                 j++;
 951                                                 if (k == 16)
 952                                                         break;
 953                                         }
 954                                         /* Link Up Event ALPA map */
 955                                         lpfc_printf_log(phba,
 956                                                         KERN_WARNING,
 957                                                         LOG_LINK_EVENT,
 958                                                         "1304 Link Up Event "
 959                                                         "ALPA map Data: x%x "
 960                                                         "x%x x%x x%x\n",
 961                                                         un.pa.wd1, un.pa.wd2,
 962                                                         un.pa.wd3, un.pa.wd4);
 963                                 }
 964                         }
 965                 }
 966         } else {
 967                 if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
 968                         if (phba->max_vpi && phba->cfg_enable_npiv &&
 969                            (phba->sli_rev == 3))
 970                                 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED;
 971                 }
 972                 vport->fc_myDID = phba->fc_pref_DID;
 973                 vport->fc_flag |= FC_LBIT;
 974         }
 975         spin_unlock_irq(&phba->hbalock);
 976
 977         lpfc_linkup(phba);
 978         if (sparam_mbox) {
 979                 lpfc_read_sparam(phba, sparam_mbox, 0);
 980                 sparam_mbox->vport = vport;
 981                 sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam;
 982                 rc = lpfc_sli_issue_mbox(phba, sparam_mbox, MBX_NOWAIT);
 983                 if (rc == MBX_NOT_FINISHED) {
 984                         mp = (struct lpfc_dmabuf *) sparam_mbox->context1;
 985                         lpfc_mbuf_free(phba, mp->virt, mp->phys);
 986                         kfree(mp);
 987                         mempool_free(sparam_mbox, phba->mbox_mem_pool);
 988                         if (cfglink_mbox)
 989                                 mempool_free(cfglink_mbox, phba->mbox_mem_pool);
 990                         goto out;
 991                 }
 992         }
 993
 994         if (cfglink_mbox) {
 995                 vport->port_state = LPFC_LOCAL_CFG_LINK;
 996                 lpfc_config_link(phba, cfglink_mbox);
 997                 cfglink_mbox->vport = vport;
 998                 cfglink_mbox->mbox_cmpl = lpfc_mbx_cmpl_local_config_link;
 999                 rc = lpfc_sli_issue_mbox(phba, cfglink_mbox, MBX_NOWAIT);
1000                 if (rc != MBX_NOT_FINISHED)
1001                         return;
1002                 mempool_free(cfglink_mbox, phba->mbox_mem_pool);
1003         }
1004 out:
1005         lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1006         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
1007                          "0263 Discovery Mailbox error: state: 0x%x : %p %p\n",
1008                          vport->port_state, sparam_mbox, cfglink_mbox);
1009         lpfc_issue_clear_la(phba, vport);
1010         return;
1011 }
1012
1013 static void
1014 lpfc_enable_la(struct lpfc_hba *phba)
1015 {
1016         uint32_t control;
1017         struct lpfc_sli *psli = &phba->sli;
1018         spin_lock_irq(&phba->hbalock);
1019         psli->sli_flag |= LPFC_PROCESS_LA;
1020         control = readl(phba->HCregaddr);
1021         control |= HC_LAINT_ENA;
1022         writel(control, phba->HCregaddr);
1023         readl(phba->HCregaddr); /* flush */
1024         spin_unlock_irq(&phba->hbalock);
1025 }
1026
1027 static void
1028 lpfc_mbx_issue_link_down(struct lpfc_hba *phba)
1029 {
1030         lpfc_linkdown(phba);
1031         lpfc_enable_la(phba);
1032         /* turn on Link Attention interrupts - no CLEAR_LA needed */
1033 }
1034
1035
1036 /*
1037  * This routine handles processing a READ_LA mailbox
1038  * command upon completion. It is setup in the LPFC_MBOXQ
1039  * as the completion routine when the command is
1040  * handed off to the SLI layer.
1041  */
1042 void
1043 lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1044 {
1045         struct lpfc_vport *vport = pmb->vport;
1046         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1047         READ_LA_VAR *la;
1048         MAILBOX_t *mb = &pmb->mb;
1049         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
1050
1051         /* Unblock ELS traffic */
1052         phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT;
1053         /* Check for error */
1054         if (mb->mbxStatus) {
1055                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1056                                 "1307 READ_LA mbox error x%x state x%x\n",
1057                                 mb->mbxStatus, vport->port_state);
1058                 lpfc_mbx_issue_link_down(phba);
1059                 phba->link_state = LPFC_HBA_ERROR;
1060                 goto lpfc_mbx_cmpl_read_la_free_mbuf;
1061         }
1062
1063         la = (READ_LA_VAR *) & pmb->mb.un.varReadLA;
1064
1065         memcpy(&phba->alpa_map[0], mp->virt, 128);
1066
1067         spin_lock_irq(shost->host_lock);
1068         if (la->pb)
1069                 vport->fc_flag |= FC_BYPASSED_MODE;
1070         else
1071                 vport->fc_flag &= ~FC_BYPASSED_MODE;
1072         spin_unlock_irq(shost->host_lock);
1073
1074         if (((phba->fc_eventTag + 1) < la->eventTag) ||
1075             (phba->fc_eventTag == la->eventTag)) {
1076                 phba->fc_stat.LinkMultiEvent++;
1077                 if (la->attType == AT_LINK_UP)
1078                         if (phba->fc_eventTag != 0)
1079                                 lpfc_linkdown(phba);
1080         }
1081
1082         phba->fc_eventTag = la->eventTag;
1083         if (la->mm)
1084                 phba->sli.sli_flag |= LPFC_MENLO_MAINT;
1085         else
1086                 phba->sli.sli_flag &= ~LPFC_MENLO_MAINT;
1087
1088         if (la->attType == AT_LINK_UP && (!la->mm)) {
1089                 phba->fc_stat.LinkUp++;
1090                 if (phba->link_flag & LS_LOOPBACK_MODE) {
1091                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1092                                         "1306 Link Up Event in loop back mode "
1093                                         "x%x received Data: x%x x%x x%x x%x\n",
1094                                         la->eventTag, phba->fc_eventTag,
1095                                         la->granted_AL_PA, la->UlnkSpeed,
1096                                         phba->alpa_map[0]);
1097                 } else {
1098                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1099                                         "1303 Link Up Event x%x received "
1100                                         "Data: x%x x%x x%x x%x x%x x%x %d\n",
1101                                         la->eventTag, phba->fc_eventTag,
1102                                         la->granted_AL_PA, la->UlnkSpeed,
1103                                         phba->alpa_map[0],
1104                                         la->mm, la->fa,
1105                                         phba->wait_4_mlo_maint_flg);
1106                 }
1107                 lpfc_mbx_process_link_up(phba, la);
1108         } else if (la->attType == AT_LINK_DOWN) {
1109                 phba->fc_stat.LinkDown++;
1110                 if (phba->link_flag & LS_LOOPBACK_MODE) {
1111                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1112                                 "1308 Link Down Event in loop back mode "
1113                                 "x%x received "
1114                                 "Data: x%x x%x x%x\n",
1115                                 la->eventTag, phba->fc_eventTag,
1116                                 phba->pport->port_state, vport->fc_flag);
1117                 }
1118                 else {
1119                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1120                                 "1305 Link Down Event x%x received "
1121                                 "Data: x%x x%x x%x x%x x%x\n",
1122                                 la->eventTag, phba->fc_eventTag,
1123                                 phba->pport->port_state, vport->fc_flag,
1124                                 la->mm, la->fa);
1125                 }
1126                 lpfc_mbx_issue_link_down(phba);
1127         }
1128         if (la->mm && la->attType == AT_LINK_UP) {
1129                 if (phba->link_state != LPFC_LINK_DOWN) {
1130                         phba->fc_stat.LinkDown++;
1131                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1132                                 "1312 Link Down Event x%x received "
1133                                 "Data: x%x x%x x%x\n",
1134                                 la->eventTag, phba->fc_eventTag,
1135                                 phba->pport->port_state, vport->fc_flag);
1136                         lpfc_mbx_issue_link_down(phba);
1137                 } else
1138                         lpfc_enable_la(phba);
1139
1140                 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1141                                 "1310 Menlo Maint Mode Link up Event x%x rcvd "
1142                                 "Data: x%x x%x x%x\n",
1143                                 la->eventTag, phba->fc_eventTag,
1144                                 phba->pport->port_state, vport->fc_flag);
1145                 /*
1146                  * The cmnd that triggered this will be waiting for this
1147                  * signal.
1148                  */
1149                 /* WAKEUP for MENLO_SET_MODE or MENLO_RESET command. */
1150                 if (phba->wait_4_mlo_maint_flg) {
1151                         phba->wait_4_mlo_maint_flg = 0;
1152                         wake_up_interruptible(&phba->wait_4_mlo_m_q);
1153                 }
1154         }
1155
1156         if (la->fa) {
1157                 if (la->mm)
1158                         lpfc_issue_clear_la(phba, vport);
1159                 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
1160                                 "1311 fa %d\n", la->fa);
1161         }
1162
1163 lpfc_mbx_cmpl_read_la_free_mbuf:
1164         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1165         kfree(mp);
1166         mempool_free(pmb, phba->mbox_mem_pool);
1167         return;
1168 }
1169
1170 /*
1171  * This routine handles processing a REG_LOGIN mailbox
1172  * command upon completion. It is setup in the LPFC_MBOXQ
1173  * as the completion routine when the command is
1174  * handed off to the SLI layer.
1175  */
1176 void
1177 lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1178 {
1179         struct lpfc_vport  *vport = pmb->vport;
1180         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
1181         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
1182
1183         pmb->context1 = NULL;
1184
1185         /* Good status, call state machine */
1186         lpfc_disc_state_machine(vport, ndlp, pmb, NLP_EVT_CMPL_REG_LOGIN);
1187         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1188         kfree(mp);
1189         mempool_free(pmb, phba->mbox_mem_pool);
1190         /* decrement the node reference count held for this callback
1191          * function.
1192          */
1193         lpfc_nlp_put(ndlp);
1194
1195         return;
1196 }
1197
1198 static void
1199 lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1200 {
1201         MAILBOX_t *mb = &pmb->mb;
1202         struct lpfc_vport *vport = pmb->vport;
1203         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1204
1205         switch (mb->mbxStatus) {
1206         case 0x0011:
1207         case 0x0020:
1208         case 0x9700:
1209                 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
1210                                  "0911 cmpl_unreg_vpi, mb status = 0x%x\n",
1211                                  mb->mbxStatus);
1212                 break;
1213         }
1214         vport->unreg_vpi_cmpl = VPORT_OK;
1215         mempool_free(pmb, phba->mbox_mem_pool);
1216         /*
1217          * This shost reference might have been taken at the beginning of
1218          * lpfc_vport_delete()
1219          */
1220         if (vport->load_flag & FC_UNLOADING)
1221                 scsi_host_put(shost);
1222 }
1223
1224 int
1225 lpfc_mbx_unreg_vpi(struct lpfc_vport *vport)
1226 {
1227         struct lpfc_hba  *phba = vport->phba;
1228         LPFC_MBOXQ_t *mbox;
1229         int rc;
1230
1231         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1232         if (!mbox)
1233                 return 1;
1234
1235         lpfc_unreg_vpi(phba, vport->vpi, mbox);
1236         mbox->vport = vport;
1237         mbox->mbox_cmpl = lpfc_mbx_cmpl_unreg_vpi;
1238         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
1239         if (rc == MBX_NOT_FINISHED) {
1240                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
1241                                  "1800 Could not issue unreg_vpi\n");
1242                 mempool_free(mbox, phba->mbox_mem_pool);
1243                 vport->unreg_vpi_cmpl = VPORT_ERROR;
1244                 return rc;
1245         }
1246         return 0;
1247 }
1248
1249 static void
1250 lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1251 {
1252         struct lpfc_vport *vport = pmb->vport;
1253         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
1254         MAILBOX_t *mb = &pmb->mb;
1255
1256         switch (mb->mbxStatus) {
1257         case 0x0011:
1258         case 0x9601:
1259         case 0x9602:
1260                 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
1261                                  "0912 cmpl_reg_vpi, mb status = 0x%x\n",
1262                                  mb->mbxStatus);
1263                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1264                 spin_lock_irq(shost->host_lock);
1265                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
1266                 spin_unlock_irq(shost->host_lock);
1267                 vport->fc_myDID = 0;
1268                 goto out;
1269         }
1270
1271         vport->num_disc_nodes = 0;
1272         /* go thru NPR list and issue ELS PLOGIs */
1273         if (vport->fc_npr_cnt)
1274                 lpfc_els_disc_plogi(vport);
1275
1276         if (!vport->num_disc_nodes) {
1277                 spin_lock_irq(shost->host_lock);
1278                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
1279                 spin_unlock_irq(shost->host_lock);
1280                 lpfc_can_disctmo(vport);
1281         }
1282         vport->port_state = LPFC_VPORT_READY;
1283
1284 out:
1285         mempool_free(pmb, phba->mbox_mem_pool);
1286         return;
1287 }
1288
1289 /*
1290  * This routine handles processing a Fabric REG_LOGIN mailbox
1291  * command upon completion. It is setup in the LPFC_MBOXQ
1292  * as the completion routine when the command is
1293  * handed off to the SLI layer.
1294  */
1295 void
1296 lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1297 {
1298         struct lpfc_vport *vport = pmb->vport;
1299         MAILBOX_t *mb = &pmb->mb;
1300         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
1301         struct lpfc_nodelist *ndlp;
1302         struct lpfc_vport **vports;
1303         int i;
1304
1305         ndlp = (struct lpfc_nodelist *) pmb->context2;
1306         pmb->context1 = NULL;
1307         pmb->context2 = NULL;
1308         if (mb->mbxStatus) {
1309                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1310                 kfree(mp);
1311                 mempool_free(pmb, phba->mbox_mem_pool);
1312
1313                 if (phba->fc_topology == TOPOLOGY_LOOP) {
1314                         /* FLOGI failed, use loop map to make discovery list */
1315                         lpfc_disc_list_loopmap(vport);
1316
1317                         /* Start discovery */
1318                         lpfc_disc_start(vport);
1319                         /* Decrement the reference count to ndlp after the
1320                          * reference to the ndlp are done.
1321                          */
1322                         lpfc_nlp_put(ndlp);
1323                         return;
1324                 }
1325
1326                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1327                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
1328                                  "0258 Register Fabric login error: 0x%x\n",
1329                                  mb->mbxStatus);
1330                 /* Decrement the reference count to ndlp after the reference
1331                  * to the ndlp are done.
1332                  */
1333                 lpfc_nlp_put(ndlp);
1334                 return;
1335         }
1336
1337         ndlp->nlp_rpi = mb->un.varWords[0];
1338         ndlp->nlp_type |= NLP_FABRIC;
1339         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1340
1341         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
1342                 vports = lpfc_create_vport_work_array(phba);
1343                 if (vports != NULL)
1344                         for(i = 0;
1345                             i <= phba->max_vpi && vports[i] != NULL;
1346                             i++) {
1347                                 if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
1348                                         continue;
1349                                 if (phba->fc_topology == TOPOLOGY_LOOP) {
1350                                         lpfc_vport_set_state(vports[i],
1351                                                         FC_VPORT_LINKDOWN);
1352                                         continue;
1353                                 }
1354                                 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
1355                                         lpfc_initial_fdisc(vports[i]);
1356                                 else {
1357                                         lpfc_vport_set_state(vports[i],
1358                                                 FC_VPORT_NO_FABRIC_SUPP);
1359                                         lpfc_printf_vlog(vport, KERN_ERR,
1360                                                          LOG_ELS,
1361                                                         "0259 No NPIV "
1362                                                         "Fabric support\n");
1363                                 }
1364                         }
1365                 lpfc_destroy_vport_work_array(phba, vports);
1366                 lpfc_do_scr_ns_plogi(phba, vport);
1367         }
1368
1369         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1370         kfree(mp);
1371         mempool_free(pmb, phba->mbox_mem_pool);
1372
1373         /* Drop the reference count from the mbox at the end after
1374          * all the current reference to the ndlp have been done.
1375          */
1376         lpfc_nlp_put(ndlp);
1377         return;
1378 }
1379
1380 /*
1381  * This routine handles processing a NameServer REG_LOGIN mailbox
1382  * command upon completion. It is setup in the LPFC_MBOXQ
1383  * as the completion routine when the command is
1384  * handed off to the SLI layer.
1385  */
1386 void
1387 lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
1388 {
1389         MAILBOX_t *mb = &pmb->mb;
1390         struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1);
1391         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
1392         struct lpfc_vport *vport = pmb->vport;
1393
1394         if (mb->mbxStatus) {
1395 out:
1396                 /* decrement the node reference count held for this
1397                  * callback function.
1398                  */
1399                 lpfc_nlp_put(ndlp);
1400                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
1401                 kfree(mp);
1402                 mempool_free(pmb, phba->mbox_mem_pool);
1403
1404                 /* If no other thread is using the ndlp, free it */
1405                 lpfc_nlp_not_used(ndlp);
1406
1407                 if (phba->fc_topology == TOPOLOGY_LOOP) {
1408                         /*
1409                          * RegLogin failed, use loop map to make discovery
1410                          * list
1411                          */
1412                         lpfc_disc_list_loopmap(vport);
1413
1414                         /* Start discovery */
1415                         lpfc_disc_start(vport);
1416                         return;
1417                 }
1418                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
1419                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
1420                                  "0260 Register NameServer error: 0x%x\n",
1421                                  mb->mbxStatus);
1422                 return;
1423         }
1424
1425         pmb->context1 = NULL;
1426
1427         ndlp->nlp_rpi = mb->un.varWords[0];
1428         ndlp->nlp_type |= NLP_FABRIC;
1429         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1430
1431         if (vport->port_state < LPFC_VPORT_READY) {
1432                 /* Link up discovery requires Fabric registration. */
1433                 lpfc_ns_cmd(vport, SLI_CTNS_RFF_ID, 0, 0); /* Do this first! */
1434                 lpfc_ns_cmd(vport, SLI_CTNS_RNN_ID, 0, 0);
1435                 lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0);
1436                 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
1437                 lpfc_ns_cmd(vport, SLI_CTNS_RFT_ID, 0, 0);
1438
1439                 /* Issue SCR just before NameServer GID_FT Query */
1440                 lpfc_issue_els_scr(vport, SCR_DID, 0);
1441         }
1442
1443         vport->fc_ns_retry = 0;
1444         /* Good status, issue CT Request to NameServer */
1445         if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0)) {
1446                 /* Cannot issue NameServer Query, so finish up discovery */
1447                 goto out;
1448         }
1449
1450         /* decrement the node reference count held for this
1451          * callback function.
1452          */
1453         lpfc_nlp_put(ndlp);
1454         lpfc_mbuf_free(phba, mp->virt, mp->phys);
1455         kfree(mp);
1456         mempool_free(pmb, phba->mbox_mem_pool);
1457
1458         return;
1459 }
1460
1461 static void
1462 lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1463 {
1464         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1465         struct fc_rport  *rport;
1466         struct lpfc_rport_data *rdata;
1467         struct fc_rport_identifiers rport_ids;
1468         struct lpfc_hba  *phba = vport->phba;
1469
1470         /* Remote port has reappeared. Re-register w/ FC transport */
1471         rport_ids.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn);
1472         rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn);
1473         rport_ids.port_id = ndlp->nlp_DID;
1474         rport_ids.roles = FC_RPORT_ROLE_UNKNOWN;
1475
1476         /*
1477          * We leave our node pointer in rport->dd_data when we unregister a
1478          * FCP target port.  But fc_remote_port_add zeros the space to which
1479          * rport->dd_data points.  So, if we're reusing a previously
1480          * registered port, drop the reference that we took the last time we
1481          * registered the port.
1482          */
1483         if (ndlp->rport && ndlp->rport->dd_data &&
1484             ((struct lpfc_rport_data *) ndlp->rport->dd_data)->pnode == ndlp)
1485                 lpfc_nlp_put(ndlp);
1486
1487         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT,
1488                 "rport add:       did:x%x flg:x%x type x%x",
1489                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
1490
1491         ndlp->rport = rport = fc_remote_port_add(shost, 0, &rport_ids);
1492         if (!rport || !get_device(&rport->dev)) {
1493                 dev_printk(KERN_WARNING, &phba->pcidev->dev,
1494                            "Warning: fc_remote_port_add failed\n");
1495                 return;
1496         }
1497
1498         /* initialize static port data */
1499         rport->maxframe_size = ndlp->nlp_maxframe;
1500         rport->supported_classes = ndlp->nlp_class_sup;
1501         rdata = rport->dd_data;
1502         rdata->pnode = lpfc_nlp_get(ndlp);
1503
1504         if (ndlp->nlp_type & NLP_FCP_TARGET)
1505                 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
1506         if (ndlp->nlp_type & NLP_FCP_INITIATOR)
1507                 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1508
1509
1510         if (rport_ids.roles !=  FC_RPORT_ROLE_UNKNOWN)
1511                 fc_remote_port_rolechg(rport, rport_ids.roles);
1512
1513         if ((rport->scsi_target_id != -1) &&
1514             (rport->scsi_target_id < LPFC_MAX_TARGET)) {
1515                 ndlp->nlp_sid = rport->scsi_target_id;
1516         }
1517         return;
1518 }
1519
1520 static void
1521 lpfc_unregister_remote_port(struct lpfc_nodelist *ndlp)
1522 {
1523         struct fc_rport *rport = ndlp->rport;
1524
1525         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT,
1526                 "rport delete:    did:x%x flg:x%x type x%x",
1527                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
1528
1529         fc_remote_port_delete(rport);
1530
1531         return;
1532 }
1533
1534 static void
1535 lpfc_nlp_counters(struct lpfc_vport *vport, int state, int count)
1536 {
1537         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1538
1539         spin_lock_irq(shost->host_lock);
1540         switch (state) {
1541         case NLP_STE_UNUSED_NODE:
1542                 vport->fc_unused_cnt += count;
1543                 break;
1544         case NLP_STE_PLOGI_ISSUE:
1545                 vport->fc_plogi_cnt += count;
1546                 break;
1547         case NLP_STE_ADISC_ISSUE:
1548                 vport->fc_adisc_cnt += count;
1549                 break;
1550         case NLP_STE_REG_LOGIN_ISSUE:
1551                 vport->fc_reglogin_cnt += count;
1552                 break;
1553         case NLP_STE_PRLI_ISSUE:
1554                 vport->fc_prli_cnt += count;
1555                 break;
1556         case NLP_STE_UNMAPPED_NODE:
1557                 vport->fc_unmap_cnt += count;
1558                 break;
1559         case NLP_STE_MAPPED_NODE:
1560                 vport->fc_map_cnt += count;
1561                 break;
1562         case NLP_STE_NPR_NODE:
1563                 vport->fc_npr_cnt += count;
1564                 break;
1565         }
1566         spin_unlock_irq(shost->host_lock);
1567 }
1568
1569 static void
1570 lpfc_nlp_state_cleanup(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1571                        int old_state, int new_state)
1572 {
1573         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1574
1575         if (new_state == NLP_STE_UNMAPPED_NODE) {
1576                 ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR);
1577                 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
1578                 ndlp->nlp_type |= NLP_FC_NODE;
1579         }
1580         if (new_state == NLP_STE_MAPPED_NODE)
1581                 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE;
1582         if (new_state == NLP_STE_NPR_NODE)
1583                 ndlp->nlp_flag &= ~NLP_RCV_PLOGI;
1584
1585         /* Transport interface */
1586         if (ndlp->rport && (old_state == NLP_STE_MAPPED_NODE ||
1587                             old_state == NLP_STE_UNMAPPED_NODE)) {
1588                 vport->phba->nport_event_cnt++;
1589                 lpfc_unregister_remote_port(ndlp);
1590         }
1591
1592         if (new_state ==  NLP_STE_MAPPED_NODE ||
1593             new_state == NLP_STE_UNMAPPED_NODE) {
1594                 vport->phba->nport_event_cnt++;
1595                 /*
1596                  * Tell the fc transport about the port, if we haven't
1597                  * already. If we have, and it's a scsi entity, be
1598                  * sure to unblock any attached scsi devices
1599                  */
1600                 lpfc_register_remote_port(vport, ndlp);
1601         }
1602         /*
1603          * if we added to Mapped list, but the remote port
1604          * registration failed or assigned a target id outside
1605          * our presentable range - move the node to the
1606          * Unmapped List
1607          */
1608         if (new_state == NLP_STE_MAPPED_NODE &&
1609             (!ndlp->rport ||
1610              ndlp->rport->scsi_target_id == -1 ||
1611              ndlp->rport->scsi_target_id >= LPFC_MAX_TARGET)) {
1612                 spin_lock_irq(shost->host_lock);
1613                 ndlp->nlp_flag |= NLP_TGT_NO_SCSIID;
1614                 spin_unlock_irq(shost->host_lock);
1615                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
1616         }
1617 }
1618
1619 static char *
1620 lpfc_nlp_state_name(char *buffer, size_t size, int state)
1621 {
1622         static char *states[] = {
1623                 [NLP_STE_UNUSED_NODE] = "UNUSED",
1624                 [NLP_STE_PLOGI_ISSUE] = "PLOGI",
1625                 [NLP_STE_ADISC_ISSUE] = "ADISC",
1626                 [NLP_STE_REG_LOGIN_ISSUE] = "REGLOGIN",
1627                 [NLP_STE_PRLI_ISSUE] = "PRLI",
1628                 [NLP_STE_UNMAPPED_NODE] = "UNMAPPED",
1629                 [NLP_STE_MAPPED_NODE] = "MAPPED",
1630                 [NLP_STE_NPR_NODE] = "NPR",
1631         };
1632
1633         if (state < NLP_STE_MAX_STATE && states[state])
1634                 strlcpy(buffer, states[state], size);
1635         else
1636                 snprintf(buffer, size, "unknown (%d)", state);
1637         return buffer;
1638 }
1639
1640 void
1641 lpfc_nlp_set_state(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1642                    int state)
1643 {
1644         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1645         int  old_state = ndlp->nlp_state;
1646         char name1[16], name2[16];
1647
1648         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
1649                          "0904 NPort state transition x%06x, %s -> %s\n",
1650                          ndlp->nlp_DID,
1651                          lpfc_nlp_state_name(name1, sizeof(name1), old_state),
1652                          lpfc_nlp_state_name(name2, sizeof(name2), state));
1653
1654         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
1655                 "node statechg    did:x%x old:%d ste:%d",
1656                 ndlp->nlp_DID, old_state, state);
1657
1658         if (old_state == NLP_STE_NPR_NODE &&
1659             state != NLP_STE_NPR_NODE)
1660                 lpfc_cancel_retry_delay_tmo(vport, ndlp);
1661         if (old_state == NLP_STE_UNMAPPED_NODE) {
1662                 ndlp->nlp_flag &= ~NLP_TGT_NO_SCSIID;
1663                 ndlp->nlp_type &= ~NLP_FC_NODE;
1664         }
1665
1666         if (list_empty(&ndlp->nlp_listp)) {
1667                 spin_lock_irq(shost->host_lock);
1668                 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes);
1669                 spin_unlock_irq(shost->host_lock);
1670         } else if (old_state)
1671                 lpfc_nlp_counters(vport, old_state, -1);
1672
1673         ndlp->nlp_state = state;
1674         lpfc_nlp_counters(vport, state, 1);
1675         lpfc_nlp_state_cleanup(vport, ndlp, old_state, state);
1676 }
1677
1678 void
1679 lpfc_enqueue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1680 {
1681         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1682
1683         if (list_empty(&ndlp->nlp_listp)) {
1684                 spin_lock_irq(shost->host_lock);
1685                 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes);
1686                 spin_unlock_irq(shost->host_lock);
1687         }
1688 }
1689
1690 void
1691 lpfc_dequeue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1692 {
1693         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1694
1695         lpfc_cancel_retry_delay_tmo(vport, ndlp);
1696         if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
1697                 lpfc_nlp_counters(vport, ndlp->nlp_state, -1);
1698         spin_lock_irq(shost->host_lock);
1699         list_del_init(&ndlp->nlp_listp);
1700         spin_unlock_irq(shost->host_lock);
1701         lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state,
1702                                 NLP_STE_UNUSED_NODE);
1703 }
1704
1705 static void
1706 lpfc_disable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1707 {
1708         lpfc_cancel_retry_delay_tmo(vport, ndlp);
1709         if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp))
1710                 lpfc_nlp_counters(vport, ndlp->nlp_state, -1);
1711         lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state,
1712                                 NLP_STE_UNUSED_NODE);
1713 }
1714
1715 struct lpfc_nodelist *
1716 lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
1717                  int state)
1718 {
1719         struct lpfc_hba *phba = vport->phba;
1720         uint32_t did;
1721         unsigned long flags;
1722
1723         if (!ndlp)
1724                 return NULL;
1725
1726         spin_lock_irqsave(&phba->ndlp_lock, flags);
1727         /* The ndlp should not be in memory free mode */
1728         if (NLP_CHK_FREE_REQ(ndlp)) {
1729                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
1730                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
1731                                 "0277 lpfc_enable_node: ndlp:x%p "
1732                                 "usgmap:x%x refcnt:%d\n",
1733                                 (void *)ndlp, ndlp->nlp_usg_map,
1734                                 atomic_read(&ndlp->kref.refcount));
1735                 return NULL;
1736         }
1737         /* The ndlp should not already be in active mode */
1738         if (NLP_CHK_NODE_ACT(ndlp)) {
1739                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
1740                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
1741                                 "0278 lpfc_enable_node: ndlp:x%p "
1742                                 "usgmap:x%x refcnt:%d\n",
1743                                 (void *)ndlp, ndlp->nlp_usg_map,
1744                                 atomic_read(&ndlp->kref.refcount));
1745                 return NULL;
1746         }
1747
1748         /* Keep the original DID */
1749         did = ndlp->nlp_DID;
1750
1751         /* re-initialize ndlp except of ndlp linked list pointer */
1752         memset((((char *)ndlp) + sizeof (struct list_head)), 0,
1753                 sizeof (struct lpfc_nodelist) - sizeof (struct list_head));
1754         INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
1755         INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
1756         init_timer(&ndlp->nlp_delayfunc);
1757         ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
1758         ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
1759         ndlp->nlp_DID = did;
1760         ndlp->vport = vport;
1761         ndlp->nlp_sid = NLP_NO_SID;
1762         /* ndlp management re-initialize */
1763         kref_init(&ndlp->kref);
1764         NLP_INT_NODE_ACT(ndlp);
1765
1766         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
1767
1768         if (state != NLP_STE_UNUSED_NODE)
1769                 lpfc_nlp_set_state(vport, ndlp, state);
1770
1771         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
1772                 "node enable:       did:x%x",
1773                 ndlp->nlp_DID, 0, 0);
1774         return ndlp;
1775 }
1776
1777 void
1778 lpfc_drop_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1779 {
1780         /*
1781          * Use of lpfc_drop_node and UNUSED list: lpfc_drop_node should
1782          * be used if we wish to issue the "last" lpfc_nlp_put() to remove
1783          * the ndlp from the vport. The ndlp marked as UNUSED on the list
1784          * until ALL other outstanding threads have completed. We check
1785          * that the ndlp not already in the UNUSED state before we proceed.
1786          */
1787         if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
1788                 return;
1789         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE);
1790         lpfc_nlp_put(ndlp);
1791         return;
1792 }
1793
1794 /*
1795  * Start / ReStart rescue timer for Discovery / RSCN handling
1796  */
1797 void
1798 lpfc_set_disctmo(struct lpfc_vport *vport)
1799 {
1800         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1801         struct lpfc_hba  *phba = vport->phba;
1802         uint32_t tmo;
1803
1804         if (vport->port_state == LPFC_LOCAL_CFG_LINK) {
1805                 /* For FAN, timeout should be greater then edtov */
1806                 tmo = (((phba->fc_edtov + 999) / 1000) + 1);
1807         } else {
1808                 /* Normal discovery timeout should be > then ELS/CT timeout
1809                  * FC spec states we need 3 * ratov for CT requests
1810                  */
1811                 tmo = ((phba->fc_ratov * 3) + 3);
1812         }
1813
1814
1815         if (!timer_pending(&vport->fc_disctmo)) {
1816                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1817                         "set disc timer:  tmo:x%x state:x%x flg:x%x",
1818                         tmo, vport->port_state, vport->fc_flag);
1819         }
1820
1821         mod_timer(&vport->fc_disctmo, jiffies + HZ * tmo);
1822         spin_lock_irq(shost->host_lock);
1823         vport->fc_flag |= FC_DISC_TMO;
1824         spin_unlock_irq(shost->host_lock);
1825
1826         /* Start Discovery Timer state <hba_state> */
1827         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1828                          "0247 Start Discovery Timer state x%x "
1829                          "Data: x%x x%lx x%x x%x\n",
1830                          vport->port_state, tmo,
1831                          (unsigned long)&vport->fc_disctmo, vport->fc_plogi_cnt,
1832                          vport->fc_adisc_cnt);
1833
1834         return;
1835 }
1836
1837 /*
1838  * Cancel rescue timer for Discovery / RSCN handling
1839  */
1840 int
1841 lpfc_can_disctmo(struct lpfc_vport *vport)
1842 {
1843         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
1844         unsigned long iflags;
1845
1846         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
1847                 "can disc timer:  state:x%x rtry:x%x flg:x%x",
1848                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
1849
1850         /* Turn off discovery timer if its running */
1851         if (vport->fc_flag & FC_DISC_TMO) {
1852                 spin_lock_irqsave(shost->host_lock, iflags);
1853                 vport->fc_flag &= ~FC_DISC_TMO;
1854                 spin_unlock_irqrestore(shost->host_lock, iflags);
1855                 del_timer_sync(&vport->fc_disctmo);
1856                 spin_lock_irqsave(&vport->work_port_lock, iflags);
1857                 vport->work_port_events &= ~WORKER_DISC_TMO;
1858                 spin_unlock_irqrestore(&vport->work_port_lock, iflags);
1859         }
1860
1861         /* Cancel Discovery Timer state <hba_state> */
1862         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
1863                          "0248 Cancel Discovery Timer state x%x "
1864                          "Data: x%x x%x x%x\n",
1865                          vport->port_state, vport->fc_flag,
1866                          vport->fc_plogi_cnt, vport->fc_adisc_cnt);
1867         return 0;
1868 }
1869
1870 /*
1871  * Check specified ring for outstanding IOCB on the SLI queue
1872  * Return true if iocb matches the specified nport
1873  */
1874 int
1875 lpfc_check_sli_ndlp(struct lpfc_hba *phba,
1876                     struct lpfc_sli_ring *pring,
1877                     struct lpfc_iocbq *iocb,
1878                     struct lpfc_nodelist *ndlp)
1879 {
1880         struct lpfc_sli *psli = &phba->sli;
1881         IOCB_t *icmd = &iocb->iocb;
1882         struct lpfc_vport    *vport = ndlp->vport;
1883
1884         if (iocb->vport != vport)
1885                 return 0;
1886
1887         if (pring->ringno == LPFC_ELS_RING) {
1888                 switch (icmd->ulpCommand) {
1889                 case CMD_GEN_REQUEST64_CR:
1890                         if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi)
1891                                 return 1;
1892                 case CMD_ELS_REQUEST64_CR:
1893                         if (icmd->un.elsreq64.remoteID == ndlp->nlp_DID)
1894                                 return 1;
1895                 case CMD_XMIT_ELS_RSP64_CX:
1896                         if (iocb->context1 == (uint8_t *) ndlp)
1897                                 return 1;
1898                 }
1899         } else if (pring->ringno == psli->extra_ring) {
1900
1901         } else if (pring->ringno == psli->fcp_ring) {
1902                 /* Skip match check if waiting to relogin to FCP target */
1903                 if ((ndlp->nlp_type & NLP_FCP_TARGET) &&
1904                     (ndlp->nlp_flag & NLP_DELAY_TMO)) {
1905                         return 0;
1906                 }
1907                 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) {
1908                         return 1;
1909                 }
1910         } else if (pring->ringno == psli->next_ring) {
1911
1912         }
1913         return 0;
1914 }
1915
1916 /*
1917  * Free resources / clean up outstanding I/Os
1918  * associated with nlp_rpi in the LPFC_NODELIST entry.
1919  */
1920 static int
1921 lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
1922 {
1923         LIST_HEAD(completions);
1924         struct lpfc_sli *psli;
1925         struct lpfc_sli_ring *pring;
1926         struct lpfc_iocbq *iocb, *next_iocb;
1927         IOCB_t *icmd;
1928         uint32_t rpi, i;
1929
1930         lpfc_fabric_abort_nport(ndlp);
1931
1932         /*
1933          * Everything that matches on txcmplq will be returned
1934          * by firmware with a no rpi error.
1935          */
1936         psli = &phba->sli;
1937         rpi = ndlp->nlp_rpi;
1938         if (rpi) {
1939                 /* Now process each ring */
1940                 for (i = 0; i < psli->num_rings; i++) {
1941                         pring = &psli->ring[i];
1942
1943                         spin_lock_irq(&phba->hbalock);
1944                         list_for_each_entry_safe(iocb, next_iocb, &pring->txq,
1945                                                  list) {
1946                                 /*
1947                                  * Check to see if iocb matches the nport we are
1948                                  * looking for
1949                                  */
1950                                 if ((lpfc_check_sli_ndlp(phba, pring, iocb,
1951                                                          ndlp))) {
1952                                         /* It matches, so deque and call compl
1953                                            with an error */
1954                                         list_move_tail(&iocb->list,
1955                                                        &completions);
1956                                         pring->txq_cnt--;
1957                                 }
1958                         }
1959                         spin_unlock_irq(&phba->hbalock);
1960                 }
1961         }
1962
1963         while (!list_empty(&completions)) {
1964                 iocb = list_get_first(&completions, struct lpfc_iocbq, list);
1965                 list_del_init(&iocb->list);
1966
1967                 if (!iocb->iocb_cmpl)
1968                         lpfc_sli_release_iocbq(phba, iocb);
1969                 else {
1970                         icmd = &iocb->iocb;
1971                         icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
1972                         icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
1973                         (iocb->iocb_cmpl)(phba, iocb, iocb);
1974                 }
1975         }
1976
1977         return 0;
1978 }
1979
1980 /*
1981  * Free rpi associated with LPFC_NODELIST entry.
1982  * This routine is called from lpfc_freenode(), when we are removing
1983  * a LPFC_NODELIST entry. It is also called if the driver initiates a
1984  * LOGO that completes successfully, and we are waiting to PLOGI back
1985  * to the remote NPort. In addition, it is called after we receive
1986  * and unsolicated ELS cmd, send back a rsp, the rsp completes and
1987  * we are waiting to PLOGI back to the remote NPort.
1988  */
1989 int
1990 lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
1991 {
1992         struct lpfc_hba *phba = vport->phba;
1993         LPFC_MBOXQ_t    *mbox;
1994         int rc;
1995
1996         if (ndlp->nlp_rpi) {
1997                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1998                 if (mbox) {
1999                         lpfc_unreg_login(phba, vport->vpi, ndlp->nlp_rpi, mbox);
2000                         mbox->vport = vport;
2001                         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2002                         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
2003                         if (rc == MBX_NOT_FINISHED)
2004                                 mempool_free(mbox, phba->mbox_mem_pool);
2005                 }
2006                 lpfc_no_rpi(phba, ndlp);
2007                 ndlp->nlp_rpi = 0;
2008                 return 1;
2009         }
2010         return 0;
2011 }
2012
2013 void
2014 lpfc_unreg_all_rpis(struct lpfc_vport *vport)
2015 {
2016         struct lpfc_hba  *phba  = vport->phba;
2017         LPFC_MBOXQ_t     *mbox;
2018         int rc;
2019
2020         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2021         if (mbox) {
2022                 lpfc_unreg_login(phba, vport->vpi, 0xffff, mbox);
2023                 mbox->vport = vport;
2024                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2025                 mbox->context1 = NULL;
2026                 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2027                 if (rc == MBX_NOT_FINISHED) {
2028                         mempool_free(mbox, phba->mbox_mem_pool);
2029                 }
2030         }
2031 }
2032
2033 void
2034 lpfc_unreg_default_rpis(struct lpfc_vport *vport)
2035 {
2036         struct lpfc_hba  *phba  = vport->phba;
2037         LPFC_MBOXQ_t     *mbox;
2038         int rc;
2039
2040         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2041         if (mbox) {
2042                 lpfc_unreg_did(phba, vport->vpi, 0xffffffff, mbox);
2043                 mbox->vport = vport;
2044                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2045                 mbox->context1 = NULL;
2046                 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
2047                 if (rc == MBX_NOT_FINISHED) {
2048                         lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT,
2049                                          "1815 Could not issue "
2050                                          "unreg_did (default rpis)\n");
2051                         mempool_free(mbox, phba->mbox_mem_pool);
2052                 }
2053         }
2054 }
2055
2056 /*
2057  * Free resources associated with LPFC_NODELIST entry
2058  * so it can be freed.
2059  */
2060 static int
2061 lpfc_cleanup_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
2062 {
2063         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2064         struct lpfc_hba  *phba = vport->phba;
2065         LPFC_MBOXQ_t *mb, *nextmb;
2066         struct lpfc_dmabuf *mp;
2067
2068         /* Cleanup node for NPort <nlp_DID> */
2069         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
2070                          "0900 Cleanup node for NPort x%x "
2071                          "Data: x%x x%x x%x\n",
2072                          ndlp->nlp_DID, ndlp->nlp_flag,
2073                          ndlp->nlp_state, ndlp->nlp_rpi);
2074         if (NLP_CHK_FREE_REQ(ndlp)) {
2075                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
2076                                 "0280 lpfc_cleanup_node: ndlp:x%p "
2077                                 "usgmap:x%x refcnt:%d\n",
2078                                 (void *)ndlp, ndlp->nlp_usg_map,
2079                                 atomic_read(&ndlp->kref.refcount));
2080                 lpfc_dequeue_node(vport, ndlp);
2081         } else {
2082                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE,
2083                                 "0281 lpfc_cleanup_node: ndlp:x%p "
2084                                 "usgmap:x%x refcnt:%d\n",
2085                                 (void *)ndlp, ndlp->nlp_usg_map,
2086                                 atomic_read(&ndlp->kref.refcount));
2087                 lpfc_disable_node(vport, ndlp);
2088         }
2089
2090         /* cleanup any ndlp on mbox q waiting for reglogin cmpl */
2091         if ((mb = phba->sli.mbox_active)) {
2092                 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) &&
2093                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
2094                         mb->context2 = NULL;
2095                         mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2096                 }
2097         }
2098
2099         spin_lock_irq(&phba->hbalock);
2100         list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
2101                 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) &&
2102                     (ndlp == (struct lpfc_nodelist *) mb->context2)) {
2103                         mp = (struct lpfc_dmabuf *) (mb->context1);
2104                         if (mp) {
2105                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
2106                                 kfree(mp);
2107                         }
2108                         list_del(&mb->list);
2109                         mempool_free(mb, phba->mbox_mem_pool);
2110                         /* We shall not invoke the lpfc_nlp_put to decrement
2111                          * the ndlp reference count as we are in the process
2112                          * of lpfc_nlp_release.
2113                          */
2114                 }
2115         }
2116         spin_unlock_irq(&phba->hbalock);
2117
2118         lpfc_els_abort(phba, ndlp);
2119
2120         spin_lock_irq(shost->host_lock);
2121         ndlp->nlp_flag &= ~NLP_DELAY_TMO;
2122         spin_unlock_irq(shost->host_lock);
2123
2124         ndlp->nlp_last_elscmd = 0;
2125         del_timer_sync(&ndlp->nlp_delayfunc);
2126
2127         list_del_init(&ndlp->els_retry_evt.evt_listp);
2128         list_del_init(&ndlp->dev_loss_evt.evt_listp);
2129
2130         lpfc_unreg_rpi(vport, ndlp);
2131
2132         return 0;
2133 }
2134
2135 /*
2136  * Check to see if we can free the nlp back to the freelist.
2137  * If we are in the middle of using the nlp in the discovery state
2138  * machine, defer the free till we reach the end of the state machine.
2139  */
2140 static void
2141 lpfc_nlp_remove(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
2142 {
2143         struct lpfc_hba  *phba = vport->phba;
2144         struct lpfc_rport_data *rdata;
2145         LPFC_MBOXQ_t *mbox;
2146         int rc;
2147
2148         lpfc_cancel_retry_delay_tmo(vport, ndlp);
2149         if (ndlp->nlp_flag & NLP_DEFER_RM && !ndlp->nlp_rpi) {
2150                 /* For this case we need to cleanup the default rpi
2151                  * allocated by the firmware.
2152                  */
2153                 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))
2154                         != NULL) {
2155                         rc = lpfc_reg_login(phba, vport->vpi, ndlp->nlp_DID,
2156                             (uint8_t *) &vport->fc_sparam, mbox, 0);
2157                         if (rc) {
2158                                 mempool_free(mbox, phba->mbox_mem_pool);
2159                         }
2160                         else {
2161                                 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG;
2162                                 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi;
2163                                 mbox->vport = vport;
2164                                 mbox->context2 = NULL;
2165                                 rc =lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
2166                                 if (rc == MBX_NOT_FINISHED) {
2167                                         mempool_free(mbox, phba->mbox_mem_pool);
2168                                 }
2169                         }
2170                 }
2171         }
2172         lpfc_cleanup_node(vport, ndlp);
2173
2174         /*
2175          * We can get here with a non-NULL ndlp->rport because when we
2176          * unregister a rport we don't break the rport/node linkage.  So if we
2177          * do, make sure we don't leaving any dangling pointers behind.
2178          */
2179         if (ndlp->rport) {
2180                 rdata = ndlp->rport->dd_data;
2181                 rdata->pnode = NULL;
2182                 ndlp->rport = NULL;
2183         }
2184 }
2185
2186 static int
2187 lpfc_matchdid(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2188               uint32_t did)
2189 {
2190         D_ID mydid, ndlpdid, matchdid;
2191
2192         if (did == Bcast_DID)
2193                 return 0;
2194
2195         /* First check for Direct match */
2196         if (ndlp->nlp_DID == did)
2197                 return 1;
2198
2199         /* Next check for area/domain identically equals 0 match */
2200         mydid.un.word = vport->fc_myDID;
2201         if ((mydid.un.b.domain == 0) && (mydid.un.b.area == 0)) {
2202                 return 0;
2203         }
2204
2205         matchdid.un.word = did;
2206         ndlpdid.un.word = ndlp->nlp_DID;
2207         if (matchdid.un.b.id == ndlpdid.un.b.id) {
2208                 if ((mydid.un.b.domain == matchdid.un.b.domain) &&
2209                     (mydid.un.b.area == matchdid.un.b.area)) {
2210                         if ((ndlpdid.un.b.domain == 0) &&
2211                             (ndlpdid.un.b.area == 0)) {
2212                                 if (ndlpdid.un.b.id)
2213                                         return 1;
2214                         }
2215                         return 0;
2216                 }
2217
2218                 matchdid.un.word = ndlp->nlp_DID;
2219                 if ((mydid.un.b.domain == ndlpdid.un.b.domain) &&
2220                     (mydid.un.b.area == ndlpdid.un.b.area)) {
2221                         if ((matchdid.un.b.domain == 0) &&
2222                             (matchdid.un.b.area == 0)) {
2223                                 if (matchdid.un.b.id)
2224                                         return 1;
2225                         }
2226                 }
2227         }
2228         return 0;
2229 }
2230
2231 /* Search for a nodelist entry */
2232 static struct lpfc_nodelist *
2233 __lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did)
2234 {
2235         struct lpfc_nodelist *ndlp;
2236         uint32_t data1;
2237
2238         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2239                 if (lpfc_matchdid(vport, ndlp, did)) {
2240                         data1 = (((uint32_t) ndlp->nlp_state << 24) |
2241                                  ((uint32_t) ndlp->nlp_xri << 16) |
2242                                  ((uint32_t) ndlp->nlp_type << 8) |
2243                                  ((uint32_t) ndlp->nlp_rpi & 0xff));
2244                         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
2245                                          "0929 FIND node DID "
2246                                          "Data: x%p x%x x%x x%x\n",
2247                                          ndlp, ndlp->nlp_DID,
2248                                          ndlp->nlp_flag, data1);
2249                         return ndlp;
2250                 }
2251         }
2252
2253         /* FIND node did <did> NOT FOUND */
2254         lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE,
2255                          "0932 FIND node did x%x NOT FOUND.\n", did);
2256         return NULL;
2257 }
2258
2259 struct lpfc_nodelist *
2260 lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did)
2261 {
2262         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2263         struct lpfc_nodelist *ndlp;
2264
2265         spin_lock_irq(shost->host_lock);
2266         ndlp = __lpfc_findnode_did(vport, did);
2267         spin_unlock_irq(shost->host_lock);
2268         return ndlp;
2269 }
2270
2271 struct lpfc_nodelist *
2272 lpfc_setup_disc_node(struct lpfc_vport *vport, uint32_t did)
2273 {
2274         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2275         struct lpfc_nodelist *ndlp;
2276
2277         ndlp = lpfc_findnode_did(vport, did);
2278         if (!ndlp) {
2279                 if ((vport->fc_flag & FC_RSCN_MODE) != 0 &&
2280                     lpfc_rscn_payload_check(vport, did) == 0)
2281                         return NULL;
2282                 ndlp = (struct lpfc_nodelist *)
2283                      mempool_alloc(vport->phba->nlp_mem_pool, GFP_KERNEL);
2284                 if (!ndlp)
2285                         return NULL;
2286                 lpfc_nlp_init(vport, ndlp, did);
2287                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2288                 spin_lock_irq(shost->host_lock);
2289                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2290                 spin_unlock_irq(shost->host_lock);
2291                 return ndlp;
2292         } else if (!NLP_CHK_NODE_ACT(ndlp)) {
2293                 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_NPR_NODE);
2294                 if (!ndlp)
2295                         return NULL;
2296                 spin_lock_irq(shost->host_lock);
2297                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2298                 spin_unlock_irq(shost->host_lock);
2299                 return ndlp;
2300         }
2301
2302         if ((vport->fc_flag & FC_RSCN_MODE) &&
2303             !(vport->fc_flag & FC_NDISC_ACTIVE)) {
2304                 if (lpfc_rscn_payload_check(vport, did)) {
2305                         /* If we've already recieved a PLOGI from this NPort
2306                          * we don't need to try to discover it again.
2307                          */
2308                         if (ndlp->nlp_flag & NLP_RCV_PLOGI)
2309                                 return NULL;
2310
2311                         spin_lock_irq(shost->host_lock);
2312                         ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2313                         spin_unlock_irq(shost->host_lock);
2314
2315                         /* Since this node is marked for discovery,
2316                          * delay timeout is not needed.
2317                          */
2318                         lpfc_cancel_retry_delay_tmo(vport, ndlp);
2319                 } else
2320                         ndlp = NULL;
2321         } else {
2322                 /* If we've already recieved a PLOGI from this NPort,
2323                  * or we are already in the process of discovery on it,
2324                  * we don't need to try to discover it again.
2325                  */
2326                 if (ndlp->nlp_state == NLP_STE_ADISC_ISSUE ||
2327                     ndlp->nlp_state == NLP_STE_PLOGI_ISSUE ||
2328                     ndlp->nlp_flag & NLP_RCV_PLOGI)
2329                         return NULL;
2330                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
2331                 spin_lock_irq(shost->host_lock);
2332                 ndlp->nlp_flag |= NLP_NPR_2B_DISC;
2333                 spin_unlock_irq(shost->host_lock);
2334         }
2335         return ndlp;
2336 }
2337
2338 /* Build a list of nodes to discover based on the loopmap */
2339 void
2340 lpfc_disc_list_loopmap(struct lpfc_vport *vport)
2341 {
2342         struct lpfc_hba  *phba = vport->phba;
2343         int j;
2344         uint32_t alpa, index;
2345
2346         if (!lpfc_is_link_up(phba))
2347                 return;
2348
2349         if (phba->fc_topology != TOPOLOGY_LOOP)
2350                 return;
2351
2352         /* Check for loop map present or not */
2353         if (phba->alpa_map[0]) {
2354                 for (j = 1; j <= phba->alpa_map[0]; j++) {
2355                         alpa = phba->alpa_map[j];
2356                         if (((vport->fc_myDID & 0xff) == alpa) || (alpa == 0))
2357                                 continue;
2358                         lpfc_setup_disc_node(vport, alpa);
2359                 }
2360         } else {
2361                 /* No alpamap, so try all alpa's */
2362                 for (j = 0; j < FC_MAXLOOP; j++) {
2363                         /* If cfg_scan_down is set, start from highest
2364                          * ALPA (0xef) to lowest (0x1).
2365                          */
2366                         if (vport->cfg_scan_down)
2367                                 index = j;
2368                         else
2369                                 index = FC_MAXLOOP - j - 1;
2370                         alpa = lpfcAlpaArray[index];
2371                         if ((vport->fc_myDID & 0xff) == alpa)
2372                                 continue;
2373                         lpfc_setup_disc_node(vport, alpa);
2374                 }
2375         }
2376         return;
2377 }
2378
2379 void
2380 lpfc_issue_clear_la(struct lpfc_hba *phba, struct lpfc_vport *vport)
2381 {
2382         LPFC_MBOXQ_t *mbox;
2383         struct lpfc_sli *psli = &phba->sli;
2384         struct lpfc_sli_ring *extra_ring = &psli->ring[psli->extra_ring];
2385         struct lpfc_sli_ring *fcp_ring   = &psli->ring[psli->fcp_ring];
2386         struct lpfc_sli_ring *next_ring  = &psli->ring[psli->next_ring];
2387         int  rc;
2388
2389         /*
2390          * if it's not a physical port or if we already send
2391          * clear_la then don't send it.
2392          */
2393         if ((phba->link_state >= LPFC_CLEAR_LA) ||
2394             (vport->port_type != LPFC_PHYSICAL_PORT))
2395                 return;
2396
2397                         /* Link up discovery */
2398         if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL)) != NULL) {
2399                 phba->link_state = LPFC_CLEAR_LA;
2400                 lpfc_clear_la(phba, mbox);
2401                 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la;
2402                 mbox->vport = vport;
2403                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
2404                 if (rc == MBX_NOT_FINISHED) {
2405                         mempool_free(mbox, phba->mbox_mem_pool);
2406                         lpfc_disc_flush_list(vport);
2407                         extra_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
2408                         fcp_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
2409                         next_ring->flag &= ~LPFC_STOP_IOCB_EVENT;
2410                         phba->link_state = LPFC_HBA_ERROR;
2411                 }
2412         }
2413 }
2414
2415 /* Reg_vpi to tell firmware to resume normal operations */
2416 void
2417 lpfc_issue_reg_vpi(struct lpfc_hba *phba, struct lpfc_vport *vport)
2418 {
2419         LPFC_MBOXQ_t *regvpimbox;
2420
2421         regvpimbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2422         if (regvpimbox) {
2423                 lpfc_reg_vpi(phba, vport->vpi, vport->fc_myDID, regvpimbox);
2424                 regvpimbox->mbox_cmpl = lpfc_mbx_cmpl_reg_vpi;
2425                 regvpimbox->vport = vport;
2426                 if (lpfc_sli_issue_mbox(phba, regvpimbox, MBX_NOWAIT)
2427                                         == MBX_NOT_FINISHED) {
2428                         mempool_free(regvpimbox, phba->mbox_mem_pool);
2429                 }
2430         }
2431 }
2432
2433 /* Start Link up / RSCN discovery on NPR nodes */
2434 void
2435 lpfc_disc_start(struct lpfc_vport *vport)
2436 {
2437         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2438         struct lpfc_hba  *phba = vport->phba;
2439         uint32_t num_sent;
2440         uint32_t clear_la_pending;
2441         int did_changed;
2442
2443         if (!lpfc_is_link_up(phba))
2444                 return;
2445
2446         if (phba->link_state == LPFC_CLEAR_LA)
2447                 clear_la_pending = 1;
2448         else
2449                 clear_la_pending = 0;
2450
2451         if (vport->port_state < LPFC_VPORT_READY)
2452                 vport->port_state = LPFC_DISC_AUTH;
2453
2454         lpfc_set_disctmo(vport);
2455
2456         if (vport->fc_prevDID == vport->fc_myDID)
2457                 did_changed = 0;
2458         else
2459                 did_changed = 1;
2460
2461         vport->fc_prevDID = vport->fc_myDID;
2462         vport->num_disc_nodes = 0;
2463
2464         /* Start Discovery state <hba_state> */
2465         lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY,
2466                          "0202 Start Discovery hba state x%x "
2467                          "Data: x%x x%x x%x\n",
2468                          vport->port_state, vport->fc_flag, vport->fc_plogi_cnt,
2469                          vport->fc_adisc_cnt);
2470
2471         /* First do ADISCs - if any */
2472         num_sent = lpfc_els_disc_adisc(vport);
2473
2474         if (num_sent)
2475                 return;
2476
2477         /*
2478          * For SLI3, cmpl_reg_vpi will set port_state to READY, and
2479          * continue discovery.
2480          */
2481         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
2482             !(vport->fc_flag & FC_PT2PT) &&
2483             !(vport->fc_flag & FC_RSCN_MODE)) {
2484                 lpfc_issue_reg_vpi(phba, vport);
2485                 return;
2486         }
2487
2488         /*
2489          * For SLI2, we need to set port_state to READY and continue
2490          * discovery.
2491          */
2492         if (vport->port_state < LPFC_VPORT_READY && !clear_la_pending) {
2493                 /* If we get here, there is nothing to ADISC */
2494                 if (vport->port_type == LPFC_PHYSICAL_PORT)
2495                         lpfc_issue_clear_la(phba, vport);
2496
2497                 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) {
2498                         vport->num_disc_nodes = 0;
2499                         /* go thru NPR nodes and issue ELS PLOGIs */
2500                         if (vport->fc_npr_cnt)
2501                                 lpfc_els_disc_plogi(vport);
2502
2503                         if (!vport->num_disc_nodes) {
2504                                 spin_lock_irq(shost->host_lock);
2505                                 vport->fc_flag &= ~FC_NDISC_ACTIVE;
2506                                 spin_unlock_irq(shost->host_lock);
2507                                 lpfc_can_disctmo(vport);
2508                         }
2509                 }
2510                 vport->port_state = LPFC_VPORT_READY;
2511         } else {
2512                 /* Next do PLOGIs - if any */
2513                 num_sent = lpfc_els_disc_plogi(vport);
2514
2515                 if (num_sent)
2516                         return;
2517
2518                 if (vport->fc_flag & FC_RSCN_MODE) {
2519                         /* Check to see if more RSCNs came in while we
2520                          * were processing this one.
2521                          */
2522                         if ((vport->fc_rscn_id_cnt == 0) &&
2523                             (!(vport->fc_flag & FC_RSCN_DISCOVERY))) {
2524                                 spin_lock_irq(shost->host_lock);
2525                                 vport->fc_flag &= ~FC_RSCN_MODE;
2526                                 spin_unlock_irq(shost->host_lock);
2527                                 lpfc_can_disctmo(vport);
2528                         } else
2529                                 lpfc_els_handle_rscn(vport);
2530                 }
2531         }
2532         return;
2533 }
2534
2535 /*
2536  *  Ignore completion for all IOCBs on tx and txcmpl queue for ELS
2537  *  ring the match the sppecified nodelist.
2538  */
2539 static void
2540 lpfc_free_tx(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
2541 {
2542         LIST_HEAD(completions);
2543         struct lpfc_sli *psli;
2544         IOCB_t     *icmd;
2545         struct lpfc_iocbq    *iocb, *next_iocb;
2546         struct lpfc_sli_ring *pring;
2547
2548         psli = &phba->sli;
2549         pring = &psli->ring[LPFC_ELS_RING];
2550
2551         /* Error matching iocb on txq or txcmplq
2552          * First check the txq.
2553          */
2554         spin_lock_irq(&phba->hbalock);
2555         list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) {
2556                 if (iocb->context1 != ndlp) {
2557                         continue;
2558                 }
2559                 icmd = &iocb->iocb;
2560                 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) ||
2561                     (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) {
2562
2563                         list_move_tail(&iocb->list, &completions);
2564                         pring->txq_cnt--;
2565                 }
2566         }
2567
2568         /* Next check the txcmplq */
2569         list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) {
2570                 if (iocb->context1 != ndlp) {
2571                         continue;
2572                 }
2573                 icmd = &iocb->iocb;
2574                 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR ||
2575                     icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX) {
2576                         lpfc_sli_issue_abort_iotag(phba, pring, iocb);
2577                 }
2578         }
2579         spin_unlock_irq(&phba->hbalock);
2580
2581         while (!list_empty(&completions)) {
2582                 iocb = list_get_first(&completions, struct lpfc_iocbq, list);
2583                 list_del_init(&iocb->list);
2584
2585                 if (!iocb->iocb_cmpl)
2586                         lpfc_sli_release_iocbq(phba, iocb);
2587                 else {
2588                         icmd = &iocb->iocb;
2589                         icmd->ulpStatus = IOSTAT_LOCAL_REJECT;
2590                         icmd->un.ulpWord[4] = IOERR_SLI_ABORTED;
2591                         (iocb->iocb_cmpl) (phba, iocb, iocb);
2592                 }
2593         }
2594 }
2595
2596 static void
2597 lpfc_disc_flush_list(struct lpfc_vport *vport)
2598 {
2599         struct lpfc_nodelist *ndlp, *next_ndlp;
2600         struct lpfc_hba *phba = vport->phba;
2601
2602         if (vport->fc_plogi_cnt || vport->fc_adisc_cnt) {
2603                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
2604                                          nlp_listp) {
2605                         if (!NLP_CHK_NODE_ACT(ndlp))
2606                                 continue;
2607                         if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE ||
2608                             ndlp->nlp_state == NLP_STE_ADISC_ISSUE) {
2609                                 lpfc_free_tx(phba, ndlp);
2610                         }
2611                 }
2612         }
2613 }
2614
2615 void
2616 lpfc_cleanup_discovery_resources(struct lpfc_vport *vport)
2617 {
2618         lpfc_els_flush_rscn(vport);
2619         lpfc_els_flush_cmd(vport);
2620         lpfc_disc_flush_list(vport);
2621 }
2622
2623 /*****************************************************************************/
2624 /*
2625  * NAME:     lpfc_disc_timeout
2626  *
2627  * FUNCTION: Fibre Channel driver discovery timeout routine.
2628  *
2629  * EXECUTION ENVIRONMENT: interrupt only
2630  *
2631  * CALLED FROM:
2632  *      Timer function
2633  *
2634  * RETURNS:
2635  *      none
2636  */
2637 /*****************************************************************************/
2638 void
2639 lpfc_disc_timeout(unsigned long ptr)
2640 {
2641         struct lpfc_vport *vport = (struct lpfc_vport *) ptr;
2642         struct lpfc_hba   *phba = vport->phba;
2643         uint32_t tmo_posted;
2644         unsigned long flags = 0;
2645
2646         if (unlikely(!phba))
2647                 return;
2648
2649         spin_lock_irqsave(&vport->work_port_lock, flags);
2650         tmo_posted = vport->work_port_events & WORKER_DISC_TMO;
2651         if (!tmo_posted)
2652                 vport->work_port_events |= WORKER_DISC_TMO;
2653         spin_unlock_irqrestore(&vport->work_port_lock, flags);
2654
2655         if (!tmo_posted)
2656                 lpfc_worker_wake_up(phba);
2657         return;
2658 }
2659
2660 static void
2661 lpfc_disc_timeout_handler(struct lpfc_vport *vport)
2662 {
2663         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2664         struct lpfc_hba  *phba = vport->phba;
2665         struct lpfc_sli  *psli = &phba->sli;
2666         struct lpfc_nodelist *ndlp, *next_ndlp;
2667         LPFC_MBOXQ_t *initlinkmbox;
2668         int rc, clrlaerr = 0;
2669
2670         if (!(vport->fc_flag & FC_DISC_TMO))
2671                 return;
2672
2673         spin_lock_irq(shost->host_lock);
2674         vport->fc_flag &= ~FC_DISC_TMO;
2675         spin_unlock_irq(shost->host_lock);
2676
2677         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
2678                 "disc timeout:    state:x%x rtry:x%x flg:x%x",
2679                 vport->port_state, vport->fc_ns_retry, vport->fc_flag);
2680
2681         switch (vport->port_state) {
2682
2683         case LPFC_LOCAL_CFG_LINK:
2684         /* port_state is identically  LPFC_LOCAL_CFG_LINK while waiting for
2685          * FAN
2686          */
2687                                 /* FAN timeout */
2688                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY,
2689                                  "0221 FAN timeout\n");
2690                 /* Start discovery by sending FLOGI, clean up old rpis */
2691                 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes,
2692                                          nlp_listp) {
2693                         if (!NLP_CHK_NODE_ACT(ndlp))
2694                                 continue;
2695                         if (ndlp->nlp_state != NLP_STE_NPR_NODE)
2696                                 continue;
2697                         if (ndlp->nlp_type & NLP_FABRIC) {
2698                                 /* Clean up the ndlp on Fabric connections */
2699                                 lpfc_drop_node(vport, ndlp);
2700
2701                         } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) {
2702                                 /* Fail outstanding IO now since device
2703                                  * is marked for PLOGI.
2704                                  */
2705                                 lpfc_unreg_rpi(vport, ndlp);
2706                         }
2707                 }
2708                 if (vport->port_state != LPFC_FLOGI) {
2709                         lpfc_initial_flogi(vport);
2710                         return;
2711                 }
2712                 break;
2713
2714         case LPFC_FDISC:
2715         case LPFC_FLOGI:
2716         /* port_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */
2717                 /* Initial FLOGI timeout */
2718                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2719                                  "0222 Initial %s timeout\n",
2720                                  vport->vpi ? "FDISC" : "FLOGI");
2721
2722                 /* Assume no Fabric and go on with discovery.
2723                  * Check for outstanding ELS FLOGI to abort.
2724                  */
2725
2726                 /* FLOGI failed, so just use loop map to make discovery list */
2727                 lpfc_disc_list_loopmap(vport);
2728
2729                 /* Start discovery */
2730                 lpfc_disc_start(vport);
2731                 break;
2732
2733         case LPFC_FABRIC_CFG_LINK:
2734         /* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for
2735            NameServer login */
2736                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2737                                  "0223 Timeout while waiting for "
2738                                  "NameServer login\n");
2739                 /* Next look for NameServer ndlp */
2740                 ndlp = lpfc_findnode_did(vport, NameServer_DID);
2741                 if (ndlp && NLP_CHK_NODE_ACT(ndlp))
2742                         lpfc_els_abort(phba, ndlp);
2743
2744                 /* ReStart discovery */
2745                 goto restart_disc;
2746
2747         case LPFC_NS_QRY:
2748         /* Check for wait for NameServer Rsp timeout */
2749                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2750                                  "0224 NameServer Query timeout "
2751                                  "Data: x%x x%x\n",
2752                                  vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
2753
2754                 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) {
2755                         /* Try it one more time */
2756                         vport->fc_ns_retry++;
2757                         rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT,
2758                                          vport->fc_ns_retry, 0);
2759                         if (rc == 0)
2760                                 break;
2761                 }
2762                 vport->fc_ns_retry = 0;
2763
2764 restart_disc:
2765                 /*
2766                  * Discovery is over.
2767                  * set port_state to PORT_READY if SLI2.
2768                  * cmpl_reg_vpi will set port_state to READY for SLI3.
2769                  */
2770                 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2771                         lpfc_issue_reg_vpi(phba, vport);
2772                 else  { /* NPIV Not enabled */
2773                         lpfc_issue_clear_la(phba, vport);
2774                         vport->port_state = LPFC_VPORT_READY;
2775                 }
2776
2777                 /* Setup and issue mailbox INITIALIZE LINK command */
2778                 initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2779                 if (!initlinkmbox) {
2780                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2781                                          "0206 Device Discovery "
2782                                          "completion error\n");
2783                         phba->link_state = LPFC_HBA_ERROR;
2784                         break;
2785                 }
2786
2787                 lpfc_linkdown(phba);
2788                 lpfc_init_link(phba, initlinkmbox, phba->cfg_topology,
2789                                phba->cfg_link_speed);
2790                 initlinkmbox->mb.un.varInitLnk.lipsr_AL_PA = 0;
2791                 initlinkmbox->vport = vport;
2792                 initlinkmbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
2793                 rc = lpfc_sli_issue_mbox(phba, initlinkmbox, MBX_NOWAIT);
2794                 lpfc_set_loopback_flag(phba);
2795                 if (rc == MBX_NOT_FINISHED)
2796                         mempool_free(initlinkmbox, phba->mbox_mem_pool);
2797
2798                 break;
2799
2800         case LPFC_DISC_AUTH:
2801         /* Node Authentication timeout */
2802                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2803                                  "0227 Node Authentication timeout\n");
2804                 lpfc_disc_flush_list(vport);
2805
2806                 /*
2807                  * set port_state to PORT_READY if SLI2.
2808                  * cmpl_reg_vpi will set port_state to READY for SLI3.
2809                  */
2810                 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
2811                         lpfc_issue_reg_vpi(phba, vport);
2812                 else {  /* NPIV Not enabled */
2813                         lpfc_issue_clear_la(phba, vport);
2814                         vport->port_state = LPFC_VPORT_READY;
2815                 }
2816                 break;
2817
2818         case LPFC_VPORT_READY:
2819                 if (vport->fc_flag & FC_RSCN_MODE) {
2820                         lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2821                                          "0231 RSCN timeout Data: x%x "
2822                                          "x%x\n",
2823                                          vport->fc_ns_retry, LPFC_MAX_NS_RETRY);
2824
2825                         /* Cleanup any outstanding ELS commands */
2826                         lpfc_els_flush_cmd(vport);
2827
2828                         lpfc_els_flush_rscn(vport);
2829                         lpfc_disc_flush_list(vport);
2830                 }
2831                 break;
2832
2833         default:
2834                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2835                                  "0273 Unexpected discovery timeout, "
2836                                  "vport State x%x\n", vport->port_state);
2837                 break;
2838         }
2839
2840         switch (phba->link_state) {
2841         case LPFC_CLEAR_LA:
2842                                 /* CLEAR LA timeout */
2843                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2844                                  "0228 CLEAR LA timeout\n");
2845                 clrlaerr = 1;
2846                 break;
2847
2848         case LPFC_LINK_UP:
2849                 lpfc_issue_clear_la(phba, vport);
2850                 /* Drop thru */
2851         case LPFC_LINK_UNKNOWN:
2852         case LPFC_WARM_START:
2853         case LPFC_INIT_START:
2854         case LPFC_INIT_MBX_CMDS:
2855         case LPFC_LINK_DOWN:
2856         case LPFC_HBA_ERROR:
2857                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
2858                                  "0230 Unexpected timeout, hba link "
2859                                  "state x%x\n", phba->link_state);
2860                 clrlaerr = 1;
2861                 break;
2862
2863         case LPFC_HBA_READY:
2864                 break;
2865         }
2866
2867         if (clrlaerr) {
2868                 lpfc_disc_flush_list(vport);
2869                 psli->ring[(psli->extra_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
2870                 psli->ring[(psli->fcp_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
2871                 psli->ring[(psli->next_ring)].flag &= ~LPFC_STOP_IOCB_EVENT;
2872                 vport->port_state = LPFC_VPORT_READY;
2873         }
2874
2875         return;
2876 }
2877
2878 /*
2879  * This routine handles processing a NameServer REG_LOGIN mailbox
2880  * command upon completion. It is setup in the LPFC_MBOXQ
2881  * as the completion routine when the command is
2882  * handed off to the SLI layer.
2883  */
2884 void
2885 lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
2886 {
2887         MAILBOX_t *mb = &pmb->mb;
2888         struct lpfc_dmabuf   *mp = (struct lpfc_dmabuf *) (pmb->context1);
2889         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
2890         struct lpfc_vport    *vport = pmb->vport;
2891
2892         pmb->context1 = NULL;
2893
2894         ndlp->nlp_rpi = mb->un.varWords[0];
2895         ndlp->nlp_type |= NLP_FABRIC;
2896         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
2897
2898         /*
2899          * Start issuing Fabric-Device Management Interface (FDMI) command to
2900          * 0xfffffa (FDMI well known port) or Delay issuing FDMI command if
2901          * fdmi-on=2 (supporting RPA/hostnmae)
2902          */
2903
2904         if (vport->cfg_fdmi_on == 1)
2905                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
2906         else
2907                 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
2908
2909         /* decrement the node reference count held for this callback
2910          * function.
2911          */
2912         lpfc_nlp_put(ndlp);
2913         lpfc_mbuf_free(phba, mp->virt, mp->phys);
2914         kfree(mp);
2915         mempool_free(pmb, phba->mbox_mem_pool);
2916
2917         return;
2918 }
2919
2920 static int
2921 lpfc_filter_by_rpi(struct lpfc_nodelist *ndlp, void *param)
2922 {
2923         uint16_t *rpi = param;
2924
2925         return ndlp->nlp_rpi == *rpi;
2926 }
2927
2928 static int
2929 lpfc_filter_by_wwpn(struct lpfc_nodelist *ndlp, void *param)
2930 {
2931         return memcmp(&ndlp->nlp_portname, param,
2932                       sizeof(ndlp->nlp_portname)) == 0;
2933 }
2934
2935 static struct lpfc_nodelist *
2936 __lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param)
2937 {
2938         struct lpfc_nodelist *ndlp;
2939
2940         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
2941                 if (filter(ndlp, param))
2942                         return ndlp;
2943         }
2944         return NULL;
2945 }
2946
2947 /*
2948  * This routine looks up the ndlp lists for the given RPI. If rpi found it
2949  * returns the node list element pointer else return NULL.
2950  */
2951 struct lpfc_nodelist *
2952 __lpfc_findnode_rpi(struct lpfc_vport *vport, uint16_t rpi)
2953 {
2954         return __lpfc_find_node(vport, lpfc_filter_by_rpi, &rpi);
2955 }
2956
2957 /*
2958  * This routine looks up the ndlp lists for the given WWPN. If WWPN found it
2959  * returns the node element list pointer else return NULL.
2960  */
2961 struct lpfc_nodelist *
2962 lpfc_findnode_wwpn(struct lpfc_vport *vport, struct lpfc_name *wwpn)
2963 {
2964         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
2965         struct lpfc_nodelist *ndlp;
2966
2967         spin_lock_irq(shost->host_lock);
2968         ndlp = __lpfc_find_node(vport, lpfc_filter_by_wwpn, wwpn);
2969         spin_unlock_irq(shost->host_lock);
2970         return ndlp;
2971 }
2972
2973 void
2974 lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
2975               uint32_t did)
2976 {
2977         memset(ndlp, 0, sizeof (struct lpfc_nodelist));
2978         INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp);
2979         INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp);
2980         init_timer(&ndlp->nlp_delayfunc);
2981         ndlp->nlp_delayfunc.function = lpfc_els_retry_delay;
2982         ndlp->nlp_delayfunc.data = (unsigned long)ndlp;
2983         ndlp->nlp_DID = did;
2984         ndlp->vport = vport;
2985         ndlp->nlp_sid = NLP_NO_SID;
2986         INIT_LIST_HEAD(&ndlp->nlp_listp);
2987         kref_init(&ndlp->kref);
2988         NLP_INT_NODE_ACT(ndlp);
2989
2990         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE,
2991                 "node init:       did:x%x",
2992                 ndlp->nlp_DID, 0, 0);
2993
2994         return;
2995 }
2996
2997 /* This routine releases all resources associated with a specifc NPort's ndlp
2998  * and mempool_free's the nodelist.
2999  */
3000 static void
3001 lpfc_nlp_release(struct kref *kref)
3002 {
3003         struct lpfc_hba *phba;
3004         unsigned long flags;
3005         struct lpfc_nodelist *ndlp = container_of(kref, struct lpfc_nodelist,
3006                                                   kref);
3007
3008         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
3009                 "node release:    did:x%x flg:x%x type:x%x",
3010                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
3011
3012         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
3013                         "0279 lpfc_nlp_release: ndlp:x%p "
3014                         "usgmap:x%x refcnt:%d\n",
3015                         (void *)ndlp, ndlp->nlp_usg_map,
3016                         atomic_read(&ndlp->kref.refcount));
3017
3018         /* remove ndlp from action. */
3019         lpfc_nlp_remove(ndlp->vport, ndlp);
3020
3021         /* clear the ndlp active flag for all release cases */
3022         phba = ndlp->vport->phba;
3023         spin_lock_irqsave(&phba->ndlp_lock, flags);
3024         NLP_CLR_NODE_ACT(ndlp);
3025         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3026
3027         /* free ndlp memory for final ndlp release */
3028         if (NLP_CHK_FREE_REQ(ndlp))
3029                 mempool_free(ndlp, ndlp->vport->phba->nlp_mem_pool);
3030 }
3031
3032 /* This routine bumps the reference count for a ndlp structure to ensure
3033  * that one discovery thread won't free a ndlp while another discovery thread
3034  * is using it.
3035  */
3036 struct lpfc_nodelist *
3037 lpfc_nlp_get(struct lpfc_nodelist *ndlp)
3038 {
3039         struct lpfc_hba *phba;
3040         unsigned long flags;
3041
3042         if (ndlp) {
3043                 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
3044                         "node get:        did:x%x flg:x%x refcnt:x%x",
3045                         ndlp->nlp_DID, ndlp->nlp_flag,
3046                         atomic_read(&ndlp->kref.refcount));
3047                 /* The check of ndlp usage to prevent incrementing the
3048                  * ndlp reference count that is in the process of being
3049                  * released.
3050                  */
3051                 phba = ndlp->vport->phba;
3052                 spin_lock_irqsave(&phba->ndlp_lock, flags);
3053                 if (!NLP_CHK_NODE_ACT(ndlp) || NLP_CHK_FREE_ACK(ndlp)) {
3054                         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3055                         lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
3056                                 "0276 lpfc_nlp_get: ndlp:x%p "
3057                                 "usgmap:x%x refcnt:%d\n",
3058                                 (void *)ndlp, ndlp->nlp_usg_map,
3059                                 atomic_read(&ndlp->kref.refcount));
3060                         return NULL;
3061                 } else
3062                         kref_get(&ndlp->kref);
3063                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3064         }
3065         return ndlp;
3066 }
3067
3068 /* This routine decrements the reference count for a ndlp structure. If the
3069  * count goes to 0, this indicates the the associated nodelist should be
3070  * freed. Returning 1 indicates the ndlp resource has been released; on the
3071  * other hand, returning 0 indicates the ndlp resource has not been released
3072  * yet.
3073  */
3074 int
3075 lpfc_nlp_put(struct lpfc_nodelist *ndlp)
3076 {
3077         struct lpfc_hba *phba;
3078         unsigned long flags;
3079
3080         if (!ndlp)
3081                 return 1;
3082
3083         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
3084         "node put:        did:x%x flg:x%x refcnt:x%x",
3085                 ndlp->nlp_DID, ndlp->nlp_flag,
3086                 atomic_read(&ndlp->kref.refcount));
3087         phba = ndlp->vport->phba;
3088         spin_lock_irqsave(&phba->ndlp_lock, flags);
3089         /* Check the ndlp memory free acknowledge flag to avoid the
3090          * possible race condition that kref_put got invoked again
3091          * after previous one has done ndlp memory free.
3092          */
3093         if (NLP_CHK_FREE_ACK(ndlp)) {
3094                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3095                 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
3096                                 "0274 lpfc_nlp_put: ndlp:x%p "
3097                                 "usgmap:x%x refcnt:%d\n",
3098                                 (void *)ndlp, ndlp->nlp_usg_map,
3099                                 atomic_read(&ndlp->kref.refcount));
3100                 return 1;
3101         }
3102         /* Check the ndlp inactivate log flag to avoid the possible
3103          * race condition that kref_put got invoked again after ndlp
3104          * is already in inactivating state.
3105          */
3106         if (NLP_CHK_IACT_REQ(ndlp)) {
3107                 spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3108                 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE,
3109                                 "0275 lpfc_nlp_put: ndlp:x%p "
3110                                 "usgmap:x%x refcnt:%d\n",
3111                                 (void *)ndlp, ndlp->nlp_usg_map,
3112                                 atomic_read(&ndlp->kref.refcount));
3113                 return 1;
3114         }
3115         /* For last put, mark the ndlp usage flags to make sure no
3116          * other kref_get and kref_put on the same ndlp shall get
3117          * in between the process when the final kref_put has been
3118          * invoked on this ndlp.
3119          */
3120         if (atomic_read(&ndlp->kref.refcount) == 1) {
3121                 /* Indicate ndlp is put to inactive state. */
3122                 NLP_SET_IACT_REQ(ndlp);
3123                 /* Acknowledge ndlp memory free has been seen. */
3124                 if (NLP_CHK_FREE_REQ(ndlp))
3125                         NLP_SET_FREE_ACK(ndlp);
3126         }
3127         spin_unlock_irqrestore(&phba->ndlp_lock, flags);
3128         /* Note, the kref_put returns 1 when decrementing a reference
3129          * count that was 1, it invokes the release callback function,
3130          * but it still left the reference count as 1 (not actually
3131          * performs the last decrementation). Otherwise, it actually
3132          * decrements the reference count and returns 0.
3133          */
3134         return kref_put(&ndlp->kref, lpfc_nlp_release);
3135 }
3136
3137 /* This routine free's the specified nodelist if it is not in use
3138  * by any other discovery thread. This routine returns 1 if the
3139  * ndlp has been freed. A return value of 0 indicates the ndlp is
3140  * not yet been released.
3141  */
3142 int
3143 lpfc_nlp_not_used(struct lpfc_nodelist *ndlp)
3144 {
3145         lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE,
3146                 "node not used:   did:x%x flg:x%x refcnt:x%x",
3147                 ndlp->nlp_DID, ndlp->nlp_flag,
3148                 atomic_read(&ndlp->kref.refcount));
3149         if (atomic_read(&ndlp->kref.refcount) == 1)
3150                 if (lpfc_nlp_put(ndlp))
3151                         return 1;
3152         return 0;
3153 }