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 if (ndlp->nlp_rpi != 0) 894 lpfc_findnode_remove_rpi(phba, ndlp->nlp_rpi); 895 ndlp->nlp_rpi = mb->un.varWords[0]; 896 lpfc_addnode_rpi(phba, ndlp, ndlp->nlp_rpi); 897 ndlp->nlp_type |= NLP_FABRIC; 898 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 899 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 900 901 if (phba->hba_state == LPFC_FABRIC_CFG_LINK) { 902 /* This NPort has been assigned an NPort_ID by the fabric as a 903 * result of the completed fabric login. Issue a State Change 904 * Registration (SCR) ELS request to the fabric controller 905 * (SCR_DID) so that this NPort gets RSCN events from the 906 * fabric. 907 */ 908 lpfc_issue_els_scr(phba, SCR_DID, 0); 909 910 /* Allocate a new node instance. If the pool is empty, just 911 * start the discovery process and skip the Nameserver login 912 * process. This is attempted again later on. Otherwise, issue 913 * a Port Login (PLOGI) to the NameServer 914 */ 915 if ((ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL)) 916 == 0) { 917 lpfc_disc_start(phba); 918 } else { 919 lpfc_nlp_init(phba, ndlp, NameServer_DID); 920 ndlp->nlp_type |= NLP_FABRIC; 921 ndlp->nlp_state = NLP_STE_PLOGI_ISSUE; 922 lpfc_nlp_list(phba, ndlp, NLP_PLOGI_LIST); 923 lpfc_issue_els_plogi(phba, ndlp, 0); 924 if (phba->cfg_fdmi_on) { 925 if ((ndlp_fdmi = mempool_alloc( 926 phba->nlp_mem_pool, 927 GFP_KERNEL))) { 928 lpfc_nlp_init(phba, ndlp_fdmi, 929 FDMI_DID); 930 ndlp_fdmi->nlp_type |= NLP_FABRIC; 931 ndlp_fdmi->nlp_state = 932 NLP_STE_PLOGI_ISSUE; 933 lpfc_issue_els_plogi(phba, ndlp_fdmi, 934 0); 935 } 936 } 937 } 938 } 939 940 lpfc_mbuf_free(phba, mp->virt, mp->phys); 941 kfree(mp); 942 mempool_free( pmb, phba->mbox_mem_pool); 943 944 return; 945 } 946 947 /* 948 * This routine handles processing a NameServer REG_LOGIN mailbox 949 * command upon completion. It is setup in the LPFC_MBOXQ 950 * as the completion routine when the command is 951 * handed off to the SLI layer. 952 */ 953 void 954 lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 955 { 956 struct lpfc_sli *psli; 957 MAILBOX_t *mb; 958 struct lpfc_dmabuf *mp; 959 struct lpfc_nodelist *ndlp; 960 961 psli = &phba->sli; 962 mb = &pmb->mb; 963 964 ndlp = (struct lpfc_nodelist *) pmb->context2; 965 mp = (struct lpfc_dmabuf *) (pmb->context1); 966 967 if (mb->mbxStatus) { 968 lpfc_mbuf_free(phba, mp->virt, mp->phys); 969 kfree(mp); 970 mempool_free( pmb, phba->mbox_mem_pool); 971 lpfc_nlp_list(phba, ndlp, NLP_NO_LIST); 972 973 /* RegLogin failed, so just use loop map to make discovery 974 list */ 975 lpfc_disc_list_loopmap(phba); 976 977 /* Start discovery */ 978 lpfc_disc_start(phba); 979 return; 980 } 981 982 pmb->context1 = NULL; 983 984 if (ndlp->nlp_rpi != 0) 985 lpfc_findnode_remove_rpi(phba, ndlp->nlp_rpi); 986 ndlp->nlp_rpi = mb->un.varWords[0]; 987 lpfc_addnode_rpi(phba, ndlp, ndlp->nlp_rpi); 988 ndlp->nlp_type |= NLP_FABRIC; 989 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 990 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 991 992 if (phba->hba_state < LPFC_HBA_READY) { 993 /* Link up discovery requires Fabrib registration. */ 994 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RNN_ID); 995 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RSNN_NN); 996 lpfc_ns_cmd(phba, ndlp, SLI_CTNS_RFT_ID); 997 } 998 999 phba->fc_ns_retry = 0; 1000 /* Good status, issue CT Request to NameServer */ 1001 if (lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT)) { 1002 /* Cannot issue NameServer Query, so finish up discovery */ 1003 lpfc_disc_start(phba); 1004 } 1005 1006 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1007 kfree(mp); 1008 mempool_free( pmb, phba->mbox_mem_pool); 1009 1010 return; 1011 } 1012 1013 static void 1014 lpfc_register_remote_port(struct lpfc_hba * phba, 1015 struct lpfc_nodelist * ndlp) 1016 { 1017 struct fc_rport *rport; 1018 struct lpfc_rport_data *rdata; 1019 struct fc_rport_identifiers rport_ids; 1020 1021 /* Remote port has reappeared. Re-register w/ FC transport */ 1022 rport_ids.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn); 1023 rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn); 1024 rport_ids.port_id = ndlp->nlp_DID; 1025 rport_ids.roles = FC_RPORT_ROLE_UNKNOWN; 1026 if (ndlp->nlp_type & NLP_FCP_TARGET) 1027 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; 1028 if (ndlp->nlp_type & NLP_FCP_INITIATOR) 1029 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR; 1030 1031 ndlp->rport = rport = fc_remote_port_add(phba->host, 0, &rport_ids); 1032 if (!rport) { 1033 dev_printk(KERN_WARNING, &phba->pcidev->dev, 1034 "Warning: fc_remote_port_add failed\n"); 1035 return; 1036 } 1037 1038 /* initialize static port data */ 1039 rport->maxframe_size = ndlp->nlp_maxframe; 1040 rport->supported_classes = ndlp->nlp_class_sup; 1041 if ((rport->scsi_target_id != -1) && 1042 (rport->scsi_target_id < MAX_FCP_TARGET)) { 1043 ndlp->nlp_sid = rport->scsi_target_id; 1044 } 1045 rdata = rport->dd_data; 1046 rdata->pnode = ndlp; 1047 1048 return; 1049 } 1050 1051 int 1052 lpfc_nlp_list(struct lpfc_hba * phba, struct lpfc_nodelist * nlp, int list) 1053 { 1054 enum { none, unmapped, mapped } rport_add = none, rport_del = none; 1055 struct lpfc_sli *psli; 1056 1057 psli = &phba->sli; 1058 /* Sanity check to ensure we are not moving to / from the same list */ 1059 if ((nlp->nlp_flag & NLP_LIST_MASK) == list) { 1060 if (list != NLP_NO_LIST) 1061 return(0); 1062 } 1063 1064 switch(nlp->nlp_flag & NLP_LIST_MASK) { 1065 case NLP_NO_LIST: /* Not on any list */ 1066 break; 1067 case NLP_UNUSED_LIST: 1068 phba->fc_unused_cnt--; 1069 list_del(&nlp->nlp_listp); 1070 break; 1071 case NLP_PLOGI_LIST: 1072 phba->fc_plogi_cnt--; 1073 list_del(&nlp->nlp_listp); 1074 break; 1075 case NLP_ADISC_LIST: 1076 phba->fc_adisc_cnt--; 1077 list_del(&nlp->nlp_listp); 1078 break; 1079 case NLP_REGLOGIN_LIST: 1080 phba->fc_reglogin_cnt--; 1081 list_del(&nlp->nlp_listp); 1082 break; 1083 case NLP_PRLI_LIST: 1084 phba->fc_prli_cnt--; 1085 list_del(&nlp->nlp_listp); 1086 break; 1087 case NLP_UNMAPPED_LIST: 1088 phba->fc_unmap_cnt--; 1089 list_del(&nlp->nlp_listp); 1090 spin_lock_irq(phba->host->host_lock); 1091 nlp->nlp_flag &= ~NLP_TGT_NO_SCSIID; 1092 nlp->nlp_type &= ~NLP_FC_NODE; 1093 spin_unlock_irq(phba->host->host_lock); 1094 phba->nport_event_cnt++; 1095 if (nlp->rport) 1096 rport_del = unmapped; 1097 break; 1098 case NLP_MAPPED_LIST: 1099 phba->fc_map_cnt--; 1100 list_del(&nlp->nlp_listp); 1101 phba->nport_event_cnt++; 1102 if (nlp->rport) 1103 rport_del = mapped; 1104 break; 1105 case NLP_NPR_LIST: 1106 phba->fc_npr_cnt--; 1107 list_del(&nlp->nlp_listp); 1108 /* Stop delay tmo if taking node off NPR list */ 1109 if ((nlp->nlp_flag & NLP_DELAY_TMO) && 1110 (list != NLP_NPR_LIST)) { 1111 spin_lock_irq(phba->host->host_lock); 1112 nlp->nlp_flag &= ~NLP_DELAY_TMO; 1113 spin_unlock_irq(phba->host->host_lock); 1114 del_timer_sync(&nlp->nlp_delayfunc); 1115 if (!list_empty(&nlp->els_retry_evt.evt_listp)) 1116 list_del_init(&nlp->els_retry_evt.evt_listp); 1117 } 1118 break; 1119 } 1120 1121 spin_lock_irq(phba->host->host_lock); 1122 nlp->nlp_flag &= ~NLP_LIST_MASK; 1123 spin_unlock_irq(phba->host->host_lock); 1124 1125 /* Add NPort <did> to <num> list */ 1126 lpfc_printf_log(phba, 1127 KERN_INFO, 1128 LOG_NODE, 1129 "%d:0904 Add NPort x%x to %d list Data: x%x\n", 1130 phba->brd_no, 1131 nlp->nlp_DID, list, nlp->nlp_flag); 1132 1133 switch(list) { 1134 case NLP_NO_LIST: /* No list, just remove it */ 1135 lpfc_nlp_remove(phba, nlp); 1136 /* as node removed - stop further transport calls */ 1137 rport_del = none; 1138 break; 1139 case NLP_UNUSED_LIST: 1140 spin_lock_irq(phba->host->host_lock); 1141 nlp->nlp_flag |= list; 1142 spin_unlock_irq(phba->host->host_lock); 1143 /* Put it at the end of the unused list */ 1144 list_add_tail(&nlp->nlp_listp, &phba->fc_unused_list); 1145 phba->fc_unused_cnt++; 1146 break; 1147 case NLP_PLOGI_LIST: 1148 spin_lock_irq(phba->host->host_lock); 1149 nlp->nlp_flag |= list; 1150 spin_unlock_irq(phba->host->host_lock); 1151 /* Put it at the end of the plogi list */ 1152 list_add_tail(&nlp->nlp_listp, &phba->fc_plogi_list); 1153 phba->fc_plogi_cnt++; 1154 break; 1155 case NLP_ADISC_LIST: 1156 spin_lock_irq(phba->host->host_lock); 1157 nlp->nlp_flag |= list; 1158 spin_unlock_irq(phba->host->host_lock); 1159 /* Put it at the end of the adisc list */ 1160 list_add_tail(&nlp->nlp_listp, &phba->fc_adisc_list); 1161 phba->fc_adisc_cnt++; 1162 break; 1163 case NLP_REGLOGIN_LIST: 1164 spin_lock_irq(phba->host->host_lock); 1165 nlp->nlp_flag |= list; 1166 spin_unlock_irq(phba->host->host_lock); 1167 /* Put it at the end of the reglogin list */ 1168 list_add_tail(&nlp->nlp_listp, &phba->fc_reglogin_list); 1169 phba->fc_reglogin_cnt++; 1170 break; 1171 case NLP_PRLI_LIST: 1172 spin_lock_irq(phba->host->host_lock); 1173 nlp->nlp_flag |= list; 1174 spin_unlock_irq(phba->host->host_lock); 1175 /* Put it at the end of the prli list */ 1176 list_add_tail(&nlp->nlp_listp, &phba->fc_prli_list); 1177 phba->fc_prli_cnt++; 1178 break; 1179 case NLP_UNMAPPED_LIST: 1180 rport_add = unmapped; 1181 /* ensure all vestiges of "mapped" significance are gone */ 1182 nlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR); 1183 spin_lock_irq(phba->host->host_lock); 1184 nlp->nlp_flag |= list; 1185 spin_unlock_irq(phba->host->host_lock); 1186 /* Put it at the end of the unmap list */ 1187 list_add_tail(&nlp->nlp_listp, &phba->fc_nlpunmap_list); 1188 phba->fc_unmap_cnt++; 1189 phba->nport_event_cnt++; 1190 /* stop nodev tmo if running */ 1191 if (nlp->nlp_flag & NLP_NODEV_TMO) { 1192 spin_lock_irq(phba->host->host_lock); 1193 nlp->nlp_flag &= ~NLP_NODEV_TMO; 1194 spin_unlock_irq(phba->host->host_lock); 1195 del_timer_sync(&nlp->nlp_tmofunc); 1196 if (!list_empty(&nlp->nodev_timeout_evt.evt_listp)) 1197 list_del_init(&nlp->nodev_timeout_evt. 1198 evt_listp); 1199 1200 } 1201 nlp->nlp_type |= NLP_FC_NODE; 1202 break; 1203 case NLP_MAPPED_LIST: 1204 rport_add = mapped; 1205 spin_lock_irq(phba->host->host_lock); 1206 nlp->nlp_flag |= list; 1207 spin_unlock_irq(phba->host->host_lock); 1208 /* Put it at the end of the map list */ 1209 list_add_tail(&nlp->nlp_listp, &phba->fc_nlpmap_list); 1210 phba->fc_map_cnt++; 1211 phba->nport_event_cnt++; 1212 /* stop nodev tmo if running */ 1213 if (nlp->nlp_flag & NLP_NODEV_TMO) { 1214 nlp->nlp_flag &= ~NLP_NODEV_TMO; 1215 del_timer_sync(&nlp->nlp_tmofunc); 1216 if (!list_empty(&nlp->nodev_timeout_evt.evt_listp)) 1217 list_del_init(&nlp->nodev_timeout_evt. 1218 evt_listp); 1219 1220 } 1221 break; 1222 case NLP_NPR_LIST: 1223 spin_lock_irq(phba->host->host_lock); 1224 nlp->nlp_flag |= list; 1225 spin_unlock_irq(phba->host->host_lock); 1226 /* Put it at the end of the npr list */ 1227 list_add_tail(&nlp->nlp_listp, &phba->fc_npr_list); 1228 phba->fc_npr_cnt++; 1229 1230 /* 1231 * Sanity check for Fabric entity. 1232 * Set nodev_tmo for NPR state, for Fabric use 1 sec. 1233 */ 1234 if (nlp->nlp_type & NLP_FABRIC) { 1235 mod_timer(&nlp->nlp_tmofunc, jiffies + HZ); 1236 } 1237 else { 1238 mod_timer(&nlp->nlp_tmofunc, 1239 jiffies + HZ * phba->cfg_nodev_tmo); 1240 } 1241 spin_lock_irq(phba->host->host_lock); 1242 nlp->nlp_flag |= NLP_NODEV_TMO; 1243 nlp->nlp_flag &= ~NLP_RCV_PLOGI; 1244 spin_unlock_irq(phba->host->host_lock); 1245 break; 1246 case NLP_JUST_DQ: 1247 break; 1248 } 1249 1250 /* 1251 * We make all the calls into the transport after we have 1252 * moved the node between lists. This so that we don't 1253 * release the lock while in-between lists. 1254 */ 1255 1256 /* Don't upcall midlayer if we're unloading */ 1257 if (!(phba->fc_flag & FC_UNLOADING)) { 1258 /* 1259 * We revalidate the rport pointer as the "add" function 1260 * may have removed the remote port. 1261 */ 1262 if ((rport_del != none) && nlp->rport) 1263 fc_remote_port_block(nlp->rport); 1264 1265 if (rport_add != none) { 1266 /* 1267 * Tell the fc transport about the port, if we haven't 1268 * already. If we have, and it's a scsi entity, be 1269 * sure to unblock any attached scsi devices 1270 */ 1271 if (!nlp->rport) 1272 lpfc_register_remote_port(phba, nlp); 1273 else 1274 fc_remote_port_unblock(nlp->rport); 1275 1276 /* 1277 * if we added to Mapped list, but the remote port 1278 * registration failed or assigned a target id outside 1279 * our presentable range - move the node to the 1280 * Unmapped List 1281 */ 1282 if ((rport_add == mapped) && 1283 ((!nlp->rport) || 1284 (nlp->rport->scsi_target_id == -1) || 1285 (nlp->rport->scsi_target_id >= MAX_FCP_TARGET))) { 1286 nlp->nlp_state = NLP_STE_UNMAPPED_NODE; 1287 spin_lock_irq(phba->host->host_lock); 1288 nlp->nlp_flag |= NLP_TGT_NO_SCSIID; 1289 spin_unlock_irq(phba->host->host_lock); 1290 lpfc_nlp_list(phba, nlp, NLP_UNMAPPED_LIST); 1291 } 1292 } 1293 } 1294 return (0); 1295 } 1296 1297 /* 1298 * Start / ReStart rescue timer for Discovery / RSCN handling 1299 */ 1300 void 1301 lpfc_set_disctmo(struct lpfc_hba * phba) 1302 { 1303 uint32_t tmo; 1304 1305 tmo = ((phba->fc_ratov * 2) + 1); 1306 1307 mod_timer(&phba->fc_disctmo, jiffies + HZ * tmo); 1308 spin_lock_irq(phba->host->host_lock); 1309 phba->fc_flag |= FC_DISC_TMO; 1310 spin_unlock_irq(phba->host->host_lock); 1311 1312 /* Start Discovery Timer state <hba_state> */ 1313 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1314 "%d:0247 Start Discovery Timer state x%x " 1315 "Data: x%x x%lx x%x x%x\n", 1316 phba->brd_no, 1317 phba->hba_state, tmo, (unsigned long)&phba->fc_disctmo, 1318 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1319 1320 return; 1321 } 1322 1323 /* 1324 * Cancel rescue timer for Discovery / RSCN handling 1325 */ 1326 int 1327 lpfc_can_disctmo(struct lpfc_hba * phba) 1328 { 1329 /* Turn off discovery timer if its running */ 1330 if (phba->fc_flag & FC_DISC_TMO) { 1331 spin_lock_irq(phba->host->host_lock); 1332 phba->fc_flag &= ~FC_DISC_TMO; 1333 spin_unlock_irq(phba->host->host_lock); 1334 del_timer_sync(&phba->fc_disctmo); 1335 phba->work_hba_events &= ~WORKER_DISC_TMO; 1336 } 1337 1338 /* Cancel Discovery Timer state <hba_state> */ 1339 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1340 "%d:0248 Cancel Discovery Timer state x%x " 1341 "Data: x%x x%x x%x\n", 1342 phba->brd_no, phba->hba_state, phba->fc_flag, 1343 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1344 1345 return (0); 1346 } 1347 1348 /* 1349 * Check specified ring for outstanding IOCB on the SLI queue 1350 * Return true if iocb matches the specified nport 1351 */ 1352 int 1353 lpfc_check_sli_ndlp(struct lpfc_hba * phba, 1354 struct lpfc_sli_ring * pring, 1355 struct lpfc_iocbq * iocb, struct lpfc_nodelist * ndlp) 1356 { 1357 struct lpfc_sli *psli; 1358 IOCB_t *icmd; 1359 1360 psli = &phba->sli; 1361 icmd = &iocb->iocb; 1362 if (pring->ringno == LPFC_ELS_RING) { 1363 switch (icmd->ulpCommand) { 1364 case CMD_GEN_REQUEST64_CR: 1365 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) 1366 return (1); 1367 case CMD_ELS_REQUEST64_CR: 1368 case CMD_XMIT_ELS_RSP64_CX: 1369 if (iocb->context1 == (uint8_t *) ndlp) 1370 return (1); 1371 } 1372 } else if (pring->ringno == psli->ip_ring) { 1373 1374 } else if (pring->ringno == psli->fcp_ring) { 1375 /* Skip match check if waiting to relogin to FCP target */ 1376 if ((ndlp->nlp_type & NLP_FCP_TARGET) && 1377 (ndlp->nlp_flag & NLP_DELAY_TMO)) { 1378 return (0); 1379 } 1380 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) { 1381 return (1); 1382 } 1383 } else if (pring->ringno == psli->next_ring) { 1384 1385 } 1386 return (0); 1387 } 1388 1389 /* 1390 * Free resources / clean up outstanding I/Os 1391 * associated with nlp_rpi in the LPFC_NODELIST entry. 1392 */ 1393 static int 1394 lpfc_no_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1395 { 1396 struct lpfc_sli *psli; 1397 struct lpfc_sli_ring *pring; 1398 struct lpfc_iocbq *iocb, *next_iocb; 1399 IOCB_t *icmd; 1400 uint32_t rpi, i; 1401 1402 /* 1403 * Everything that matches on txcmplq will be returned 1404 * by firmware with a no rpi error. 1405 */ 1406 psli = &phba->sli; 1407 rpi = ndlp->nlp_rpi; 1408 if (rpi) { 1409 /* Now process each ring */ 1410 for (i = 0; i < psli->num_rings; i++) { 1411 pring = &psli->ring[i]; 1412 1413 spin_lock_irq(phba->host->host_lock); 1414 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, 1415 list) { 1416 /* 1417 * Check to see if iocb matches the nport we are 1418 * looking for 1419 */ 1420 if ((lpfc_check_sli_ndlp 1421 (phba, pring, iocb, ndlp))) { 1422 /* It matches, so deque and call compl 1423 with an error */ 1424 list_del(&iocb->list); 1425 pring->txq_cnt--; 1426 if (iocb->iocb_cmpl) { 1427 icmd = &iocb->iocb; 1428 icmd->ulpStatus = 1429 IOSTAT_LOCAL_REJECT; 1430 icmd->un.ulpWord[4] = 1431 IOERR_SLI_ABORTED; 1432 spin_unlock_irq(phba->host-> 1433 host_lock); 1434 (iocb->iocb_cmpl) (phba, 1435 iocb, iocb); 1436 spin_lock_irq(phba->host-> 1437 host_lock); 1438 } else { 1439 list_add_tail(&iocb->list, 1440 &phba->lpfc_iocb_list); 1441 } 1442 } 1443 } 1444 spin_unlock_irq(phba->host->host_lock); 1445 1446 } 1447 } 1448 return (0); 1449 } 1450 1451 /* 1452 * Free rpi associated with LPFC_NODELIST entry. 1453 * This routine is called from lpfc_freenode(), when we are removing 1454 * a LPFC_NODELIST entry. It is also called if the driver initiates a 1455 * LOGO that completes successfully, and we are waiting to PLOGI back 1456 * to the remote NPort. In addition, it is called after we receive 1457 * and unsolicated ELS cmd, send back a rsp, the rsp completes and 1458 * we are waiting to PLOGI back to the remote NPort. 1459 */ 1460 int 1461 lpfc_unreg_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1462 { 1463 LPFC_MBOXQ_t *mbox; 1464 int rc; 1465 1466 if (ndlp->nlp_rpi) { 1467 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 1468 lpfc_unreg_login(phba, ndlp->nlp_rpi, mbox); 1469 mbox->mbox_cmpl=lpfc_sli_def_mbox_cmpl; 1470 rc = lpfc_sli_issue_mbox 1471 (phba, mbox, (MBX_NOWAIT | MBX_STOP_IOCB)); 1472 if (rc == MBX_NOT_FINISHED) 1473 mempool_free( mbox, phba->mbox_mem_pool); 1474 } 1475 lpfc_findnode_remove_rpi(phba, ndlp->nlp_rpi); 1476 lpfc_no_rpi(phba, ndlp); 1477 ndlp->nlp_rpi = 0; 1478 return 1; 1479 } 1480 return 0; 1481 } 1482 1483 /* 1484 * Free resources associated with LPFC_NODELIST entry 1485 * so it can be freed. 1486 */ 1487 static int 1488 lpfc_freenode(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1489 { 1490 LPFC_MBOXQ_t *mb; 1491 LPFC_MBOXQ_t *nextmb; 1492 struct lpfc_dmabuf *mp; 1493 struct fc_rport *rport; 1494 1495 /* Cleanup node for NPort <nlp_DID> */ 1496 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1497 "%d:0900 Cleanup node for NPort x%x " 1498 "Data: x%x x%x x%x\n", 1499 phba->brd_no, ndlp->nlp_DID, ndlp->nlp_flag, 1500 ndlp->nlp_state, ndlp->nlp_rpi); 1501 1502 lpfc_nlp_list(phba, ndlp, NLP_JUST_DQ); 1503 1504 /* 1505 * if unloading the driver - just leave the remote port in place. 1506 * The driver unload will force the attached devices to detach 1507 * and flush cache's w/o generating flush errors. 1508 */ 1509 if ((ndlp->rport) && !(phba->fc_flag & FC_UNLOADING)) { 1510 rport = ndlp->rport; 1511 ndlp->rport = NULL; 1512 fc_remote_port_unblock(rport); 1513 fc_remote_port_delete(rport); 1514 ndlp->nlp_sid = NLP_NO_SID; 1515 } 1516 1517 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */ 1518 if ((mb = phba->sli.mbox_active)) { 1519 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 1520 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1521 mb->context2 = NULL; 1522 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 1523 } 1524 } 1525 list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) { 1526 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 1527 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 1528 mp = (struct lpfc_dmabuf *) (mb->context1); 1529 if (mp) { 1530 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1531 kfree(mp); 1532 } 1533 list_del(&mb->list); 1534 mempool_free(mb, phba->mbox_mem_pool); 1535 } 1536 } 1537 1538 lpfc_els_abort(phba,ndlp,0); 1539 spin_lock_irq(phba->host->host_lock); 1540 ndlp->nlp_flag &= ~(NLP_NODEV_TMO|NLP_DELAY_TMO); 1541 spin_unlock_irq(phba->host->host_lock); 1542 del_timer_sync(&ndlp->nlp_tmofunc); 1543 1544 del_timer_sync(&ndlp->nlp_delayfunc); 1545 1546 if (!list_empty(&ndlp->nodev_timeout_evt.evt_listp)) 1547 list_del_init(&ndlp->nodev_timeout_evt.evt_listp); 1548 if (!list_empty(&ndlp->els_retry_evt.evt_listp)) 1549 list_del_init(&ndlp->els_retry_evt.evt_listp); 1550 1551 lpfc_unreg_rpi(phba, ndlp); 1552 1553 return (0); 1554 } 1555 1556 /* 1557 * Check to see if we can free the nlp back to the freelist. 1558 * If we are in the middle of using the nlp in the discovery state 1559 * machine, defer the free till we reach the end of the state machine. 1560 */ 1561 int 1562 lpfc_nlp_remove(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 1563 { 1564 if (ndlp->nlp_flag & NLP_NODEV_TMO) { 1565 spin_lock_irq(phba->host->host_lock); 1566 ndlp->nlp_flag &= ~NLP_NODEV_TMO; 1567 spin_unlock_irq(phba->host->host_lock); 1568 del_timer_sync(&ndlp->nlp_tmofunc); 1569 if (!list_empty(&ndlp->nodev_timeout_evt.evt_listp)) 1570 list_del_init(&ndlp->nodev_timeout_evt.evt_listp); 1571 1572 } 1573 1574 1575 if (ndlp->nlp_flag & NLP_DELAY_TMO) { 1576 spin_lock_irq(phba->host->host_lock); 1577 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 1578 spin_unlock_irq(phba->host->host_lock); 1579 del_timer_sync(&ndlp->nlp_delayfunc); 1580 if (!list_empty(&ndlp->els_retry_evt.evt_listp)) 1581 list_del_init(&ndlp->els_retry_evt.evt_listp); 1582 } 1583 1584 if (ndlp->nlp_disc_refcnt) { 1585 spin_lock_irq(phba->host->host_lock); 1586 ndlp->nlp_flag |= NLP_DELAY_REMOVE; 1587 spin_unlock_irq(phba->host->host_lock); 1588 } 1589 else { 1590 lpfc_freenode(phba, ndlp); 1591 mempool_free( ndlp, phba->nlp_mem_pool); 1592 } 1593 return(0); 1594 } 1595 1596 static int 1597 lpfc_matchdid(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, uint32_t did) 1598 { 1599 D_ID mydid; 1600 D_ID ndlpdid; 1601 D_ID matchdid; 1602 1603 if (did == Bcast_DID) 1604 return (0); 1605 1606 if (ndlp->nlp_DID == 0) { 1607 return (0); 1608 } 1609 1610 /* First check for Direct match */ 1611 if (ndlp->nlp_DID == did) 1612 return (1); 1613 1614 /* Next check for area/domain identically equals 0 match */ 1615 mydid.un.word = phba->fc_myDID; 1616 if ((mydid.un.b.domain == 0) && (mydid.un.b.area == 0)) { 1617 return (0); 1618 } 1619 1620 matchdid.un.word = did; 1621 ndlpdid.un.word = ndlp->nlp_DID; 1622 if (matchdid.un.b.id == ndlpdid.un.b.id) { 1623 if ((mydid.un.b.domain == matchdid.un.b.domain) && 1624 (mydid.un.b.area == matchdid.un.b.area)) { 1625 if ((ndlpdid.un.b.domain == 0) && 1626 (ndlpdid.un.b.area == 0)) { 1627 if (ndlpdid.un.b.id) 1628 return (1); 1629 } 1630 return (0); 1631 } 1632 1633 matchdid.un.word = ndlp->nlp_DID; 1634 if ((mydid.un.b.domain == ndlpdid.un.b.domain) && 1635 (mydid.un.b.area == ndlpdid.un.b.area)) { 1636 if ((matchdid.un.b.domain == 0) && 1637 (matchdid.un.b.area == 0)) { 1638 if (matchdid.un.b.id) 1639 return (1); 1640 } 1641 } 1642 } 1643 return (0); 1644 } 1645 1646 /* Search for a nodelist entry on a specific list */ 1647 struct lpfc_nodelist * 1648 lpfc_findnode_did(struct lpfc_hba * phba, uint32_t order, uint32_t did) 1649 { 1650 struct lpfc_nodelist *ndlp, *next_ndlp; 1651 uint32_t data1; 1652 1653 if (order & NLP_SEARCH_UNMAPPED) { 1654 list_for_each_entry_safe(ndlp, next_ndlp, 1655 &phba->fc_nlpunmap_list, nlp_listp) { 1656 if (lpfc_matchdid(phba, ndlp, did)) { 1657 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1658 ((uint32_t) ndlp->nlp_xri << 16) | 1659 ((uint32_t) ndlp->nlp_type << 8) | 1660 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1661 /* FIND node DID unmapped */ 1662 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1663 "%d:0929 FIND node DID unmapped" 1664 " Data: x%p x%x x%x x%x\n", 1665 phba->brd_no, 1666 ndlp, ndlp->nlp_DID, 1667 ndlp->nlp_flag, data1); 1668 return (ndlp); 1669 } 1670 } 1671 } 1672 1673 if (order & NLP_SEARCH_MAPPED) { 1674 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nlpmap_list, 1675 nlp_listp) { 1676 if (lpfc_matchdid(phba, ndlp, did)) { 1677 1678 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1679 ((uint32_t) ndlp->nlp_xri << 16) | 1680 ((uint32_t) ndlp->nlp_type << 8) | 1681 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1682 /* FIND node DID mapped */ 1683 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1684 "%d:0930 FIND node DID mapped " 1685 "Data: x%p x%x x%x x%x\n", 1686 phba->brd_no, 1687 ndlp, ndlp->nlp_DID, 1688 ndlp->nlp_flag, data1); 1689 return (ndlp); 1690 } 1691 } 1692 } 1693 1694 if (order & NLP_SEARCH_PLOGI) { 1695 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list, 1696 nlp_listp) { 1697 if (lpfc_matchdid(phba, ndlp, did)) { 1698 1699 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1700 ((uint32_t) ndlp->nlp_xri << 16) | 1701 ((uint32_t) ndlp->nlp_type << 8) | 1702 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1703 /* LOG change to PLOGI */ 1704 /* FIND node DID plogi */ 1705 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1706 "%d:0908 FIND node DID plogi " 1707 "Data: x%p x%x x%x x%x\n", 1708 phba->brd_no, 1709 ndlp, ndlp->nlp_DID, 1710 ndlp->nlp_flag, data1); 1711 return (ndlp); 1712 } 1713 } 1714 } 1715 1716 if (order & NLP_SEARCH_ADISC) { 1717 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 1718 nlp_listp) { 1719 if (lpfc_matchdid(phba, ndlp, did)) { 1720 1721 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1722 ((uint32_t) ndlp->nlp_xri << 16) | 1723 ((uint32_t) ndlp->nlp_type << 8) | 1724 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1725 /* LOG change to ADISC */ 1726 /* FIND node DID adisc */ 1727 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1728 "%d:0931 FIND node DID adisc " 1729 "Data: x%p x%x x%x x%x\n", 1730 phba->brd_no, 1731 ndlp, ndlp->nlp_DID, 1732 ndlp->nlp_flag, data1); 1733 return (ndlp); 1734 } 1735 } 1736 } 1737 1738 if (order & NLP_SEARCH_REGLOGIN) { 1739 list_for_each_entry_safe(ndlp, next_ndlp, 1740 &phba->fc_reglogin_list, nlp_listp) { 1741 if (lpfc_matchdid(phba, ndlp, did)) { 1742 1743 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1744 ((uint32_t) ndlp->nlp_xri << 16) | 1745 ((uint32_t) ndlp->nlp_type << 8) | 1746 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1747 /* LOG change to REGLOGIN */ 1748 /* FIND node DID reglogin */ 1749 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1750 "%d:0931 FIND node DID reglogin" 1751 " Data: x%p x%x x%x x%x\n", 1752 phba->brd_no, 1753 ndlp, ndlp->nlp_DID, 1754 ndlp->nlp_flag, data1); 1755 return (ndlp); 1756 } 1757 } 1758 } 1759 1760 if (order & NLP_SEARCH_PRLI) { 1761 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_prli_list, 1762 nlp_listp) { 1763 if (lpfc_matchdid(phba, ndlp, did)) { 1764 1765 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1766 ((uint32_t) ndlp->nlp_xri << 16) | 1767 ((uint32_t) ndlp->nlp_type << 8) | 1768 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1769 /* LOG change to PRLI */ 1770 /* FIND node DID prli */ 1771 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1772 "%d:0931 FIND node DID prli " 1773 "Data: x%p x%x x%x x%x\n", 1774 phba->brd_no, 1775 ndlp, ndlp->nlp_DID, 1776 ndlp->nlp_flag, data1); 1777 return (ndlp); 1778 } 1779 } 1780 } 1781 1782 if (order & NLP_SEARCH_NPR) { 1783 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 1784 nlp_listp) { 1785 if (lpfc_matchdid(phba, ndlp, did)) { 1786 1787 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1788 ((uint32_t) ndlp->nlp_xri << 16) | 1789 ((uint32_t) ndlp->nlp_type << 8) | 1790 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1791 /* LOG change to NPR */ 1792 /* FIND node DID npr */ 1793 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1794 "%d:0931 FIND node DID npr " 1795 "Data: x%p x%x x%x x%x\n", 1796 phba->brd_no, 1797 ndlp, ndlp->nlp_DID, 1798 ndlp->nlp_flag, data1); 1799 return (ndlp); 1800 } 1801 } 1802 } 1803 1804 if (order & NLP_SEARCH_UNUSED) { 1805 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 1806 nlp_listp) { 1807 if (lpfc_matchdid(phba, ndlp, did)) { 1808 1809 data1 = (((uint32_t) ndlp->nlp_state << 24) | 1810 ((uint32_t) ndlp->nlp_xri << 16) | 1811 ((uint32_t) ndlp->nlp_type << 8) | 1812 ((uint32_t) ndlp->nlp_rpi & 0xff)); 1813 /* LOG change to UNUSED */ 1814 /* FIND node DID unused */ 1815 lpfc_printf_log(phba, KERN_INFO, LOG_NODE, 1816 "%d:0931 FIND node DID unused " 1817 "Data: x%p x%x x%x x%x\n", 1818 phba->brd_no, 1819 ndlp, ndlp->nlp_DID, 1820 ndlp->nlp_flag, data1); 1821 return (ndlp); 1822 } 1823 } 1824 } 1825 1826 /* FIND node did <did> NOT FOUND */ 1827 lpfc_printf_log(phba, 1828 KERN_INFO, 1829 LOG_NODE, 1830 "%d:0932 FIND node did x%x NOT FOUND Data: x%x\n", 1831 phba->brd_no, did, order); 1832 1833 /* no match found */ 1834 return NULL; 1835 } 1836 1837 struct lpfc_nodelist * 1838 lpfc_setup_disc_node(struct lpfc_hba * phba, uint32_t did) 1839 { 1840 struct lpfc_nodelist *ndlp; 1841 uint32_t flg; 1842 1843 if ((ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, did)) == 0) { 1844 if ((phba->hba_state == LPFC_HBA_READY) && 1845 ((lpfc_rscn_payload_check(phba, did) == 0))) 1846 return NULL; 1847 ndlp = (struct lpfc_nodelist *) 1848 mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 1849 if (!ndlp) 1850 return NULL; 1851 lpfc_nlp_init(phba, ndlp, did); 1852 ndlp->nlp_state = NLP_STE_NPR_NODE; 1853 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1854 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1855 return ndlp; 1856 } 1857 if ((phba->hba_state == LPFC_HBA_READY) && 1858 (phba->fc_flag & FC_RSCN_MODE)) { 1859 if (lpfc_rscn_payload_check(phba, did)) { 1860 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1861 } 1862 else { 1863 ndlp->nlp_flag &= ~NLP_NPR_2B_DISC; 1864 ndlp = NULL; 1865 } 1866 } 1867 else { 1868 flg = ndlp->nlp_flag & NLP_LIST_MASK; 1869 if ((flg == NLP_ADISC_LIST) || 1870 (flg == NLP_PLOGI_LIST)) { 1871 return NULL; 1872 } 1873 ndlp->nlp_state = NLP_STE_NPR_NODE; 1874 lpfc_nlp_list(phba, ndlp, NLP_NPR_LIST); 1875 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 1876 } 1877 return ndlp; 1878 } 1879 1880 /* Build a list of nodes to discover based on the loopmap */ 1881 void 1882 lpfc_disc_list_loopmap(struct lpfc_hba * phba) 1883 { 1884 int j; 1885 uint32_t alpa, index; 1886 1887 if (phba->hba_state <= LPFC_LINK_DOWN) { 1888 return; 1889 } 1890 if (phba->fc_topology != TOPOLOGY_LOOP) { 1891 return; 1892 } 1893 1894 /* Check for loop map present or not */ 1895 if (phba->alpa_map[0]) { 1896 for (j = 1; j <= phba->alpa_map[0]; j++) { 1897 alpa = phba->alpa_map[j]; 1898 1899 if (((phba->fc_myDID & 0xff) == alpa) || (alpa == 0)) { 1900 continue; 1901 } 1902 lpfc_setup_disc_node(phba, alpa); 1903 } 1904 } else { 1905 /* No alpamap, so try all alpa's */ 1906 for (j = 0; j < FC_MAXLOOP; j++) { 1907 /* If cfg_scan_down is set, start from highest 1908 * ALPA (0xef) to lowest (0x1). 1909 */ 1910 if (phba->cfg_scan_down) 1911 index = j; 1912 else 1913 index = FC_MAXLOOP - j - 1; 1914 alpa = lpfcAlpaArray[index]; 1915 if ((phba->fc_myDID & 0xff) == alpa) { 1916 continue; 1917 } 1918 1919 lpfc_setup_disc_node(phba, alpa); 1920 } 1921 } 1922 return; 1923 } 1924 1925 /* Start Link up / RSCN discovery on NPR list */ 1926 void 1927 lpfc_disc_start(struct lpfc_hba * phba) 1928 { 1929 struct lpfc_sli *psli; 1930 LPFC_MBOXQ_t *mbox; 1931 struct lpfc_nodelist *ndlp, *next_ndlp; 1932 uint32_t did_changed, num_sent; 1933 uint32_t clear_la_pending; 1934 int rc; 1935 1936 psli = &phba->sli; 1937 1938 if (phba->hba_state <= LPFC_LINK_DOWN) { 1939 return; 1940 } 1941 if (phba->hba_state == LPFC_CLEAR_LA) 1942 clear_la_pending = 1; 1943 else 1944 clear_la_pending = 0; 1945 1946 if (phba->hba_state < LPFC_HBA_READY) { 1947 phba->hba_state = LPFC_DISC_AUTH; 1948 } 1949 lpfc_set_disctmo(phba); 1950 1951 if (phba->fc_prevDID == phba->fc_myDID) { 1952 did_changed = 0; 1953 } else { 1954 did_changed = 1; 1955 } 1956 phba->fc_prevDID = phba->fc_myDID; 1957 phba->num_disc_nodes = 0; 1958 1959 /* Start Discovery state <hba_state> */ 1960 lpfc_printf_log(phba, KERN_INFO, LOG_DISCOVERY, 1961 "%d:0202 Start Discovery hba state x%x " 1962 "Data: x%x x%x x%x\n", 1963 phba->brd_no, phba->hba_state, phba->fc_flag, 1964 phba->fc_plogi_cnt, phba->fc_adisc_cnt); 1965 1966 /* If our did changed, we MUST do PLOGI */ 1967 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_npr_list, 1968 nlp_listp) { 1969 if (ndlp->nlp_flag & NLP_NPR_2B_DISC) { 1970 if (did_changed) { 1971 spin_lock_irq(phba->host->host_lock); 1972 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 1973 spin_unlock_irq(phba->host->host_lock); 1974 } 1975 } 1976 } 1977 1978 /* First do ADISCs - if any */ 1979 num_sent = lpfc_els_disc_adisc(phba); 1980 1981 if (num_sent) 1982 return; 1983 1984 if ((phba->hba_state < LPFC_HBA_READY) && (!clear_la_pending)) { 1985 /* If we get here, there is nothing to ADISC */ 1986 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL))) { 1987 phba->hba_state = LPFC_CLEAR_LA; 1988 lpfc_clear_la(phba, mbox); 1989 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 1990 rc = lpfc_sli_issue_mbox(phba, mbox, 1991 (MBX_NOWAIT | MBX_STOP_IOCB)); 1992 if (rc == MBX_NOT_FINISHED) { 1993 mempool_free( mbox, phba->mbox_mem_pool); 1994 lpfc_disc_flush_list(phba); 1995 psli->ring[(psli->ip_ring)].flag &= 1996 ~LPFC_STOP_IOCB_EVENT; 1997 psli->ring[(psli->fcp_ring)].flag &= 1998 ~LPFC_STOP_IOCB_EVENT; 1999 psli->ring[(psli->next_ring)].flag &= 2000 ~LPFC_STOP_IOCB_EVENT; 2001 phba->hba_state = LPFC_HBA_READY; 2002 } 2003 } 2004 } else { 2005 /* Next do PLOGIs - if any */ 2006 num_sent = lpfc_els_disc_plogi(phba); 2007 2008 if (num_sent) 2009 return; 2010 2011 if (phba->fc_flag & FC_RSCN_MODE) { 2012 /* Check to see if more RSCNs came in while we 2013 * were processing this one. 2014 */ 2015 if ((phba->fc_rscn_id_cnt == 0) && 2016 (!(phba->fc_flag & FC_RSCN_DISCOVERY))) { 2017 spin_lock_irq(phba->host->host_lock); 2018 phba->fc_flag &= ~FC_RSCN_MODE; 2019 spin_unlock_irq(phba->host->host_lock); 2020 } 2021 else 2022 lpfc_els_handle_rscn(phba); 2023 } 2024 } 2025 return; 2026 } 2027 2028 /* 2029 * Ignore completion for all IOCBs on tx and txcmpl queue for ELS 2030 * ring the match the sppecified nodelist. 2031 */ 2032 static void 2033 lpfc_free_tx(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp) 2034 { 2035 struct lpfc_sli *psli; 2036 IOCB_t *icmd; 2037 struct lpfc_iocbq *iocb, *next_iocb; 2038 struct lpfc_sli_ring *pring; 2039 struct lpfc_dmabuf *mp; 2040 2041 psli = &phba->sli; 2042 pring = &psli->ring[LPFC_ELS_RING]; 2043 2044 /* Error matching iocb on txq or txcmplq 2045 * First check the txq. 2046 */ 2047 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) { 2048 if (iocb->context1 != ndlp) { 2049 continue; 2050 } 2051 icmd = &iocb->iocb; 2052 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) || 2053 (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) { 2054 2055 list_del(&iocb->list); 2056 pring->txq_cnt--; 2057 lpfc_els_free_iocb(phba, iocb); 2058 } 2059 } 2060 2061 /* Next check the txcmplq */ 2062 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) { 2063 if (iocb->context1 != ndlp) { 2064 continue; 2065 } 2066 icmd = &iocb->iocb; 2067 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) || 2068 (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) { 2069 2070 iocb->iocb_cmpl = NULL; 2071 /* context2 = cmd, context2->next = rsp, context3 = 2072 bpl */ 2073 if (iocb->context2) { 2074 /* Free the response IOCB before handling the 2075 command. */ 2076 2077 mp = (struct lpfc_dmabuf *) (iocb->context2); 2078 mp = list_get_first(&mp->list, 2079 struct lpfc_dmabuf, 2080 list); 2081 if (mp) { 2082 /* Delay before releasing rsp buffer to 2083 * give UNREG mbox a chance to take 2084 * effect. 2085 */ 2086 list_add(&mp->list, 2087 &phba->freebufList); 2088 } 2089 lpfc_mbuf_free(phba, 2090 ((struct lpfc_dmabuf *) 2091 iocb->context2)->virt, 2092 ((struct lpfc_dmabuf *) 2093 iocb->context2)->phys); 2094 kfree(iocb->context2); 2095 } 2096 2097 if (iocb->context3) { 2098 lpfc_mbuf_free(phba, 2099 ((struct lpfc_dmabuf *) 2100 iocb->context3)->virt, 2101 ((struct lpfc_dmabuf *) 2102 iocb->context3)->phys); 2103 kfree(iocb->context3); 2104 } 2105 } 2106 } 2107 2108 return; 2109 } 2110 2111 void 2112 lpfc_disc_flush_list(struct lpfc_hba * phba) 2113 { 2114 struct lpfc_nodelist *ndlp, *next_ndlp; 2115 2116 if (phba->fc_plogi_cnt) { 2117 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_plogi_list, 2118 nlp_listp) { 2119 lpfc_free_tx(phba, ndlp); 2120 lpfc_nlp_remove(phba, ndlp); 2121 } 2122 } 2123 if (phba->fc_adisc_cnt) { 2124 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_adisc_list, 2125 nlp_listp) { 2126 lpfc_free_tx(phba, ndlp); 2127 lpfc_nlp_remove(phba, ndlp); 2128 } 2129 } 2130 return; 2131 } 2132 2133 /*****************************************************************************/ 2134 /* 2135 * NAME: lpfc_disc_timeout 2136 * 2137 * FUNCTION: Fibre Channel driver discovery timeout routine. 2138 * 2139 * EXECUTION ENVIRONMENT: interrupt only 2140 * 2141 * CALLED FROM: 2142 * Timer function 2143 * 2144 * RETURNS: 2145 * none 2146 */ 2147 /*****************************************************************************/ 2148 void 2149 lpfc_disc_timeout(unsigned long ptr) 2150 { 2151 struct lpfc_hba *phba = (struct lpfc_hba *)ptr; 2152 unsigned long flags = 0; 2153 2154 if (unlikely(!phba)) 2155 return; 2156 2157 spin_lock_irqsave(phba->host->host_lock, flags); 2158 if (!(phba->work_hba_events & WORKER_DISC_TMO)) { 2159 phba->work_hba_events |= WORKER_DISC_TMO; 2160 if (phba->work_wait) 2161 wake_up(phba->work_wait); 2162 } 2163 spin_unlock_irqrestore(phba->host->host_lock, flags); 2164 return; 2165 } 2166 2167 static void 2168 lpfc_disc_timeout_handler(struct lpfc_hba *phba) 2169 { 2170 struct lpfc_sli *psli; 2171 struct lpfc_nodelist *ndlp; 2172 LPFC_MBOXQ_t *clearlambox, *initlinkmbox; 2173 int rc, clrlaerr = 0; 2174 2175 if (unlikely(!phba)) 2176 return; 2177 2178 if (!(phba->fc_flag & FC_DISC_TMO)) 2179 return; 2180 2181 psli = &phba->sli; 2182 2183 spin_lock_irq(phba->host->host_lock); 2184 phba->fc_flag &= ~FC_DISC_TMO; 2185 spin_unlock_irq(phba->host->host_lock); 2186 2187 switch (phba->hba_state) { 2188 2189 case LPFC_LOCAL_CFG_LINK: 2190 /* hba_state is identically LPFC_LOCAL_CFG_LINK while waiting for FAN */ 2191 /* FAN timeout */ 2192 lpfc_printf_log(phba, 2193 KERN_WARNING, 2194 LOG_DISCOVERY, 2195 "%d:0221 FAN timeout\n", 2196 phba->brd_no); 2197 2198 /* Forget about FAN, Start discovery by sending a FLOGI 2199 * hba_state is identically LPFC_FLOGI while waiting for FLOGI 2200 * cmpl 2201 */ 2202 phba->hba_state = LPFC_FLOGI; 2203 lpfc_set_disctmo(phba); 2204 lpfc_initial_flogi(phba); 2205 break; 2206 2207 case LPFC_FLOGI: 2208 /* hba_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */ 2209 /* Initial FLOGI timeout */ 2210 lpfc_printf_log(phba, 2211 KERN_ERR, 2212 LOG_DISCOVERY, 2213 "%d:0222 Initial FLOGI timeout\n", 2214 phba->brd_no); 2215 2216 /* Assume no Fabric and go on with discovery. 2217 * Check for outstanding ELS FLOGI to abort. 2218 */ 2219 2220 /* FLOGI failed, so just use loop map to make discovery list */ 2221 lpfc_disc_list_loopmap(phba); 2222 2223 /* Start discovery */ 2224 lpfc_disc_start(phba); 2225 break; 2226 2227 case LPFC_FABRIC_CFG_LINK: 2228 /* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for 2229 NameServer login */ 2230 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2231 "%d:0223 Timeout while waiting for NameServer " 2232 "login\n", phba->brd_no); 2233 2234 /* Next look for NameServer ndlp */ 2235 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_ALL, NameServer_DID); 2236 if (ndlp) 2237 lpfc_nlp_remove(phba, ndlp); 2238 /* Start discovery */ 2239 lpfc_disc_start(phba); 2240 break; 2241 2242 case LPFC_NS_QRY: 2243 /* Check for wait for NameServer Rsp timeout */ 2244 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2245 "%d:0224 NameServer Query timeout " 2246 "Data: x%x x%x\n", 2247 phba->brd_no, 2248 phba->fc_ns_retry, LPFC_MAX_NS_RETRY); 2249 2250 ndlp = lpfc_findnode_did(phba, NLP_SEARCH_UNMAPPED, 2251 NameServer_DID); 2252 if (ndlp) { 2253 if (phba->fc_ns_retry < LPFC_MAX_NS_RETRY) { 2254 /* Try it one more time */ 2255 rc = lpfc_ns_cmd(phba, ndlp, SLI_CTNS_GID_FT); 2256 if (rc == 0) 2257 break; 2258 } 2259 phba->fc_ns_retry = 0; 2260 } 2261 2262 /* Nothing to authenticate, so CLEAR_LA right now */ 2263 clearlambox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2264 if (!clearlambox) { 2265 clrlaerr = 1; 2266 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2267 "%d:0226 Device Discovery " 2268 "completion error\n", 2269 phba->brd_no); 2270 phba->hba_state = LPFC_HBA_ERROR; 2271 break; 2272 } 2273 2274 phba->hba_state = LPFC_CLEAR_LA; 2275 lpfc_clear_la(phba, clearlambox); 2276 clearlambox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 2277 rc = lpfc_sli_issue_mbox(phba, clearlambox, 2278 (MBX_NOWAIT | MBX_STOP_IOCB)); 2279 if (rc == MBX_NOT_FINISHED) { 2280 mempool_free(clearlambox, phba->mbox_mem_pool); 2281 clrlaerr = 1; 2282 break; 2283 } 2284 2285 /* Setup and issue mailbox INITIALIZE LINK command */ 2286 initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2287 if (!initlinkmbox) { 2288 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2289 "%d:0226 Device Discovery " 2290 "completion error\n", 2291 phba->brd_no); 2292 phba->hba_state = LPFC_HBA_ERROR; 2293 break; 2294 } 2295 2296 lpfc_linkdown(phba); 2297 lpfc_init_link(phba, initlinkmbox, phba->cfg_topology, 2298 phba->cfg_link_speed); 2299 initlinkmbox->mb.un.varInitLnk.lipsr_AL_PA = 0; 2300 rc = lpfc_sli_issue_mbox(phba, initlinkmbox, 2301 (MBX_NOWAIT | MBX_STOP_IOCB)); 2302 if (rc == MBX_NOT_FINISHED) 2303 mempool_free(initlinkmbox, phba->mbox_mem_pool); 2304 2305 break; 2306 2307 case LPFC_DISC_AUTH: 2308 /* Node Authentication timeout */ 2309 lpfc_printf_log(phba, 2310 KERN_ERR, 2311 LOG_DISCOVERY, 2312 "%d:0227 Node Authentication timeout\n", 2313 phba->brd_no); 2314 lpfc_disc_flush_list(phba); 2315 clearlambox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2316 if (!clearlambox) { 2317 clrlaerr = 1; 2318 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY, 2319 "%d:0226 Device Discovery " 2320 "completion error\n", 2321 phba->brd_no); 2322 phba->hba_state = LPFC_HBA_ERROR; 2323 break; 2324 } 2325 phba->hba_state = LPFC_CLEAR_LA; 2326 lpfc_clear_la(phba, clearlambox); 2327 clearlambox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 2328 rc = lpfc_sli_issue_mbox(phba, clearlambox, 2329 (MBX_NOWAIT | MBX_STOP_IOCB)); 2330 if (rc == MBX_NOT_FINISHED) { 2331 mempool_free(clearlambox, phba->mbox_mem_pool); 2332 clrlaerr = 1; 2333 } 2334 break; 2335 2336 case LPFC_CLEAR_LA: 2337 /* CLEAR LA timeout */ 2338 lpfc_printf_log(phba, 2339 KERN_ERR, 2340 LOG_DISCOVERY, 2341 "%d:0228 CLEAR LA timeout\n", 2342 phba->brd_no); 2343 clrlaerr = 1; 2344 break; 2345 2346 case LPFC_HBA_READY: 2347 if (phba->fc_flag & FC_RSCN_MODE) { 2348 lpfc_printf_log(phba, 2349 KERN_ERR, 2350 LOG_DISCOVERY, 2351 "%d:0231 RSCN timeout Data: x%x x%x\n", 2352 phba->brd_no, 2353 phba->fc_ns_retry, LPFC_MAX_NS_RETRY); 2354 2355 /* Cleanup any outstanding ELS commands */ 2356 lpfc_els_flush_cmd(phba); 2357 2358 lpfc_els_flush_rscn(phba); 2359 lpfc_disc_flush_list(phba); 2360 } 2361 break; 2362 } 2363 2364 if (clrlaerr) { 2365 lpfc_disc_flush_list(phba); 2366 psli->ring[(psli->ip_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2367 psli->ring[(psli->fcp_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2368 psli->ring[(psli->next_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 2369 phba->hba_state = LPFC_HBA_READY; 2370 } 2371 2372 return; 2373 } 2374 2375 static void 2376 lpfc_nodev_timeout(unsigned long ptr) 2377 { 2378 struct lpfc_hba *phba; 2379 struct lpfc_nodelist *ndlp; 2380 unsigned long iflag; 2381 struct lpfc_work_evt *evtp; 2382 2383 ndlp = (struct lpfc_nodelist *)ptr; 2384 phba = ndlp->nlp_phba; 2385 evtp = &ndlp->nodev_timeout_evt; 2386 spin_lock_irqsave(phba->host->host_lock, iflag); 2387 2388 if (!list_empty(&evtp->evt_listp)) { 2389 spin_unlock_irqrestore(phba->host->host_lock, iflag); 2390 return; 2391 } 2392 evtp->evt_arg1 = ndlp; 2393 evtp->evt = LPFC_EVT_NODEV_TMO; 2394 list_add_tail(&evtp->evt_listp, &phba->work_list); 2395 if (phba->work_wait) 2396 wake_up(phba->work_wait); 2397 2398 spin_unlock_irqrestore(phba->host->host_lock, iflag); 2399 return; 2400 } 2401 2402 2403 /* 2404 * This routine handles processing a NameServer REG_LOGIN mailbox 2405 * command upon completion. It is setup in the LPFC_MBOXQ 2406 * as the completion routine when the command is 2407 * handed off to the SLI layer. 2408 */ 2409 void 2410 lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmb) 2411 { 2412 struct lpfc_sli *psli; 2413 MAILBOX_t *mb; 2414 struct lpfc_dmabuf *mp; 2415 struct lpfc_nodelist *ndlp; 2416 2417 psli = &phba->sli; 2418 mb = &pmb->mb; 2419 2420 ndlp = (struct lpfc_nodelist *) pmb->context2; 2421 mp = (struct lpfc_dmabuf *) (pmb->context1); 2422 2423 pmb->context1 = NULL; 2424 2425 if (ndlp->nlp_rpi != 0) 2426 lpfc_findnode_remove_rpi(phba, ndlp->nlp_rpi); 2427 ndlp->nlp_rpi = mb->un.varWords[0]; 2428 lpfc_addnode_rpi(phba, ndlp, ndlp->nlp_rpi); 2429 ndlp->nlp_type |= NLP_FABRIC; 2430 ndlp->nlp_state = NLP_STE_UNMAPPED_NODE; 2431 lpfc_nlp_list(phba, ndlp, NLP_UNMAPPED_LIST); 2432 2433 /* Start issuing Fabric-Device Management Interface (FDMI) 2434 * command to 0xfffffa (FDMI well known port) 2435 */ 2436 if (phba->cfg_fdmi_on == 1) { 2437 lpfc_fdmi_cmd(phba, ndlp, SLI_MGMT_DHBA); 2438 } else { 2439 /* 2440 * Delay issuing FDMI command if fdmi-on=2 2441 * (supporting RPA/hostnmae) 2442 */ 2443 mod_timer(&phba->fc_fdmitmo, jiffies + HZ * 60); 2444 } 2445 2446 lpfc_mbuf_free(phba, mp->virt, mp->phys); 2447 kfree(mp); 2448 mempool_free( pmb, phba->mbox_mem_pool); 2449 2450 return; 2451 } 2452 2453 /* 2454 * This routine looks up the ndlp hash 2455 * table for the given RPI. If rpi found 2456 * it return the node list pointer 2457 * else return 0. 2458 */ 2459 struct lpfc_nodelist * 2460 lpfc_findnode_rpi(struct lpfc_hba * phba, uint16_t rpi) 2461 { 2462 struct lpfc_nodelist *ret; 2463 2464 ret = phba->fc_nlplookup[LPFC_RPI_HASH_FUNC(rpi)]; 2465 while ((ret != 0) && (ret->nlp_rpi != rpi)) { 2466 ret = ret->nlp_rpi_hash_next; 2467 } 2468 return ret; 2469 } 2470 2471 /* 2472 * This routine looks up the ndlp hash table for the 2473 * given RPI. If rpi found it return the node list 2474 * pointer else return 0 after deleting the entry 2475 * from hash table. 2476 */ 2477 struct lpfc_nodelist * 2478 lpfc_findnode_remove_rpi(struct lpfc_hba * phba, uint16_t rpi) 2479 { 2480 struct lpfc_nodelist *ret, *temp;; 2481 2482 ret = phba->fc_nlplookup[LPFC_RPI_HASH_FUNC(rpi)]; 2483 if (ret == 0) 2484 return NULL; 2485 2486 if (ret->nlp_rpi == rpi) { 2487 phba->fc_nlplookup[LPFC_RPI_HASH_FUNC(rpi)] = 2488 ret->nlp_rpi_hash_next; 2489 ret->nlp_rpi_hash_next = NULL; 2490 return ret; 2491 } 2492 2493 while ((ret->nlp_rpi_hash_next != 0) && 2494 (ret->nlp_rpi_hash_next->nlp_rpi != rpi)) { 2495 ret = ret->nlp_rpi_hash_next; 2496 } 2497 2498 if (ret->nlp_rpi_hash_next != 0) { 2499 temp = ret->nlp_rpi_hash_next; 2500 ret->nlp_rpi_hash_next = temp->nlp_rpi_hash_next; 2501 temp->nlp_rpi_hash_next = NULL; 2502 return temp; 2503 } else { 2504 return NULL; 2505 } 2506 } 2507 2508 /* 2509 * This routine adds the node list entry to the 2510 * ndlp hash table. 2511 */ 2512 void 2513 lpfc_addnode_rpi(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 2514 uint16_t rpi) 2515 { 2516 2517 uint32_t index; 2518 2519 index = LPFC_RPI_HASH_FUNC(rpi); 2520 ndlp->nlp_rpi_hash_next = phba->fc_nlplookup[index]; 2521 phba->fc_nlplookup[index] = ndlp; 2522 return; 2523 } 2524 2525 void 2526 lpfc_nlp_init(struct lpfc_hba * phba, struct lpfc_nodelist * ndlp, 2527 uint32_t did) 2528 { 2529 memset(ndlp, 0, sizeof (struct lpfc_nodelist)); 2530 INIT_LIST_HEAD(&ndlp->nodev_timeout_evt.evt_listp); 2531 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp); 2532 init_timer(&ndlp->nlp_tmofunc); 2533 ndlp->nlp_tmofunc.function = lpfc_nodev_timeout; 2534 ndlp->nlp_tmofunc.data = (unsigned long)ndlp; 2535 init_timer(&ndlp->nlp_delayfunc); 2536 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay; 2537 ndlp->nlp_delayfunc.data = (unsigned long)ndlp; 2538 ndlp->nlp_DID = did; 2539 ndlp->nlp_phba = phba; 2540 ndlp->nlp_sid = NLP_NO_SID; 2541 return; 2542 } 2543