1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2005 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 40 /* AlpaArray for assignment of scsid for scan-down and bind_method */ 41 static uint8_t lpfcAlpaArray[] = { 42 0xEF, 0xE8, 0xE4, 0xE2, 0xE1, 0xE0, 0xDC, 0xDA, 0xD9, 0xD6, 43 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 44 0xC9, 0xC7, 0xC6, 0xC5, 0xC3, 0xBC, 0xBA, 0xB9, 0xB6, 0xB5, 45 0xB4, 0xB3, 0xB2, 0xB1, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 46 0xA7, 0xA6, 0xA5, 0xA3, 0x9F, 0x9E, 0x9D, 0x9B, 0x98, 0x97, 47 0x90, 0x8F, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7C, 0x7A, 0x79, 48 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6E, 0x6D, 0x6C, 0x6B, 49 0x6A, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5C, 0x5A, 0x59, 0x56, 50 0x55, 0x54, 0x53, 0x52, 0x51, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A, 51 0x49, 0x47, 0x46, 0x45, 0x43, 0x3C, 0x3A, 0x39, 0x36, 0x35, 52 0x34, 0x33, 0x32, 0x31, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 53 0x27, 0x26, 0x25, 0x23, 0x1F, 0x1E, 0x1D, 0x1B, 0x18, 0x17, 54 0x10, 0x0F, 0x08, 0x04, 0x02, 0x01 55 }; 56 57 static void lpfc_disc_timeout_handler(struct lpfc_hba *); 58 59 static void 60 lpfc_process_nodev_timeout(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 61 { 62 int warn_on = 0; 63 64 spin_lock_irq(phba->host->host_lock); 65 if (!(ndlp->nlp_flag & NLP_NODEV_TMO)) { 66 spin_unlock_irq(phba->host->host_lock); 67 return; 68 } 69 70 ndlp->nlp_flag &= ~NLP_NODEV_TMO; 71 72 if (ndlp->nlp_sid != NLP_NO_SID) { 73 warn_on = 1; 74 /* flush the target */ 75 lpfc_sli_abort_iocb(phba, &phba->sli.ring[phba->sli.fcp_ring], 76 ndlp->nlp_sid, 0, 0, LPFC_CTX_TGT); 77 } 78 spin_unlock_irq(phba->host->host_lock); 79 80 if (warn_on) { 81 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 82 "%d:0203 Nodev timeout on NPort x%x " 83 "Data: x%x x%x x%x\n", 84 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag, 85 ndlp->nlp_state, ndlp->nlp_rpi); 86 } else { 87 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 88 "%d:0204 Nodev timeout on NPort x%x " 89 "Data: x%x x%x x%x\n", 90 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag, 91 ndlp->nlp_state, ndlp->nlp_rpi); 92 } 93 94 lpfc_disc_state_machine(phba, ndlp, NULL, NLP_EVT_DEVICE_RM); 95 return; 96 } 97 98 static void 99 lpfc_work_list_done(struct lpfc_hba * phba) 100 { 101 struct lpfc_work_evt *evtp = NULL; 102 struct lpfc_nodelist *ndlp; 103 int free_evt; 104 105 spin_lock_irq(phba->host->host_lock); 106 while(!list_empty(&phba->work_list)) { 107 list_remove_head((&phba->work_list), evtp, typeof(*evtp), 108 evt_listp); 109 spin_unlock_irq(phba->host->host_lock); 110 free_evt = 1; 111 switch(evtp->evt) { 112 case LPFC_EVT_NODEV_TMO: 113 ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1); 114 lpfc_process_nodev_timeout(phba, ndlp); 115 free_evt = 0; 116 break; 117 case LPFC_EVT_ELS_RETRY: 118 ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1); 119 lpfc_els_retry_delay_handler(ndlp); 120 free_evt = 0; 121 break; 122 case LPFC_EVT_ONLINE: 123 *(int *)(evtp->evt_arg1) = lpfc_online(phba); 124 complete((struct completion *)(evtp->evt_arg2)); 125 break; 126 case LPFC_EVT_OFFLINE: 127 *(int *)(evtp->evt_arg1) = lpfc_offline(phba); 128 complete((struct completion *)(evtp->evt_arg2)); 129 break; 130 } 131 if (free_evt) 132 kfree(evtp); 133 spin_lock_irq(phba->host->host_lock); 134 } 135 spin_unlock_irq(phba->host->host_lock); 136 137 } 138 139 static void 140 lpfc_work_done(struct lpfc_hba * phba) 141 { 142 struct lpfc_sli_ring *pring; 143 int i; 144 uint32_t ha_copy; 145 uint32_t control; 146 uint32_t work_hba_events; 147 148 spin_lock_irq(phba->host->host_lock); 149 ha_copy = phba->work_ha; 150 phba->work_ha = 0; 151 work_hba_events=phba->work_hba_events; 152 spin_unlock_irq(phba->host->host_lock); 153 154 if(ha_copy & HA_ERATT) 155 lpfc_handle_eratt(phba); 156 157 if(ha_copy & HA_MBATT) 158 lpfc_sli_handle_mb_event(phba); 159 160 if(ha_copy & HA_LATT) 161 lpfc_handle_latt(phba); 162 163 if (work_hba_events & WORKER_DISC_TMO) 164 lpfc_disc_timeout_handler(phba); 165 166 if (work_hba_events & WORKER_ELS_TMO) 167 lpfc_els_timeout_handler(phba); 168 169 if (work_hba_events & WORKER_MBOX_TMO) 170 lpfc_mbox_timeout_handler(phba); 171 172 if (work_hba_events & WORKER_FDMI_TMO) 173 lpfc_fdmi_tmo_handler(phba); 174 175 spin_lock_irq(phba->host->host_lock); 176 phba->work_hba_events &= ~work_hba_events; 177 spin_unlock_irq(phba->host->host_lock); 178 179 for (i = 0; i < phba->sli.num_rings; i++, ha_copy >>= 4) { 180 pring = &phba->sli.ring[i]; 181 if ((ha_copy & HA_RXATT) 182 || (pring->flag & LPFC_DEFERRED_RING_EVENT)) { 183 if (pring->flag & LPFC_STOP_IOCB_MASK) { 184 pring->flag |= LPFC_DEFERRED_RING_EVENT; 185 } else { 186 lpfc_sli_handle_slow_ring_event(phba, pring, 187 (ha_copy & 188 HA_RXMASK)); 189 pring->flag &= ~LPFC_DEFERRED_RING_EVENT; 190 } 191 /* 192 * Turn on Ring interrupts 193 */ 194 spin_lock_irq(phba->host->host_lock); 195 control = readl(phba->HCregaddr); 196 control |= (HC_R0INT_ENA << i); 197 writel(control, phba->HCregaddr); 198 readl(phba->HCregaddr); /* flush */ 199 spin_unlock_irq(phba->host->host_lock); 200 } 201 } 202 203 lpfc_work_list_done (phba); 204 205 } 206 207 static int 208 check_work_wait_done(struct lpfc_hba *phba) { 209 210 spin_lock_irq(phba->host->host_lock); 211 if (phba->work_ha || 212 phba->work_hba_events || 213 (!list_empty(&phba->work_list)) || 214 kthread_should_stop()) { 215 spin_unlock_irq(phba->host->host_lock); 216 return 1; 217 } else { 218 spin_unlock_irq(phba->host->host_lock); 219 return 0; 220 } 221 } 222 223 int 224 lpfc_do_work(void *p) 225 { 226 struct lpfc_hba *phba = p; 227 int rc; 228 DECLARE_WAIT_QUEUE_HEAD(work_waitq); 229 230 set_user_nice(current, -20); 231 phba->work_wait = &work_waitq; 232 233 while (1) { 234 235 rc = wait_event_interruptible(work_waitq, 236 check_work_wait_done(phba)); 237 BUG_ON(rc); 238 239 if (kthread_should_stop()) 240 break; 241 242 lpfc_work_done(phba); 243 244 } 245 phba->work_wait = NULL; 246 return 0; 247 } 248 249 /* 250 * This is only called to handle FC worker events. Since this a rare 251 * occurance, we allocate a struct lpfc_work_evt structure here instead of 252 * embedding it in the IOCB. 253 */ 254 int 255 lpfc_workq_post_event(struct lpfc_hba * phba, void *arg1, void *arg2, 256 uint32_t evt) 257 { 258 struct lpfc_work_evt *evtp; 259 260 /* 261 * All Mailbox completions and LPFC_ELS_RING rcv ring IOCB events will 262 * be queued to worker thread for processing 263 */ 264 evtp = kmalloc(sizeof(struct lpfc_work_evt), GFP_KERNEL); 265 if (!evtp) 266 return 0; 267 268 evtp->evt_arg1 = arg1; 269 evtp->evt_arg2 = arg2; 270 evtp->evt = evt; 271 272 list_add_tail(&evtp->evt_listp, &phba->work_list); 273 spin_lock_irq(phba->host->host_lock); 274 if (phba->work_wait) 275 wake_up(phba->work_wait); 276 spin_unlock_irq(phba->host->host_lock); 277 278 return 1; 279 } 280 281 int 282 lpfc_linkdown(struct lpfc_hba * phba) 283 { 284 struct lpfc_sli *psli; 285 struct lpfc_nodelist *ndlp, *next_ndlp; 286 struct list_head *listp; 287 struct list_head *node_list[7]; 288 LPFC_MBOXQ_t *mb; 289 int rc, i; 290 291 psli = &phba->sli; 292 293 spin_lock_irq(phba->host->host_lock); 294 phba->hba_state = LPFC_LINK_DOWN; 295 spin_unlock_irq(phba->host->host_lock); 296 297 /* Clean up any firmware default rpi's */ 298 if ((mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 299 lpfc_unreg_did(phba, 0xffffffff, mb); 300 mb->mbox_cmpl=lpfc_sli_def_mbox_cmpl; 301 if (lpfc_sli_issue_mbox(phba, mb, (MBX_NOWAIT | MBX_STOP_IOCB)) 302 == MBX_NOT_FINISHED) { 303 mempool_free( mb, phba->mbox_mem_pool); 304 } 305 } 306 307 /* Cleanup any outstanding RSCN activity */ 308 lpfc_els_flush_rscn(phba); 309 310 /* Cleanup any outstanding ELS commands */ 311 lpfc_els_flush_cmd(phba); 312 313 /* Issue a LINK DOWN event to all nodes */ 314 node_list[0] = &phba->fc_npr_list; /* MUST do this list first */ 315 node_list[1] = &phba->fc_nlpmap_list; 316 node_list[2] = &phba->fc_nlpunmap_list; 317 node_list[3] = &phba->fc_prli_list; 318 node_list[4] = &phba->fc_reglogin_list; 319 node_list[5] = &phba->fc_adisc_list; 320 node_list[6] = &phba->fc_plogi_list; 321 for (i = 0; i < 7; i++) { 322 listp = node_list[i]; 323 if (list_empty(listp)) 324 continue; 325 326 list_for_each_entry_safe(ndlp, next_ndlp, listp, nlp_listp) { 327 /* Fabric nodes are not handled thru state machine for 328 link down */ 329 if (ndlp->nlp_type & NLP_FABRIC) { 330 /* Remove ALL Fabric nodes except Fabric_DID */ 331 if (ndlp->nlp_DID != Fabric_DID) { 332 /* Take it off current list and free */ 333 lpfc_nlp_list(phba, ndlp, 334 NLP_NO_LIST); 335 } 336 } 337 else { 338 339 rc = lpfc_disc_state_machine(phba, ndlp, NULL, 340 NLP_EVT_DEVICE_RECOVERY); 341 342 /* Check config parameter use-adisc or FCP-2 */ 343 if ((rc != NLP_STE_FREED_NODE) && 344 (phba->cfg_use_adisc == 0) && 345 !(ndlp->nlp_fcp_info & 346 NLP_FCP_2_DEVICE)) { 347 /* We know we will have to relogin, so 348 * unreglogin the rpi right now to fail 349 * any outstanding I/Os quickly. 350 */ 351 lpfc_unreg_rpi(phba, ndlp); 352 } 353 } 354 } 355 } 356 357 /* free any ndlp's on unused list */ 358 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_unused_list, 359 nlp_listp) { 360 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 361 } 362 363 /* Setup myDID for link up if we are in pt2pt mode */ 364 if (phba->fc_flag & FC_PT2PT) { 365 phba->fc_myDID = 0; 366 if ((mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 367 lpfc_config_link(phba, mb); 368 mb->mbox_cmpl=lpfc_sli_def_mbox_cmpl; 369 if (lpfc_sli_issue_mbox 370 (phba, mb, (MBX_NOWAIT | MBX_STOP_IOCB)) 371 == MBX_NOT_FINISHED) { 372 mempool_free( mb, phba->mbox_mem_pool); 373 } 374 } 375 spin_lock_irq(phba->host->host_lock); 376 phba->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI); 377 spin_unlock_irq(phba->host->host_lock); 378 } 379 spin_lock_irq(phba->host->host_lock); 380 phba->fc_flag &= ~FC_LBIT; 381 spin_unlock_irq(phba->host->host_lock); 382 383 /* Turn off discovery timer if its running */ 384 lpfc_can_disctmo(phba); 385 386 /* Must process IOCBs on all rings to handle ABORTed I/Os */ 387 return (0); 388 } 389 390 static int 391 lpfc_linkup(struct lpfc_hba * phba) 392 { 393 struct lpfc_nodelist *ndlp, *next_ndlp; 394 395 spin_lock_irq(phba->host->host_lock); 396 phba->hba_state = LPFC_LINK_UP; 397 phba->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI | FC_ABORT_DISCOVERY | 398 FC_RSCN_MODE | FC_NLP_MORE | FC_RSCN_DISCOVERY); 399 phba->fc_flag |= FC_NDISC_ACTIVE; 400 phba->fc_ns_retry = 0; 401 spin_unlock_irq(phba->host->host_lock); 402 403 404 /* 405 * Clean up old Fabric NLP_FABRIC logins. 406 */ 407 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nlpunmap_list, 408 nlp_listp) { 409 if (ndlp->nlp_DID == Fabric_DID) { 410 /* Take it off current list and free */ 411 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 412 } 413 } 414 415 /* free any ndlp's on unused list */ 416 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_unused_list, 417 nlp_listp) { 418 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 419 } 420 421 return 0; 422 } 423 424 /* 425 * This routine handles processing a CLEAR_LA mailbox 426 * command upon completion. It is setup in the LPFC_MBOXQ 427 * as the completion routine when the command is 428 * handed off to the SLI layer. 429 */ 430 void 431 lpfc_mbx_cmpl_clear_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 432 { 433 struct lpfc_sli *psli; 434 MAILBOX_t *mb; 435 uint32_t control; 436 437 psli = &phba->sli; 438 mb = &pmb->mb; 439 /* Since we don't do discovery right now, turn these off here */ 440 psli->ring[psli->ip_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 441 psli->ring[psli->fcp_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 442 psli->ring[psli->next_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 443 444 /* Check for error */ 445 if ((mb->mbxStatus) && (mb->mbxStatus != 0x1601)) { 446 /* CLEAR_LA mbox error <mbxStatus> state <hba_state> */ 447 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 448 "%d:0320 CLEAR_LA mbxStatus error x%x hba " 449 "state x%x\n", 450 phba->brd_no, mb->mbxStatus, phba->hba_state); 451 452 phba->hba_state = LPFC_HBA_ERROR; 453 goto out; 454 } 455 456 if (phba->fc_flag & FC_ABORT_DISCOVERY) 457 goto out; 458 459 phba->num_disc_nodes = 0; 460 /* go thru NPR list and issue ELS PLOGIs */ 461 if (phba->fc_npr_cnt) { 462 lpfc_els_disc_plogi(phba); 463 } 464 465 if(!phba->num_disc_nodes) { 466 spin_lock_irq(phba->host->host_lock); 467 phba->fc_flag &= ~FC_NDISC_ACTIVE; 468 spin_unlock_irq(phba->host->host_lock); 469 } 470 471 phba->hba_state = LPFC_HBA_READY; 472 473 out: 474 /* Device Discovery completes */ 475 lpfc_printf_log(phba, 476 KERN_INFO, 477 LOG_DISCOVERY, 478 "%d:0225 Device Discovery completes\n", 479 phba->brd_no); 480 481 mempool_free( pmb, phba->mbox_mem_pool); 482 483 spin_lock_irq(phba->host->host_lock); 484 phba->fc_flag &= ~FC_ABORT_DISCOVERY; 485 if (phba->fc_flag & FC_ESTABLISH_LINK) { 486 phba->fc_flag &= ~FC_ESTABLISH_LINK; 487 } 488 spin_unlock_irq(phba->host->host_lock); 489 490 del_timer_sync(&phba->fc_estabtmo); 491 492 lpfc_can_disctmo(phba); 493 494 /* turn on Link Attention interrupts */ 495 spin_lock_irq(phba->host->host_lock); 496 psli->sli_flag |= LPFC_PROCESS_LA; 497 control = readl(phba->HCregaddr); 498 control |= HC_LAINT_ENA; 499 writel(control, phba->HCregaddr); 500 readl(phba->HCregaddr); /* flush */ 501 spin_unlock_irq(phba->host->host_lock); 502 503 return; 504 } 505 506 static void 507 lpfc_mbx_cmpl_config_link(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 508 { 509 struct lpfc_sli *psli; 510 MAILBOX_t *mb; 511 512 psli = &phba->sli; 513 mb = &pmb->mb; 514 /* Check for error */ 515 if (mb->mbxStatus) { 516 /* CONFIG_LINK mbox error <mbxStatus> state <hba_state> */ 517 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 518 "%d:0306 CONFIG_LINK mbxStatus error x%x " 519 "HBA state x%x\n", 520 phba->brd_no, mb->mbxStatus, phba->hba_state); 521 522 lpfc_linkdown(phba); 523 phba->hba_state = LPFC_HBA_ERROR; 524 goto out; 525 } 526 527 if (phba->hba_state == LPFC_LOCAL_CFG_LINK) { 528 if (phba->fc_topology == TOPOLOGY_LOOP) { 529 /* If we are public loop and L bit was set */ 530 if ((phba->fc_flag & FC_PUBLIC_LOOP) && 531 !(phba->fc_flag & FC_LBIT)) { 532 /* Need to wait for FAN - use discovery timer 533 * for timeout. hba_state is identically 534 * LPFC_LOCAL_CFG_LINK while waiting for FAN 535 */ 536 lpfc_set_disctmo(phba); 537 mempool_free( pmb, phba->mbox_mem_pool); 538 return; 539 } 540 } 541 542 /* Start discovery by sending a FLOGI hba_state is identically 543 * LPFC_FLOGI while waiting for FLOGI cmpl 544 */ 545 phba->hba_state = LPFC_FLOGI; 546 lpfc_set_disctmo(phba); 547 lpfc_initial_flogi(phba); 548 mempool_free( pmb, phba->mbox_mem_pool); 549 return; 550 } 551 if (phba->hba_state == LPFC_FABRIC_CFG_LINK) { 552 mempool_free( pmb, phba->mbox_mem_pool); 553 return; 554 } 555 556 out: 557 /* CONFIG_LINK bad hba state <hba_state> */ 558 lpfc_printf_log(phba, 559 KERN_ERR, 560 LOG_DISCOVERY, 561 "%d:0200 CONFIG_LINK bad hba state x%x\n", 562 phba->brd_no, phba->hba_state); 563 564 if (phba->hba_state != LPFC_CLEAR_LA) { 565 lpfc_clear_la(phba, pmb); 566 pmb->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 567 if (lpfc_sli_issue_mbox(phba, pmb, (MBX_NOWAIT | MBX_STOP_IOCB)) 568 == MBX_NOT_FINISHED) { 569 mempool_free( pmb, phba->mbox_mem_pool); 570 lpfc_disc_flush_list(phba); 571 psli->ring[(psli->ip_ring)].flag &= 572 ~LPFC_STOP_IOCB_EVENT; 573 psli->ring[(psli->fcp_ring)].flag &= 574 ~LPFC_STOP_IOCB_EVENT; 575 psli->ring[(psli->next_ring)].flag &= 576 ~LPFC_STOP_IOCB_EVENT; 577 phba->hba_state = LPFC_HBA_READY; 578 } 579 } else { 580 mempool_free( pmb, phba->mbox_mem_pool); 581 } 582 return; 583 } 584 585 static void 586 lpfc_mbx_cmpl_read_sparam(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 587 { 588 struct lpfc_sli *psli = &phba->sli; 589 MAILBOX_t *mb = &pmb->mb; 590 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) pmb->context1; 591 592 593 /* Check for error */ 594 if (mb->mbxStatus) { 595 /* READ_SPARAM mbox error <mbxStatus> state <hba_state> */ 596 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 597 "%d:0319 READ_SPARAM mbxStatus error x%x " 598 "hba state x%x>\n", 599 phba->brd_no, mb->mbxStatus, phba->hba_state); 600 601 lpfc_linkdown(phba); 602 phba->hba_state = LPFC_HBA_ERROR; 603 goto out; 604 } 605 606 memcpy((uint8_t *) & phba->fc_sparam, (uint8_t *) mp->virt, 607 sizeof (struct serv_parm)); 608 memcpy((uint8_t *) & phba->fc_nodename, 609 (uint8_t *) & phba->fc_sparam.nodeName, 610 sizeof (struct lpfc_name)); 611 memcpy((uint8_t *) & phba->fc_portname, 612 (uint8_t *) & phba->fc_sparam.portName, 613 sizeof (struct lpfc_name)); 614 lpfc_mbuf_free(phba, mp->virt, mp->phys); 615 kfree(mp); 616 mempool_free( pmb, phba->mbox_mem_pool); 617 return; 618 619 out: 620 pmb->context1 = NULL; 621 lpfc_mbuf_free(phba, mp->virt, mp->phys); 622 kfree(mp); 623 if (phba->hba_state != LPFC_CLEAR_LA) { 624 lpfc_clear_la(phba, pmb); 625 pmb->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 626 if (lpfc_sli_issue_mbox(phba, pmb, (MBX_NOWAIT | MBX_STOP_IOCB)) 627 == MBX_NOT_FINISHED) { 628 mempool_free( pmb, phba->mbox_mem_pool); 629 lpfc_disc_flush_list(phba); 630 psli->ring[(psli->ip_ring)].flag &= 631 ~LPFC_STOP_IOCB_EVENT; 632 psli->ring[(psli->fcp_ring)].flag &= 633 ~LPFC_STOP_IOCB_EVENT; 634 psli->ring[(psli->next_ring)].flag &= 635 ~LPFC_STOP_IOCB_EVENT; 636 phba->hba_state = LPFC_HBA_READY; 637 } 638 } else { 639 mempool_free( pmb, phba->mbox_mem_pool); 640 } 641 return; 642 } 643 644 static void 645 lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la) 646 { 647 int i; 648 LPFC_MBOXQ_t *sparam_mbox, *cfglink_mbox; 649 sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 650 cfglink_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 651 652 spin_lock_irq(phba->host->host_lock); 653 switch(la->UlnkSpeed) { 654 case LA_1GHZ_LINK: 655 phba->fc_linkspeed = LA_1GHZ_LINK; 656 break; 657 case LA_2GHZ_LINK: 658 phba->fc_linkspeed = LA_2GHZ_LINK; 659 break; 660 case LA_4GHZ_LINK: 661 phba->fc_linkspeed = LA_4GHZ_LINK; 662 break; 663 default: 664 phba->fc_linkspeed = LA_UNKNW_LINK; 665 break; 666 } 667 668 phba->fc_topology = la->topology; 669 670 if (phba->fc_topology == TOPOLOGY_LOOP) { 671 /* Get Loop Map information */ 672 673 if (la->il) 674 phba->fc_flag |= FC_LBIT; 675 676 phba->fc_myDID = la->granted_AL_PA; 677 i = la->un.lilpBde64.tus.f.bdeSize; 678 679 if (i == 0) { 680 phba->alpa_map[0] = 0; 681 } else { 682 if (phba->cfg_log_verbose & LOG_LINK_EVENT) { 683 int numalpa, j, k; 684 union { 685 uint8_t pamap[16]; 686 struct { 687 uint32_t wd1; 688 uint32_t wd2; 689 uint32_t wd3; 690 uint32_t wd4; 691 } pa; 692 } un; 693 numalpa = phba->alpa_map[0]; 694 j = 0; 695 while (j < numalpa) { 696 memset(un.pamap, 0, 16); 697 for (k = 1; j < numalpa; k++) { 698 un.pamap[k - 1] = 699 phba->alpa_map[j + 1]; 700 j++; 701 if (k == 16) 702 break; 703 } 704 /* Link Up Event ALPA map */ 705 lpfc_printf_log(phba, 706 KERN_WARNING, 707 LOG_LINK_EVENT, 708 "%d:1304 Link Up Event " 709 "ALPA map Data: x%x " 710 "x%x x%x x%x\n", 711 phba->brd_no, 712 un.pa.wd1, un.pa.wd2, 713 un.pa.wd3, un.pa.wd4); 714 } 715 } 716 } 717 } else { 718 phba->fc_myDID = phba->fc_pref_DID; 719 phba->fc_flag |= FC_LBIT; 720 } 721 spin_unlock_irq(phba->host->host_lock); 722 723 lpfc_linkup(phba); 724 if (sparam_mbox) { 725 lpfc_read_sparam(phba, sparam_mbox); 726 sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam; 727 lpfc_sli_issue_mbox(phba, sparam_mbox, 728 (MBX_NOWAIT | MBX_STOP_IOCB)); 729 } 730 731 if (cfglink_mbox) { 732 phba->hba_state = LPFC_LOCAL_CFG_LINK; 733 lpfc_config_link(phba, cfglink_mbox); 734 cfglink_mbox->mbox_cmpl = lpfc_mbx_cmpl_config_link; 735 lpfc_sli_issue_mbox(phba, cfglink_mbox, 736 (MBX_NOWAIT | MBX_STOP_IOCB)); 737 } 738 } 739 740 static void 741 lpfc_mbx_issue_link_down(struct lpfc_hba *phba) { 742 uint32_t control; 743 struct lpfc_sli *psli = &phba->sli; 744 745 lpfc_linkdown(phba); 746 747 /* turn on Link Attention interrupts - no CLEAR_LA needed */ 748 spin_lock_irq(phba->host->host_lock); 749 psli->sli_flag |= LPFC_PROCESS_LA; 750 control = readl(phba->HCregaddr); 751 control |= HC_LAINT_ENA; 752 writel(control, phba->HCregaddr); 753 readl(phba->HCregaddr); /* flush */ 754 spin_unlock_irq(phba->host->host_lock); 755 } 756 757 /* 758 * This routine handles processing a READ_LA mailbox 759 * command upon completion. It is setup in the LPFC_MBOXQ 760 * as the completion routine when the command is 761 * handed off to the SLI layer. 762 */ 763 void 764 lpfc_mbx_cmpl_read_la(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 765 { 766 READ_LA_VAR *la; 767 MAILBOX_t *mb = &pmb->mb; 768 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 769 770 /* Check for error */ 771 if (mb->mbxStatus) { 772 lpfc_printf_log(phba, 773 KERN_INFO, 774 LOG_LINK_EVENT, 775 "%d:1307 READ_LA mbox error x%x state x%x\n", 776 phba->brd_no, 777 mb->mbxStatus, phba->hba_state); 778 lpfc_mbx_issue_link_down(phba); 779 phba->hba_state = LPFC_HBA_ERROR; 780 goto lpfc_mbx_cmpl_read_la_free_mbuf; 781 } 782 783 la = (READ_LA_VAR *) & pmb->mb.un.varReadLA; 784 785 memcpy(&phba->alpa_map[0], mp->virt, 128); 786 787 if (((phba->fc_eventTag + 1) < la->eventTag) || 788 (phba->fc_eventTag == la->eventTag)) { 789 phba->fc_stat.LinkMultiEvent++; 790 if (la->attType == AT_LINK_UP) { 791 if (phba->fc_eventTag != 0) 792 lpfc_linkdown(phba); 793 } 794 } 795 796 phba->fc_eventTag = la->eventTag; 797 798 if (la->attType == AT_LINK_UP) { 799 phba->fc_stat.LinkUp++; 800 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 801 "%d:1303 Link Up Event x%x received " 802 "Data: x%x x%x x%x x%x\n", 803 phba->brd_no, la->eventTag, phba->fc_eventTag, 804 la->granted_AL_PA, la->UlnkSpeed, 805 phba->alpa_map[0]); 806 lpfc_mbx_process_link_up(phba, la); 807 } else { 808 phba->fc_stat.LinkDown++; 809 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 810 "%d:1305 Link Down Event x%x received " 811 "Data: x%x x%x x%x\n", 812 phba->brd_no, la->eventTag, phba->fc_eventTag, 813 phba->hba_state, phba->fc_flag); 814 lpfc_mbx_issue_link_down(phba); 815 } 816 817 lpfc_mbx_cmpl_read_la_free_mbuf: 818 lpfc_mbuf_free(phba, mp->virt, mp->phys); 819 kfree(mp); 820 mempool_free(pmb, phba->mbox_mem_pool); 821 return; 822 } 823 824 /* 825 * This routine handles processing a REG_LOGIN mailbox 826 * command upon completion. It is setup in the LPFC_MBOXQ 827 * as the completion routine when the command is 828 * handed off to the SLI layer. 829 */ 830 void 831 lpfc_mbx_cmpl_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 832 { 833 struct lpfc_sli *psli; 834 MAILBOX_t *mb; 835 struct lpfc_dmabuf *mp; 836 struct lpfc_nodelist *ndlp; 837 838 psli = &phba->sli; 839 mb = &pmb->mb; 840 841 ndlp = (struct lpfc_nodelist *) pmb->context2; 842 mp = (struct lpfc_dmabuf *) (pmb->context1); 843 844 pmb->context1 = NULL; 845 846 /* Good status, call state machine */ 847 lpfc_disc_state_machine(phba, ndlp, pmb, NLP_EVT_CMPL_REG_LOGIN); 848 lpfc_mbuf_free(phba, mp->virt, mp->phys); 849 kfree(mp); 850 mempool_free( pmb, phba->mbox_mem_pool); 851 852 return; 853 } 854 855 /* 856 * This routine handles processing a Fabric REG_LOGIN mailbox 857 * command upon completion. It is setup in the LPFC_MBOXQ 858 * as the completion routine when the command is 859 * handed off to the SLI layer. 860 */ 861 void 862 lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 863 { 864 struct lpfc_sli *psli; 865 MAILBOX_t *mb; 866 struct lpfc_dmabuf *mp; 867 struct lpfc_nodelist *ndlp; 868 struct lpfc_nodelist *ndlp_fdmi; 869 870 871 psli = &phba->sli; 872 mb = &pmb->mb; 873 874 ndlp = (struct lpfc_nodelist *) pmb->context2; 875 mp = (struct lpfc_dmabuf *) (pmb->context1); 876 877 if (mb->mbxStatus) { 878 lpfc_mbuf_free(phba, mp->virt, mp->phys); 879 kfree(mp); 880 mempool_free( pmb, phba->mbox_mem_pool); 881 mempool_free( ndlp, phba->nlp_mem_pool); 882 883 /* FLOGI failed, so just use loop map to make discovery list */ 884 lpfc_disc_list_loopmap(phba); 885 886 /* Start discovery */ 887 lpfc_disc_start(phba); 888 return; 889 } 890 891 pmb->context1 = NULL; 892 893 ndlp->nlp_rpi = mb->un.varWords[0]; 894 ndlp->nlp_type |= NLP_FABRIC; 895 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 896 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 897 898 if (phba->hba_state == LPFC_FABRIC_CFG_LINK) { 899 /* This NPort has been assigned an NPort_ID by the fabric as a 900 * result of the completed fabric login. Issue a State Change 901 * Registration (SCR) ELS request to the fabric controller 902 * (SCR_DID) so that this NPort gets RSCN events from the 903 * fabric. 904 */ 905 lpfc_issue_els_scr(phba, SCR_DID, 0); 906 907 /* Allocate a new node instance. If the pool is empty, just 908 * start the discovery process and skip the Nameserver login 909 * process. This is attempted again later on. Otherwise, issue 910 * a Port Login (PLOGI) to the NameServer 911 */ 912 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) 913 == 0) { 914 lpfc_disc_start(phba); 915 } else { 916 lpfc_nlp_init(phba, ndlp, NameServer_DID); 917 ndlp->nlp_type |= NLP_FABRIC; 918 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 919 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 920 lpfc_issue_els_plogi(phba, ndlp, 0); 921 if (phba->cfg_fdmi_on) { 922 if ((ndlp_fdmi = mempool_alloc( 923 phba->nlp_mem_pool, 924 GFP_KERNEL))) { 925 lpfc_nlp_init(phba, ndlp_fdmi, 926 FDMI_DID); 927 ndlp_fdmi->nlp_type |= NLP_FABRIC; 928 ndlp_fdmi->nlp_state = 929 NLP_STE_PLOGI_ISSUE; 930 lpfc_issue_els_plogi(phba, ndlp_fdmi, 931 0); 932 } 933 } 934 } 935 } 936 937 lpfc_mbuf_free(phba, mp->virt, mp->phys); 938 kfree(mp); 939 mempool_free( pmb, phba->mbox_mem_pool); 940 941 return; 942 } 943 944 /* 945 * This routine handles processing a NameServer REG_LOGIN mailbox 946 * command upon completion. It is setup in the LPFC_MBOXQ 947 * as the completion routine when the command is 948 * handed off to the SLI layer. 949 */ 950 void 951 lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 952 { 953 struct lpfc_sli *psli; 954 MAILBOX_t *mb; 955 struct lpfc_dmabuf *mp; 956 struct lpfc_nodelist *ndlp; 957 958 psli = &phba->sli; 959 mb = &pmb->mb; 960 961 ndlp = (struct lpfc_nodelist *) pmb->context2; 962 mp = (struct lpfc_dmabuf *) (pmb->context1); 963 964 if (mb->mbxStatus) { 965 lpfc_mbuf_free(phba, mp->virt, mp->phys); 966 kfree(mp); 967 mempool_free( pmb, phba->mbox_mem_pool); 968 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 969 970 /* RegLogin failed, so just use loop map to make discovery 971 list */ 972 lpfc_disc_list_loopmap(phba); 973 974 /* Start discovery */ 975 lpfc_disc_start(phba); 976 return; 977 } 978 979 pmb->context1 = NULL; 980 981 ndlp->nlp_rpi = mb->un.varWords[0]; 982 ndlp->nlp_type |= NLP_FABRIC; 983 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 984 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 985 986 if (phba->hba_state < LPFC_HBA_READY) { 987 /* Link up discovery requires Fabrib registration. */ 988 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RNN_ID); 989 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RSNN_NN); 990 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RFT_ID); 991 } 992 993 phba->fc_ns_retry = 0; 994 /* Good status, issue CT Request to NameServer */ 995 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT)) { 996 /* Cannot issue NameServer Query, so finish up discovery */ 997 lpfc_disc_start(phba); 998 } 999 1000 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1001 kfree(mp); 1002 mempool_free( pmb, phba->mbox_mem_pool); 1003 1004 return; 1005 } 1006 1007 static void 1008 lpfc_register_remote_port(struct lpfc_hba * phba, 1009 struct lpfc_nodelist * ndlp) 1010 { 1011 struct fc_rport *rport; 1012 struct lpfc_rport_data *rdata; 1013 struct fc_rport_identifiers rport_ids; 1014 1015 /* Remote port has reappeared. Re-register w/ FC transport */ 1016 rport_ids.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn); 1017 rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn); 1018 rport_ids.port_id = ndlp->nlp_DID; 1019 rport_ids.roles = FC_RPORT_ROLE_UNKNOWN; 1020 1021 ndlp->rport = rport = fc_remote_port_add(phba->host, 0, &rport_ids); 1022 if (!rport) { 1023 dev_printk(KERN_WARNING, &phba->pcidev->dev, 1024 "Warning: fc_remote_port_add failed\n"); 1025 return; 1026 } 1027 1028 /* initialize static port data */ 1029 rport->maxframe_size = ndlp->nlp_maxframe; 1030 rport->supported_classes = ndlp->nlp_class_sup; 1031 if ((rport->scsi_target_id != -1) && 1032 (rport->scsi_target_id < MAX_FCP_TARGET)) { 1033 ndlp->nlp_sid = rport->scsi_target_id; 1034 } 1035 rdata = rport->dd_data; 1036 rdata->pnode = ndlp; 1037 1038 if (ndlp->nlp_type & NLP_FCP_TARGET) 1039 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; 1040 if (ndlp->nlp_type & NLP_FCP_INITIATOR) 1041 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR; 1042 1043 1044 if (rport_ids.roles != FC_RPORT_ROLE_UNKNOWN) 1045 fc_remote_port_rolechg(rport, rport_ids.roles); 1046 1047 1048 return; 1049 } 1050 1051 static void 1052 lpfc_unregister_remote_port(struct lpfc_hba * phba, 1053 struct lpfc_nodelist * ndlp) 1054 { 1055 struct fc_rport *rport = ndlp->rport; 1056 struct lpfc_rport_data *rdata = rport->dd_data; 1057 1058 ndlp->rport = NULL; 1059 rdata->pnode = NULL; 1060 fc_remote_port_delete(rport); 1061 1062 return; 1063 } 1064 1065 int 1066 lpfc_nlp_list(struct lpfc_hba * phba, struct lpfc_nodelist * nlp, int list) 1067 { 1068 enum { none, unmapped, mapped } rport_add = none, rport_del = none; 1069 struct lpfc_sli *psli; 1070 1071 psli = &phba->sli; 1072 /* Sanity check to ensure we are not moving to / from the same list */ 1073 if ((nlp->nlp_flag & NLP_LIST_MASK) == list) { 1074 if (list != NLP_NO_LIST) 1075 return(0); 1076 } 1077 1078 switch(nlp->nlp_flag & NLP_LIST_MASK) { 1079 case NLP_NO_LIST: /* Not on any list */ 1080 break; 1081 case NLP_UNUSED_LIST: 1082 phba->fc_unused_cnt--; 1083 list_del(&nlp->nlp_listp); 1084 break; 1085 case NLP_PLOGI_LIST: 1086 phba->fc_plogi_cnt--; 1087 list_del(&nlp->nlp_listp); 1088 break; 1089 case NLP_ADISC_LIST: 1090 phba->fc_adisc_cnt--; 1091 list_del(&nlp->nlp_listp); 1092 break; 1093 case NLP_REGLOGIN_LIST: 1094 phba->fc_reglogin_cnt--; 1095 list_del(&nlp->nlp_listp); 1096 break; 1097 case NLP_PRLI_LIST: 1098 phba->fc_prli_cnt--; 1099 list_del(&nlp->nlp_listp); 1100 break; 1101 case NLP_UNMAPPED_LIST: 1102 phba->fc_unmap_cnt--; 1103 list_del(&nlp->nlp_listp); 1104 spin_lock_irq(phba->host->host_lock); 1105 nlp->nlp_flag &= ~NLP_TGT_NO_SCSIID; 1106 nlp->nlp_type &= ~NLP_FC_NODE; 1107 spin_unlock_irq(phba->host->host_lock); 1108 phba->nport_event_cnt++; 1109 if (nlp->rport) 1110 rport_del = unmapped; 1111 break; 1112 case NLP_MAPPED_LIST: 1113 phba->fc_map_cnt--; 1114 list_del(&nlp->nlp_listp); 1115 phba->nport_event_cnt++; 1116 if (nlp->rport) 1117 rport_del = mapped; 1118 break; 1119 case NLP_NPR_LIST: 1120 phba->fc_npr_cnt--; 1121 list_del(&nlp->nlp_listp); 1122 /* Stop delay tmo if taking node off NPR list */ 1123 if ((nlp->nlp_flag & NLP_DELAY_TMO) && 1124 (list != NLP_NPR_LIST)) { 1125 spin_lock_irq(phba->host->host_lock); 1126 nlp->nlp_flag &= ~NLP_DELAY_TMO; 1127 spin_unlock_irq(phba->host->host_lock); 1128 del_timer_sync(&nlp->nlp_delayfunc); 1129 if (!list_empty(&nlp->els_retry_evt.evt_listp)) 1130 list_del_init(&nlp->els_retry_evt.evt_listp); 1131 } 1132 break; 1133 } 1134 1135 spin_lock_irq(phba->host->host_lock); 1136 nlp->nlp_flag &= ~NLP_LIST_MASK; 1137 spin_unlock_irq(phba->host->host_lock); 1138 1139 /* Add NPort <did> to <num> list */ 1140 lpfc_printf_log(phba, 1141 KERN_INFO, 1142 LOG_NODE, 1143 "%d:0904 Add NPort x%x to %d list Data: x%x\n", 1144 phba->brd_no, 1145 nlp->nlp_DID, list, nlp->nlp_flag); 1146 1147 switch(list) { 1148 case NLP_NO_LIST: /* No list, just remove it */ 1149 lpfc_nlp_remove(phba, nlp); 1150 /* as node removed - stop further transport calls */ 1151 rport_del = none; 1152 break; 1153 case NLP_UNUSED_LIST: 1154 spin_lock_irq(phba->host->host_lock); 1155 nlp->nlp_flag |= list; 1156 spin_unlock_irq(phba->host->host_lock); 1157 /* Put it at the end of the unused list */ 1158 list_add_tail(&nlp->nlp_listp, &phba->fc_unused_list); 1159 phba->fc_unused_cnt++; 1160 break; 1161 case NLP_PLOGI_LIST: 1162 spin_lock_irq(phba->host->host_lock); 1163 nlp->nlp_flag |= list; 1164 spin_unlock_irq(phba->host->host_lock); 1165 /* Put it at the end of the plogi list */ 1166 list_add_tail(&nlp->nlp_listp, &phba->fc_plogi_list); 1167 phba->fc_plogi_cnt++; 1168 break; 1169 case NLP_ADISC_LIST: 1170 spin_lock_irq(phba->host->host_lock); 1171 nlp->nlp_flag |= list; 1172 spin_unlock_irq(phba->host->host_lock); 1173 /* Put it at the end of the adisc list */ 1174 list_add_tail(&nlp->nlp_listp, &phba->fc_adisc_list); 1175 phba->fc_adisc_cnt++; 1176 break; 1177 case NLP_REGLOGIN_LIST: 1178 spin_lock_irq(phba->host->host_lock); 1179 nlp->nlp_flag |= list; 1180 spin_unlock_irq(phba->host->host_lock); 1181 /* Put it at the end of the reglogin list */ 1182 list_add_tail(&nlp->nlp_listp, &phba->fc_reglogin_list); 1183 phba->fc_reglogin_cnt++; 1184 break; 1185 case NLP_PRLI_LIST: 1186 spin_lock_irq(phba->host->host_lock); 1187 nlp->nlp_flag |= list; 1188 spin_unlock_irq(phba->host->host_lock); 1189 /* Put it at the end of the prli list */ 1190 list_add_tail(&nlp->nlp_listp, &phba->fc_prli_list); 1191 phba->fc_prli_cnt++; 1192 break; 1193 case NLP_UNMAPPED_LIST: 1194 rport_add = unmapped; 1195 /* ensure all vestiges of "mapped" significance are gone */ 1196 nlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR); 1197 spin_lock_irq(phba->host->host_lock); 1198 nlp->nlp_flag |= list; 1199 spin_unlock_irq(phba->host->host_lock); 1200 /* Put it at the end of the unmap list */ 1201 list_add_tail(&nlp->nlp_listp, &phba->fc_nlpunmap_list); 1202 phba->fc_unmap_cnt++; 1203 phba->nport_event_cnt++; 1204 /* stop nodev tmo if running */ 1205 if (nlp->nlp_flag & NLP_NODEV_TMO) { 1206 spin_lock_irq(phba->host->host_lock); 1207 nlp->nlp_flag &= ~NLP_NODEV_TMO; 1208 spin_unlock_irq(phba->host->host_lock); 1209 del_timer_sync(&nlp->nlp_tmofunc); 1210 if (!list_empty(&nlp->nodev_timeout_evt.evt_listp)) 1211 list_del_init(&nlp->nodev_timeout_evt. 1212 evt_listp); 1213 1214 } 1215 nlp->nlp_type |= NLP_FC_NODE; 1216 break; 1217 case NLP_MAPPED_LIST: 1218 rport_add = mapped; 1219 spin_lock_irq(phba->host->host_lock); 1220 nlp->nlp_flag |= list; 1221 spin_unlock_irq(phba->host->host_lock); 1222 /* Put it at the end of the map list */ 1223 list_add_tail(&nlp->nlp_listp, &phba->fc_nlpmap_list); 1224 phba->fc_map_cnt++; 1225 phba->nport_event_cnt++; 1226 /* stop nodev tmo if running */ 1227 if (nlp->nlp_flag & NLP_NODEV_TMO) { 1228 nlp->nlp_flag &= ~NLP_NODEV_TMO; 1229 del_timer_sync(&nlp->nlp_tmofunc); 1230 if (!list_empty(&nlp->nodev_timeout_evt.evt_listp)) 1231 list_del_init(&nlp->nodev_timeout_evt. 1232 evt_listp); 1233 1234 } 1235 break; 1236 case NLP_NPR_LIST: 1237 spin_lock_irq(phba->host->host_lock); 1238 nlp->nlp_flag |= list; 1239 spin_unlock_irq(phba->host->host_lock); 1240 /* Put it at the end of the npr list */ 1241 list_add_tail(&nlp->nlp_listp, &phba->fc_npr_list); 1242 phba->fc_npr_cnt++; 1243 1244 /* 1245 * Sanity check for Fabric entity. 1246 * Set nodev_tmo for NPR state, for Fabric use 1 sec. 1247 */ 1248 if (nlp->nlp_type & NLP_FABRIC) { 1249 mod_timer(&nlp->nlp_tmofunc, jiffies + HZ); 1250 } 1251 else { 1252 mod_timer(&nlp->nlp_tmofunc, 1253 jiffies + HZ * phba->cfg_nodev_tmo); 1254 } 1255 spin_lock_irq(phba->host->host_lock); 1256 nlp->nlp_flag |= NLP_NODEV_TMO; 1257 nlp->nlp_flag &= ~NLP_RCV_PLOGI; 1258 spin_unlock_irq(phba->host->host_lock); 1259 break; 1260 case NLP_JUST_DQ: 1261 break; 1262 } 1263 1264 /* 1265 * We make all the calls into the transport after we have 1266 * moved the node between lists. This so that we don't 1267 * release the lock while in-between lists. 1268 */ 1269 1270 /* Don't upcall midlayer if we're unloading */ 1271 if (!(phba->fc_flag & FC_UNLOADING)) { 1272 /* 1273 * We revalidate the rport pointer as the "add" function 1274 * may have removed the remote port. 1275 */ 1276 if ((rport_del != none) && nlp->rport) 1277 lpfc_unregister_remote_port(phba, nlp); 1278 1279 if (rport_add != none) { 1280 /* 1281 * Tell the fc transport about the port, if we haven't 1282 * already. If we have, and it's a scsi entity, be 1283 * sure to unblock any attached scsi devices 1284 */ 1285 if (!nlp->rport) 1286 lpfc_register_remote_port(phba, nlp); 1287 1288 /* 1289 * if we added to Mapped list, but the remote port 1290 * registration failed or assigned a target id outside 1291 * our presentable range - move the node to the 1292 * Unmapped List 1293 */ 1294 if ((rport_add == mapped) && 1295 ((!nlp->rport) || 1296 (nlp->rport->scsi_target_id == -1) || 1297 (nlp->rport->scsi_target_id >= MAX_FCP_TARGET))) { 1298 nlp->nlp_state = NLP_STE_UNMAPPED_NODE; 1299 spin_lock_irq(phba->host->host_lock); 1300 nlp->nlp_flag |= NLP_TGT_NO_SCSIID; 1301 spin_unlock_irq(phba->host->host_lock); 1302 lpfc_nlp_list(phba, nlp, NLP_UNMAPPED_LIST); 1303 } 1304 } 1305 } 1306 return (0); 1307 } 1308 1309 /* 1310 * Start / ReStart rescue timer for Discovery / RSCN handling 1311 */ 1312 void 1313 lpfc_set_disctmo(struct lpfc_hba * phba) 1314 { 1315 uint32_t tmo; 1316 1317 tmo = ((phba->fc_ratov * 2) + 1); 1318 1319 mod_timer(&phba->fc_disctmo, jiffies + HZ * tmo); 1320 spin_lock_irq(phba->host->host_lock); 1321 phba->fc_flag |= FC_DISC_TMO; 1322 spin_unlock_irq(phba->host->host_lock); 1323 1324 /* Start Discovery Timer state <hba_state> */ 1325 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1326 "%d:0247 Start Discovery Timer state x%x " 1327 "Data: x%x x%lx x%x x%x\n", 1328 phba->brd_no, 1329 phba->hba_state, tmo, (unsigned long)&phba->fc_disctmo, 1330 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1331 1332 return; 1333 } 1334 1335 /* 1336 * Cancel rescue timer for Discovery / RSCN handling 1337 */ 1338 int 1339 lpfc_can_disctmo(struct lpfc_hba * phba) 1340 { 1341 /* Turn off discovery timer if its running */ 1342 if (phba->fc_flag & FC_DISC_TMO) { 1343 spin_lock_irq(phba->host->host_lock); 1344 phba->fc_flag &= ~FC_DISC_TMO; 1345 spin_unlock_irq(phba->host->host_lock); 1346 del_timer_sync(&phba->fc_disctmo); 1347 phba->work_hba_events &= ~WORKER_DISC_TMO; 1348 } 1349 1350 /* Cancel Discovery Timer state <hba_state> */ 1351 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1352 "%d:0248 Cancel Discovery Timer state x%x " 1353 "Data: x%x x%x x%x\n", 1354 phba->brd_no, phba->hba_state, phba->fc_flag, 1355 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1356 1357 return (0); 1358 } 1359 1360 /* 1361 * Check specified ring for outstanding IOCB on the SLI queue 1362 * Return true if iocb matches the specified nport 1363 */ 1364 int 1365 lpfc_check_sli_ndlp(struct lpfc_hba * phba, 1366 struct lpfc_sli_ring * pring, 1367 struct lpfc_iocbq * iocb, struct lpfc_nodelist * ndlp) 1368 { 1369 struct lpfc_sli *psli; 1370 IOCB_t *icmd; 1371 1372 psli = &phba->sli; 1373 icmd = &iocb->iocb; 1374 if (pring->ringno == LPFC_ELS_RING) { 1375 switch (icmd->ulpCommand) { 1376 case CMD_GEN_REQUEST64_CR: 1377 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) 1378 return (1); 1379 case CMD_ELS_REQUEST64_CR: 1380 case CMD_XMIT_ELS_RSP64_CX: 1381 if (iocb->context1 == (uint8_t *) ndlp) 1382 return (1); 1383 } 1384 } else if (pring->ringno == psli->ip_ring) { 1385 1386 } else if (pring->ringno == psli->fcp_ring) { 1387 /* Skip match check if waiting to relogin to FCP target */ 1388 if ((ndlp->nlp_type & NLP_FCP_TARGET) && 1389 (ndlp->nlp_flag & NLP_DELAY_TMO)) { 1390 return (0); 1391 } 1392 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) { 1393 return (1); 1394 } 1395 } else if (pring->ringno == psli->next_ring) { 1396 1397 } 1398 return (0); 1399 } 1400 1401 /* 1402 * Free resources / clean up outstanding I/Os 1403 * associated with nlp_rpi in the LPFC_NODELIST entry. 1404 */ 1405 static int 1406 lpfc_no_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1407 { 1408 struct lpfc_sli *psli; 1409 struct lpfc_sli_ring *pring; 1410 struct lpfc_iocbq *iocb, *next_iocb; 1411 IOCB_t *icmd; 1412 uint32_t rpi, i; 1413 1414 /* 1415 * Everything that matches on txcmplq will be returned 1416 * by firmware with a no rpi error. 1417 */ 1418 psli = &phba->sli; 1419 rpi = ndlp->nlp_rpi; 1420 if (rpi) { 1421 /* Now process each ring */ 1422 for (i = 0; i < psli->num_rings; i++) { 1423 pring = &psli->ring[i]; 1424 1425 spin_lock_irq(phba->host->host_lock); 1426 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, 1427 list) { 1428 /* 1429 * Check to see if iocb matches the nport we are 1430 * looking for 1431 */ 1432 if ((lpfc_check_sli_ndlp 1433 (phba, pring, iocb, ndlp))) { 1434 /* It matches, so deque and call compl 1435 with an error */ 1436 list_del(&iocb->list); 1437 pring->txq_cnt--; 1438 if (iocb->iocb_cmpl) { 1439 icmd = &iocb->iocb; 1440 icmd->ulpStatus = 1441 IOSTAT_LOCAL_REJECT; 1442 icmd->un.ulpWord[4] = 1443 IOERR_SLI_ABORTED; 1444 spin_unlock_irq(phba->host-> 1445 host_lock); 1446 (iocb->iocb_cmpl) (phba, 1447 iocb, iocb); 1448 spin_lock_irq(phba->host-> 1449 host_lock); 1450 } else 1451 lpfc_sli_release_iocbq(phba, 1452 iocb); 1453 } 1454 } 1455 spin_unlock_irq(phba->host->host_lock); 1456 1457 } 1458 } 1459 return (0); 1460 } 1461 1462 /* 1463 * Free rpi associated with LPFC_NODELIST entry. 1464 * This routine is called from lpfc_freenode(), when we are removing 1465 * a LPFC_NODELIST entry. It is also called if the driver initiates a 1466 * LOGO that completes successfully, and we are waiting to PLOGI back 1467 * to the remote NPort. In addition, it is called after we receive 1468 * and unsolicated ELS cmd, send back a rsp, the rsp completes and 1469 * we are waiting to PLOGI back to the remote NPort. 1470 */ 1471 int 1472 lpfc_unreg_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1473 { 1474 LPFC_MBOXQ_t *mbox; 1475 int rc; 1476 1477 if (ndlp->nlp_rpi) { 1478 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 1479 lpfc_unreg_login(phba, ndlp->nlp_rpi, mbox); 1480 mbox->mbox_cmpl=lpfc_sli_def_mbox_cmpl; 1481 rc = lpfc_sli_issue_mbox 1482 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB)); 1483 if (rc == MBX_NOT_FINISHED) 1484 mempool_free( mbox, phba->mbox_mem_pool); 1485 } 1486 lpfc_no_rpi(phba, ndlp); 1487 ndlp->nlp_rpi = 0; 1488 return 1; 1489 } 1490 return 0; 1491 } 1492 1493 /* 1494 * Free resources associated with LPFC_NODELIST entry 1495 * so it can be freed. 1496 */ 1497 static int 1498 lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1499 { 1500 LPFC_MBOXQ_t *mb; 1501 LPFC_MBOXQ_t *nextmb; 1502 struct lpfc_dmabuf *mp; 1503 1504 /* Cleanup node for NPort <nlp_DID> */ 1505 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1506 "%d:0900 Cleanup node for NPort x%x " 1507 "Data: x%x x%x x%x\n", 1508 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag, 1509 ndlp->nlp_state, ndlp->nlp_rpi); 1510 1511 lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ); 1512 1513 /* 1514 * if unloading the driver - just leave the remote port in place. 1515 * The driver unload will force the attached devices to detach 1516 * and flush cache's w/o generating flush errors. 1517 */ 1518 if ((ndlp->rport) && !(phba->fc_flag & FC_UNLOADING)) { 1519 lpfc_unregister_remote_port(phba, ndlp); 1520 ndlp->nlp_sid = NLP_NO_SID; 1521 } 1522 1523 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */ 1524 if ((mb = phba->sli.mbox_active)) { 1525 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 1526 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1527 mb->context2 = NULL; 1528 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 1529 } 1530 } 1531 list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) { 1532 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 1533 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1534 mp = (struct lpfc_dmabuf *) (mb->context1); 1535 if (mp) { 1536 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1537 kfree(mp); 1538 } 1539 list_del(&mb->list); 1540 mempool_free(mb, phba->mbox_mem_pool); 1541 } 1542 } 1543 1544 lpfc_els_abort(phba,ndlp,0); 1545 spin_lock_irq(phba->host->host_lock); 1546 ndlp->nlp_flag &= ~(NLP_NODEV_TMO|NLP_DELAY_TMO); 1547 spin_unlock_irq(phba->host->host_lock); 1548 del_timer_sync(&ndlp->nlp_tmofunc); 1549 1550 del_timer_sync(&ndlp->nlp_delayfunc); 1551 1552 if (!list_empty(&ndlp->nodev_timeout_evt.evt_listp)) 1553 list_del_init(&ndlp->nodev_timeout_evt.evt_listp); 1554 if (!list_empty(&ndlp->els_retry_evt.evt_listp)) 1555 list_del_init(&ndlp->els_retry_evt.evt_listp); 1556 1557 lpfc_unreg_rpi(phba, ndlp); 1558 1559 return (0); 1560 } 1561 1562 /* 1563 * Check to see if we can free the nlp back to the freelist. 1564 * If we are in the middle of using the nlp in the discovery state 1565 * machine, defer the free till we reach the end of the state machine. 1566 */ 1567 int 1568 lpfc_nlp_remove(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1569 { 1570 if (ndlp->nlp_flag & NLP_NODEV_TMO) { 1571 spin_lock_irq(phba->host->host_lock); 1572 ndlp->nlp_flag &= ~NLP_NODEV_TMO; 1573 spin_unlock_irq(phba->host->host_lock); 1574 del_timer_sync(&ndlp->nlp_tmofunc); 1575 if (!list_empty(&ndlp->nodev_timeout_evt.evt_listp)) 1576 list_del_init(&ndlp->nodev_timeout_evt.evt_listp); 1577 1578 } 1579 1580 1581 if (ndlp->nlp_flag & NLP_DELAY_TMO) { 1582 spin_lock_irq(phba->host->host_lock); 1583 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 1584 spin_unlock_irq(phba->host->host_lock); 1585 del_timer_sync(&ndlp->nlp_delayfunc); 1586 if (!list_empty(&ndlp->els_retry_evt.evt_listp)) 1587 list_del_init(&ndlp->els_retry_evt.evt_listp); 1588 } 1589 1590 if (ndlp->nlp_disc_refcnt) { 1591 spin_lock_irq(phba->host->host_lock); 1592 ndlp->nlp_flag |= NLP_DELAY_REMOVE; 1593 spin_unlock_irq(phba->host->host_lock); 1594 } 1595 else { 1596 lpfc_freenode(phba, ndlp); 1597 mempool_free( ndlp, phba->nlp_mem_pool); 1598 } 1599 return(0); 1600 } 1601 1602 static int 1603 lpfc_matchdid(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, uint32_t did) 1604 { 1605 D_ID mydid; 1606 D_ID ndlpdid; 1607 D_ID matchdid; 1608 1609 if (did == Bcast_DID) 1610 return (0); 1611 1612 if (ndlp->nlp_DID == 0) { 1613 return (0); 1614 } 1615 1616 /* First check for Direct match */ 1617 if (ndlp->nlp_DID == did) 1618 return (1); 1619 1620 /* Next check for area/domain identically equals 0 match */ 1621 mydid.un.word = phba->fc_myDID; 1622 if ((mydid.un.b.domain == 0) && (mydid.un.b.area == 0)) { 1623 return (0); 1624 } 1625 1626 matchdid.un.word = did; 1627 ndlpdid.un.word = ndlp->nlp_DID; 1628 if (matchdid.un.b.id == ndlpdid.un.b.id) { 1629 if ((mydid.un.b.domain == matchdid.un.b.domain) && 1630 (mydid.un.b.area == matchdid.un.b.area)) { 1631 if ((ndlpdid.un.b.domain == 0) && 1632 (ndlpdid.un.b.area == 0)) { 1633 if (ndlpdid.un.b.id) 1634 return (1); 1635 } 1636 return (0); 1637 } 1638 1639 matchdid.un.word = ndlp->nlp_DID; 1640 if ((mydid.un.b.domain == ndlpdid.un.b.domain) && 1641 (mydid.un.b.area == ndlpdid.un.b.area)) { 1642 if ((matchdid.un.b.domain == 0) && 1643 (matchdid.un.b.area == 0)) { 1644 if (matchdid.un.b.id) 1645 return (1); 1646 } 1647 } 1648 } 1649 return (0); 1650 } 1651 1652 /* Search for a nodelist entry on a specific list */ 1653 struct lpfc_nodelist * 1654 lpfc_findnode_did(struct lpfc_hba * phba, uint32_t order, uint32_t did) 1655 { 1656 struct lpfc_nodelist *ndlp, *next_ndlp; 1657 uint32_t data1; 1658 1659 if (order & NLP_SEARCH_UNMAPPED) { 1660 list_for_each_entry_safe(ndlp, next_ndlp, 1661 &phba->fc_nlpunmap_list, nlp_listp) { 1662 if (lpfc_matchdid(phba, ndlp, did)) { 1663 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1664 ((uint32_t) ndlp->nlp_xri << 16) | 1665 ((uint32_t) ndlp->nlp_type << 8) | 1666 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1667 /* FIND node DID unmapped */ 1668 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1669 "%d:0929 FIND node DID unmapped" 1670 " Data: x%p x%x x%x x%x\n", 1671 phba->brd_no, 1672 ndlp, ndlp->nlp_DID, 1673 ndlp->nlp_flag, data1); 1674 return (ndlp); 1675 } 1676 } 1677 } 1678 1679 if (order & NLP_SEARCH_MAPPED) { 1680 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nlpmap_list, 1681 nlp_listp) { 1682 if (lpfc_matchdid(phba, ndlp, did)) { 1683 1684 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1685 ((uint32_t) ndlp->nlp_xri << 16) | 1686 ((uint32_t) ndlp->nlp_type << 8) | 1687 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1688 /* FIND node DID mapped */ 1689 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1690 "%d:0930 FIND node DID mapped " 1691 "Data: x%p x%x x%x x%x\n", 1692 phba->brd_no, 1693 ndlp, ndlp->nlp_DID, 1694 ndlp->nlp_flag, data1); 1695 return (ndlp); 1696 } 1697 } 1698 } 1699 1700 if (order & NLP_SEARCH_PLOGI) { 1701 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list, 1702 nlp_listp) { 1703 if (lpfc_matchdid(phba, ndlp, did)) { 1704 1705 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1706 ((uint32_t) ndlp->nlp_xri << 16) | 1707 ((uint32_t) ndlp->nlp_type << 8) | 1708 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1709 /* LOG change to PLOGI */ 1710 /* FIND node DID plogi */ 1711 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1712 "%d:0908 FIND node DID plogi " 1713 "Data: x%p x%x x%x x%x\n", 1714 phba->brd_no, 1715 ndlp, ndlp->nlp_DID, 1716 ndlp->nlp_flag, data1); 1717 return (ndlp); 1718 } 1719 } 1720 } 1721 1722 if (order & NLP_SEARCH_ADISC) { 1723 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 1724 nlp_listp) { 1725 if (lpfc_matchdid(phba, ndlp, did)) { 1726 1727 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1728 ((uint32_t) ndlp->nlp_xri << 16) | 1729 ((uint32_t) ndlp->nlp_type << 8) | 1730 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1731 /* LOG change to ADISC */ 1732 /* FIND node DID adisc */ 1733 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1734 "%d:0931 FIND node DID adisc " 1735 "Data: x%p x%x x%x x%x\n", 1736 phba->brd_no, 1737 ndlp, ndlp->nlp_DID, 1738 ndlp->nlp_flag, data1); 1739 return (ndlp); 1740 } 1741 } 1742 } 1743 1744 if (order & NLP_SEARCH_REGLOGIN) { 1745 list_for_each_entry_safe(ndlp, next_ndlp, 1746 &phba->fc_reglogin_list, nlp_listp) { 1747 if (lpfc_matchdid(phba, ndlp, did)) { 1748 1749 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1750 ((uint32_t) ndlp->nlp_xri << 16) | 1751 ((uint32_t) ndlp->nlp_type << 8) | 1752 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1753 /* LOG change to REGLOGIN */ 1754 /* FIND node DID reglogin */ 1755 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1756 "%d:0931 FIND node DID reglogin" 1757 " Data: x%p x%x x%x x%x\n", 1758 phba->brd_no, 1759 ndlp, ndlp->nlp_DID, 1760 ndlp->nlp_flag, data1); 1761 return (ndlp); 1762 } 1763 } 1764 } 1765 1766 if (order & NLP_SEARCH_PRLI) { 1767 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_prli_list, 1768 nlp_listp) { 1769 if (lpfc_matchdid(phba, ndlp, did)) { 1770 1771 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1772 ((uint32_t) ndlp->nlp_xri << 16) | 1773 ((uint32_t) ndlp->nlp_type << 8) | 1774 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1775 /* LOG change to PRLI */ 1776 /* FIND node DID prli */ 1777 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1778 "%d:0931 FIND node DID prli " 1779 "Data: x%p x%x x%x x%x\n", 1780 phba->brd_no, 1781 ndlp, ndlp->nlp_DID, 1782 ndlp->nlp_flag, data1); 1783 return (ndlp); 1784 } 1785 } 1786 } 1787 1788 if (order & NLP_SEARCH_NPR) { 1789 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 1790 nlp_listp) { 1791 if (lpfc_matchdid(phba, ndlp, did)) { 1792 1793 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1794 ((uint32_t) ndlp->nlp_xri << 16) | 1795 ((uint32_t) ndlp->nlp_type << 8) | 1796 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1797 /* LOG change to NPR */ 1798 /* FIND node DID npr */ 1799 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1800 "%d:0931 FIND node DID npr " 1801 "Data: x%p x%x x%x x%x\n", 1802 phba->brd_no, 1803 ndlp, ndlp->nlp_DID, 1804 ndlp->nlp_flag, data1); 1805 return (ndlp); 1806 } 1807 } 1808 } 1809 1810 if (order & NLP_SEARCH_UNUSED) { 1811 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 1812 nlp_listp) { 1813 if (lpfc_matchdid(phba, ndlp, did)) { 1814 1815 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1816 ((uint32_t) ndlp->nlp_xri << 16) | 1817 ((uint32_t) ndlp->nlp_type << 8) | 1818 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1819 /* LOG change to UNUSED */ 1820 /* FIND node DID unused */ 1821 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1822 "%d:0931 FIND node DID unused " 1823 "Data: x%p x%x x%x x%x\n", 1824 phba->brd_no, 1825 ndlp, ndlp->nlp_DID, 1826 ndlp->nlp_flag, data1); 1827 return (ndlp); 1828 } 1829 } 1830 } 1831 1832 /* FIND node did <did> NOT FOUND */ 1833 lpfc_printf_log(phba, 1834 KERN_INFO, 1835 LOG_NODE, 1836 "%d:0932 FIND node did x%x NOT FOUND Data: x%x\n", 1837 phba->brd_no, did, order); 1838 1839 /* no match found */ 1840 return NULL; 1841 } 1842 1843 struct lpfc_nodelist * 1844 lpfc_setup_disc_node(struct lpfc_hba * phba, uint32_t did) 1845 { 1846 struct lpfc_nodelist *ndlp; 1847 uint32_t flg; 1848 1849 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did)) == 0) { 1850 if ((phba->hba_state == LPFC_HBA_READY) && 1851 ((lpfc_rscn_payload_check(phba, did) == 0))) 1852 return NULL; 1853 ndlp = (struct lpfc_nodelist *) 1854 mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 1855 if (!ndlp) 1856 return NULL; 1857 lpfc_nlp_init(phba, ndlp, did); 1858 ndlp->nlp_state = NLP_STE_NPR_NODE; 1859 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1860 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1861 return ndlp; 1862 } 1863 if ((phba->hba_state == LPFC_HBA_READY) && 1864 (phba->fc_flag & FC_RSCN_MODE)) { 1865 if (lpfc_rscn_payload_check(phba, did)) { 1866 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1867 } 1868 else { 1869 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 1870 ndlp = NULL; 1871 } 1872 } 1873 else { 1874 flg = ndlp->nlp_flag & NLP_LIST_MASK; 1875 if ((flg == NLP_ADISC_LIST) || 1876 (flg == NLP_PLOGI_LIST)) { 1877 return NULL; 1878 } 1879 ndlp->nlp_state = NLP_STE_NPR_NODE; 1880 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1881 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1882 } 1883 return ndlp; 1884 } 1885 1886 /* Build a list of nodes to discover based on the loopmap */ 1887 void 1888 lpfc_disc_list_loopmap(struct lpfc_hba * phba) 1889 { 1890 int j; 1891 uint32_t alpa, index; 1892 1893 if (phba->hba_state <= LPFC_LINK_DOWN) { 1894 return; 1895 } 1896 if (phba->fc_topology != TOPOLOGY_LOOP) { 1897 return; 1898 } 1899 1900 /* Check for loop map present or not */ 1901 if (phba->alpa_map[0]) { 1902 for (j = 1; j <= phba->alpa_map[0]; j++) { 1903 alpa = phba->alpa_map[j]; 1904 1905 if (((phba->fc_myDID & 0xff) == alpa) || (alpa == 0)) { 1906 continue; 1907 } 1908 lpfc_setup_disc_node(phba, alpa); 1909 } 1910 } else { 1911 /* No alpamap, so try all alpa's */ 1912 for (j = 0; j < FC_MAXLOOP; j++) { 1913 /* If cfg_scan_down is set, start from highest 1914 * ALPA (0xef) to lowest (0x1). 1915 */ 1916 if (phba->cfg_scan_down) 1917 index = j; 1918 else 1919 index = FC_MAXLOOP - j - 1; 1920 alpa = lpfcAlpaArray[index]; 1921 if ((phba->fc_myDID & 0xff) == alpa) { 1922 continue; 1923 } 1924 1925 lpfc_setup_disc_node(phba, alpa); 1926 } 1927 } 1928 return; 1929 } 1930 1931 /* Start Link up / RSCN discovery on NPR list */ 1932 void 1933 lpfc_disc_start(struct lpfc_hba * phba) 1934 { 1935 struct lpfc_sli *psli; 1936 LPFC_MBOXQ_t *mbox; 1937 struct lpfc_nodelist *ndlp, *next_ndlp; 1938 uint32_t did_changed, num_sent; 1939 uint32_t clear_la_pending; 1940 int rc; 1941 1942 psli = &phba->sli; 1943 1944 if (phba->hba_state <= LPFC_LINK_DOWN) { 1945 return; 1946 } 1947 if (phba->hba_state == LPFC_CLEAR_LA) 1948 clear_la_pending = 1; 1949 else 1950 clear_la_pending = 0; 1951 1952 if (phba->hba_state < LPFC_HBA_READY) { 1953 phba->hba_state = LPFC_DISC_AUTH; 1954 } 1955 lpfc_set_disctmo(phba); 1956 1957 if (phba->fc_prevDID == phba->fc_myDID) { 1958 did_changed = 0; 1959 } else { 1960 did_changed = 1; 1961 } 1962 phba->fc_prevDID = phba->fc_myDID; 1963 phba->num_disc_nodes = 0; 1964 1965 /* Start Discovery state <hba_state> */ 1966 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1967 "%d:0202 Start Discovery hba state x%x " 1968 "Data: x%x x%x x%x\n", 1969 phba->brd_no, phba->hba_state, phba->fc_flag, 1970 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1971 1972 /* If our did changed, we MUST do PLOGI */ 1973 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 1974 nlp_listp) { 1975 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1976 if (did_changed) { 1977 spin_lock_irq(phba->host->host_lock); 1978 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 1979 spin_unlock_irq(phba->host->host_lock); 1980 } 1981 } 1982 } 1983 1984 /* First do ADISCs - if any */ 1985 num_sent = lpfc_els_disc_adisc(phba); 1986 1987 if (num_sent) 1988 return; 1989 1990 if ((phba->hba_state < LPFC_HBA_READY) && (!clear_la_pending)) { 1991 /* If we get here, there is nothing to ADISC */ 1992 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 1993 phba->hba_state = LPFC_CLEAR_LA; 1994 lpfc_clear_la(phba, mbox); 1995 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 1996 rc = lpfc_sli_issue_mbox(phba, mbox, 1997 (MBX_NOWAIT | MBX_STOP_IOCB)); 1998 if (rc == MBX_NOT_FINISHED) { 1999 mempool_free( mbox, phba->mbox_mem_pool); 2000 lpfc_disc_flush_list(phba); 2001 psli->ring[(psli->ip_ring)].flag &= 2002 ~LPFC_STOP_IOCB_EVENT; 2003 psli->ring[(psli->fcp_ring)].flag &= 2004 ~LPFC_STOP_IOCB_EVENT; 2005 psli->ring[(psli->next_ring)].flag &= 2006 ~LPFC_STOP_IOCB_EVENT; 2007 phba->hba_state = LPFC_HBA_READY; 2008 } 2009 } 2010 } else { 2011 /* Next do PLOGIs - if any */ 2012 num_sent = lpfc_els_disc_plogi(phba); 2013 2014 if (num_sent) 2015 return; 2016 2017 if (phba->fc_flag & FC_RSCN_MODE) { 2018 /* Check to see if more RSCNs came in while we 2019 * were processing this one. 2020 */ 2021 if ((phba->fc_rscn_id_cnt == 0) && 2022 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 2023 spin_lock_irq(phba->host->host_lock); 2024 phba->fc_flag &= ~FC_RSCN_MODE; 2025 spin_unlock_irq(phba->host->host_lock); 2026 } 2027 else 2028 lpfc_els_handle_rscn(phba); 2029 } 2030 } 2031 return; 2032 } 2033 2034 /* 2035 * Ignore completion for all IOCBs on tx and txcmpl queue for ELS 2036 * ring the match the sppecified nodelist. 2037 */ 2038 static void 2039 lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 2040 { 2041 struct lpfc_sli *psli; 2042 IOCB_t *icmd; 2043 struct lpfc_iocbq *iocb, *next_iocb; 2044 struct lpfc_sli_ring *pring; 2045 struct lpfc_dmabuf *mp; 2046 2047 psli = &phba->sli; 2048 pring = &psli->ring[LPFC_ELS_RING]; 2049 2050 /* Error matching iocb on txq or txcmplq 2051 * First check the txq. 2052 */ 2053 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) { 2054 if (iocb->context1 != ndlp) { 2055 continue; 2056 } 2057 icmd = &iocb->iocb; 2058 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) || 2059 (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) { 2060 2061 list_del(&iocb->list); 2062 pring->txq_cnt--; 2063 lpfc_els_free_iocb(phba, iocb); 2064 } 2065 } 2066 2067 /* Next check the txcmplq */ 2068 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) { 2069 if (iocb->context1 != ndlp) { 2070 continue; 2071 } 2072 icmd = &iocb->iocb; 2073 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) || 2074 (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) { 2075 2076 iocb->iocb_cmpl = NULL; 2077 /* context2 = cmd, context2->next = rsp, context3 = 2078 bpl */ 2079 if (iocb->context2) { 2080 /* Free the response IOCB before handling the 2081 command. */ 2082 2083 mp = (struct lpfc_dmabuf *) (iocb->context2); 2084 mp = list_get_first(&mp->list, 2085 struct lpfc_dmabuf, 2086 list); 2087 if (mp) { 2088 /* Delay before releasing rsp buffer to 2089 * give UNREG mbox a chance to take 2090 * effect. 2091 */ 2092 list_add(&mp->list, 2093 &phba->freebufList); 2094 } 2095 lpfc_mbuf_free(phba, 2096 ((struct lpfc_dmabuf *) 2097 iocb->context2)->virt, 2098 ((struct lpfc_dmabuf *) 2099 iocb->context2)->phys); 2100 kfree(iocb->context2); 2101 } 2102 2103 if (iocb->context3) { 2104 lpfc_mbuf_free(phba, 2105 ((struct lpfc_dmabuf *) 2106 iocb->context3)->virt, 2107 ((struct lpfc_dmabuf *) 2108 iocb->context3)->phys); 2109 kfree(iocb->context3); 2110 } 2111 } 2112 } 2113 2114 return; 2115 } 2116 2117 void 2118 lpfc_disc_flush_list(struct lpfc_hba * phba) 2119 { 2120 struct lpfc_nodelist *ndlp, *next_ndlp; 2121 2122 if (phba->fc_plogi_cnt) { 2123 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list, 2124 nlp_listp) { 2125 lpfc_free_tx(phba, ndlp); 2126 lpfc_nlp_remove(phba, ndlp); 2127 } 2128 } 2129 if (phba->fc_adisc_cnt) { 2130 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 2131 nlp_listp) { 2132 lpfc_free_tx(phba, ndlp); 2133 lpfc_nlp_remove(phba, ndlp); 2134 } 2135 } 2136 return; 2137 } 2138 2139 /*****************************************************************************/ 2140 /* 2141 * NAME: lpfc_disc_timeout 2142 * 2143 * FUNCTION: Fibre Channel driver discovery timeout routine. 2144 * 2145 * EXECUTION ENVIRONMENT: interrupt only 2146 * 2147 * CALLED FROM: 2148 * Timer function 2149 * 2150 * RETURNS: 2151 * none 2152 */ 2153 /*****************************************************************************/ 2154 void 2155 lpfc_disc_timeout(unsigned long ptr) 2156 { 2157 struct lpfc_hba *phba = (struct lpfc_hba *)ptr; 2158 unsigned long flags = 0; 2159 2160 if (unlikely(!phba)) 2161 return; 2162 2163 spin_lock_irqsave(phba->host->host_lock, flags); 2164 if (!(phba->work_hba_events & WORKER_DISC_TMO)) { 2165 phba->work_hba_events |= WORKER_DISC_TMO; 2166 if (phba->work_wait) 2167 wake_up(phba->work_wait); 2168 } 2169 spin_unlock_irqrestore(phba->host->host_lock, flags); 2170 return; 2171 } 2172 2173 static void 2174 lpfc_disc_timeout_handler(struct lpfc_hba *phba) 2175 { 2176 struct lpfc_sli *psli; 2177 struct lpfc_nodelist *ndlp; 2178 LPFC_MBOXQ_t *clearlambox, *initlinkmbox; 2179 int rc, clrlaerr = 0; 2180 2181 if (unlikely(!phba)) 2182 return; 2183 2184 if (!(phba->fc_flag & FC_DISC_TMO)) 2185 return; 2186 2187 psli = &phba->sli; 2188 2189 spin_lock_irq(phba->host->host_lock); 2190 phba->fc_flag &= ~FC_DISC_TMO; 2191 spin_unlock_irq(phba->host->host_lock); 2192 2193 switch (phba->hba_state) { 2194 2195 case LPFC_LOCAL_CFG_LINK: 2196 /* hba_state is identically LPFC_LOCAL_CFG_LINK while waiting for FAN */ 2197 /* FAN timeout */ 2198 lpfc_printf_log(phba, 2199 KERN_WARNING, 2200 LOG_DISCOVERY, 2201 "%d:0221 FAN timeout\n", 2202 phba->brd_no); 2203 2204 /* Forget about FAN, Start discovery by sending a FLOGI 2205 * hba_state is identically LPFC_FLOGI while waiting for FLOGI 2206 * cmpl 2207 */ 2208 phba->hba_state = LPFC_FLOGI; 2209 lpfc_set_disctmo(phba); 2210 lpfc_initial_flogi(phba); 2211 break; 2212 2213 case LPFC_FLOGI: 2214 /* hba_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */ 2215 /* Initial FLOGI timeout */ 2216 lpfc_printf_log(phba, 2217 KERN_ERR, 2218 LOG_DISCOVERY, 2219 "%d:0222 Initial FLOGI timeout\n", 2220 phba->brd_no); 2221 2222 /* Assume no Fabric and go on with discovery. 2223 * Check for outstanding ELS FLOGI to abort. 2224 */ 2225 2226 /* FLOGI failed, so just use loop map to make discovery list */ 2227 lpfc_disc_list_loopmap(phba); 2228 2229 /* Start discovery */ 2230 lpfc_disc_start(phba); 2231 break; 2232 2233 case LPFC_FABRIC_CFG_LINK: 2234 /* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for 2235 NameServer login */ 2236 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2237 "%d:0223 Timeout while waiting for NameServer " 2238 "login\n", phba->brd_no); 2239 2240 /* Next look for NameServer ndlp */ 2241 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID); 2242 if (ndlp) 2243 lpfc_nlp_remove(phba, ndlp); 2244 /* Start discovery */ 2245 lpfc_disc_start(phba); 2246 break; 2247 2248 case LPFC_NS_QRY: 2249 /* Check for wait for NameServer Rsp timeout */ 2250 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2251 "%d:0224 NameServer Query timeout " 2252 "Data: x%x x%x\n", 2253 phba->brd_no, 2254 phba->fc_ns_retry, LPFC_MAX_NS_RETRY); 2255 2256 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, 2257 NameServer_DID); 2258 if (ndlp) { 2259 if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) { 2260 /* Try it one more time */ 2261 rc = lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT); 2262 if (rc == 0) 2263 break; 2264 } 2265 phba->fc_ns_retry = 0; 2266 } 2267 2268 /* Nothing to authenticate, so CLEAR_LA right now */ 2269 clearlambox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2270 if (!clearlambox) { 2271 clrlaerr = 1; 2272 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2273 "%d:0226 Device Discovery " 2274 "completion error\n", 2275 phba->brd_no); 2276 phba->hba_state = LPFC_HBA_ERROR; 2277 break; 2278 } 2279 2280 phba->hba_state = LPFC_CLEAR_LA; 2281 lpfc_clear_la(phba, clearlambox); 2282 clearlambox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 2283 rc = lpfc_sli_issue_mbox(phba, clearlambox, 2284 (MBX_NOWAIT | MBX_STOP_IOCB)); 2285 if (rc == MBX_NOT_FINISHED) { 2286 mempool_free(clearlambox, phba->mbox_mem_pool); 2287 clrlaerr = 1; 2288 break; 2289 } 2290 2291 /* Setup and issue mailbox INITIALIZE LINK command */ 2292 initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2293 if (!initlinkmbox) { 2294 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2295 "%d:0226 Device Discovery " 2296 "completion error\n", 2297 phba->brd_no); 2298 phba->hba_state = LPFC_HBA_ERROR; 2299 break; 2300 } 2301 2302 lpfc_linkdown(phba); 2303 lpfc_init_link(phba, initlinkmbox, phba->cfg_topology, 2304 phba->cfg_link_speed); 2305 initlinkmbox->mb.un.varInitLnk.lipsr_AL_PA = 0; 2306 rc = lpfc_sli_issue_mbox(phba, initlinkmbox, 2307 (MBX_NOWAIT | MBX_STOP_IOCB)); 2308 if (rc == MBX_NOT_FINISHED) 2309 mempool_free(initlinkmbox, phba->mbox_mem_pool); 2310 2311 break; 2312 2313 case LPFC_DISC_AUTH: 2314 /* Node Authentication timeout */ 2315 lpfc_printf_log(phba, 2316 KERN_ERR, 2317 LOG_DISCOVERY, 2318 "%d:0227 Node Authentication timeout\n", 2319 phba->brd_no); 2320 lpfc_disc_flush_list(phba); 2321 clearlambox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2322 if (!clearlambox) { 2323 clrlaerr = 1; 2324 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2325 "%d:0226 Device Discovery " 2326 "completion error\n", 2327 phba->brd_no); 2328 phba->hba_state = LPFC_HBA_ERROR; 2329 break; 2330 } 2331 phba->hba_state = LPFC_CLEAR_LA; 2332 lpfc_clear_la(phba, clearlambox); 2333 clearlambox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 2334 rc = lpfc_sli_issue_mbox(phba, clearlambox, 2335 (MBX_NOWAIT | MBX_STOP_IOCB)); 2336 if (rc == MBX_NOT_FINISHED) { 2337 mempool_free(clearlambox, phba->mbox_mem_pool); 2338 clrlaerr = 1; 2339 } 2340 break; 2341 2342 case LPFC_CLEAR_LA: 2343 /* CLEAR LA timeout */ 2344 lpfc_printf_log(phba, 2345 KERN_ERR, 2346 LOG_DISCOVERY, 2347 "%d:0228 CLEAR LA timeout\n", 2348 phba->brd_no); 2349 clrlaerr = 1; 2350 break; 2351 2352 case LPFC_HBA_READY: 2353 if (phba->fc_flag & FC_RSCN_MODE) { 2354 lpfc_printf_log(phba, 2355 KERN_ERR, 2356 LOG_DISCOVERY, 2357 "%d:0231 RSCN timeout Data: x%x x%x\n", 2358 phba->brd_no, 2359 phba->fc_ns_retry, LPFC_MAX_NS_RETRY); 2360 2361 /* Cleanup any outstanding ELS commands */ 2362 lpfc_els_flush_cmd(phba); 2363 2364 lpfc_els_flush_rscn(phba); 2365 lpfc_disc_flush_list(phba); 2366 } 2367 break; 2368 } 2369 2370 if (clrlaerr) { 2371 lpfc_disc_flush_list(phba); 2372 psli->ring[(psli->ip_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2373 psli->ring[(psli->fcp_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2374 psli->ring[(psli->next_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2375 phba->hba_state = LPFC_HBA_READY; 2376 } 2377 2378 return; 2379 } 2380 2381 static void 2382 lpfc_nodev_timeout(unsigned long ptr) 2383 { 2384 struct lpfc_hba *phba; 2385 struct lpfc_nodelist *ndlp; 2386 unsigned long iflag; 2387 struct lpfc_work_evt *evtp; 2388 2389 ndlp = (struct lpfc_nodelist *)ptr; 2390 phba = ndlp->nlp_phba; 2391 evtp = &ndlp->nodev_timeout_evt; 2392 spin_lock_irqsave(phba->host->host_lock, iflag); 2393 2394 if (!list_empty(&evtp->evt_listp)) { 2395 spin_unlock_irqrestore(phba->host->host_lock, iflag); 2396 return; 2397 } 2398 evtp->evt_arg1 = ndlp; 2399 evtp->evt = LPFC_EVT_NODEV_TMO; 2400 list_add_tail(&evtp->evt_listp, &phba->work_list); 2401 if (phba->work_wait) 2402 wake_up(phba->work_wait); 2403 2404 spin_unlock_irqrestore(phba->host->host_lock, iflag); 2405 return; 2406 } 2407 2408 2409 /* 2410 * This routine handles processing a NameServer REG_LOGIN mailbox 2411 * command upon completion. It is setup in the LPFC_MBOXQ 2412 * as the completion routine when the command is 2413 * handed off to the SLI layer. 2414 */ 2415 void 2416 lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 2417 { 2418 struct lpfc_sli *psli; 2419 MAILBOX_t *mb; 2420 struct lpfc_dmabuf *mp; 2421 struct lpfc_nodelist *ndlp; 2422 2423 psli = &phba->sli; 2424 mb = &pmb->mb; 2425 2426 ndlp = (struct lpfc_nodelist *) pmb->context2; 2427 mp = (struct lpfc_dmabuf *) (pmb->context1); 2428 2429 pmb->context1 = NULL; 2430 2431 ndlp->nlp_rpi = mb->un.varWords[0]; 2432 ndlp->nlp_type |= NLP_FABRIC; 2433 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 2434 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 2435 2436 /* Start issuing Fabric-Device Management Interface (FDMI) 2437 * command to 0xfffffa (FDMI well known port) 2438 */ 2439 if (phba->cfg_fdmi_on == 1) { 2440 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DHBA); 2441 } else { 2442 /* 2443 * Delay issuing FDMI command if fdmi-on=2 2444 * (supporting RPA/hostnmae) 2445 */ 2446 mod_timer(&phba->fc_fdmitmo, jiffies + HZ * 60); 2447 } 2448 2449 lpfc_mbuf_free(phba, mp->virt, mp->phys); 2450 kfree(mp); 2451 mempool_free( pmb, phba->mbox_mem_pool); 2452 2453 return; 2454 } 2455 2456 /* 2457 * This routine looks up the ndlp lists 2458 * for the given RPI. If rpi found 2459 * it return the node list pointer 2460 * else return NULL. 2461 */ 2462 struct lpfc_nodelist * 2463 lpfc_findnode_rpi(struct lpfc_hba * phba, uint16_t rpi) 2464 { 2465 struct lpfc_nodelist *ndlp; 2466 struct list_head * lists[]={&phba->fc_nlpunmap_list, 2467 &phba->fc_nlpmap_list, 2468 &phba->fc_plogi_list, 2469 &phba->fc_adisc_list, 2470 &phba->fc_reglogin_list}; 2471 int i; 2472 2473 for (i = 0; i < ARRAY_SIZE(lists); i++ ) 2474 list_for_each_entry(ndlp, lists[i], nlp_listp) 2475 if (ndlp->nlp_rpi == rpi) 2476 return (ndlp); 2477 2478 return NULL; 2479 } 2480 2481 void 2482 lpfc_nlp_init(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 2483 uint32_t did) 2484 { 2485 memset(ndlp, 0, sizeof (struct lpfc_nodelist)); 2486 INIT_LIST_HEAD(&ndlp->nodev_timeout_evt.evt_listp); 2487 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp); 2488 init_timer(&ndlp->nlp_tmofunc); 2489 ndlp->nlp_tmofunc.function = lpfc_nodev_timeout; 2490 ndlp->nlp_tmofunc.data = (unsigned long)ndlp; 2491 init_timer(&ndlp->nlp_delayfunc); 2492 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay; 2493 ndlp->nlp_delayfunc.data = (unsigned long)ndlp; 2494 ndlp->nlp_DID = did; 2495 ndlp->nlp_phba = phba; 2496 ndlp->nlp_sid = NLP_NO_SID; 2497 return; 2498 } 2499