1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2011 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/delay.h> 24 #include <linux/dma-mapping.h> 25 #include <linux/idr.h> 26 #include <linux/interrupt.h> 27 #include <linux/module.h> 28 #include <linux/kthread.h> 29 #include <linux/pci.h> 30 #include <linux/spinlock.h> 31 #include <linux/ctype.h> 32 #include <linux/aer.h> 33 #include <linux/slab.h> 34 #include <linux/firmware.h> 35 36 #include <scsi/scsi.h> 37 #include <scsi/scsi_device.h> 38 #include <scsi/scsi_host.h> 39 #include <scsi/scsi_transport_fc.h> 40 41 #include "lpfc_hw4.h" 42 #include "lpfc_hw.h" 43 #include "lpfc_sli.h" 44 #include "lpfc_sli4.h" 45 #include "lpfc_nl.h" 46 #include "lpfc_disc.h" 47 #include "lpfc_scsi.h" 48 #include "lpfc.h" 49 #include "lpfc_logmsg.h" 50 #include "lpfc_crtn.h" 51 #include "lpfc_vport.h" 52 #include "lpfc_version.h" 53 54 char *_dump_buf_data; 55 unsigned long _dump_buf_data_order; 56 char *_dump_buf_dif; 57 unsigned long _dump_buf_dif_order; 58 spinlock_t _dump_buf_lock; 59 60 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *); 61 static int lpfc_post_rcv_buf(struct lpfc_hba *); 62 static int lpfc_sli4_queue_verify(struct lpfc_hba *); 63 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *); 64 static int lpfc_setup_endian_order(struct lpfc_hba *); 65 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *); 66 static void lpfc_free_sgl_list(struct lpfc_hba *); 67 static int lpfc_init_sgl_list(struct lpfc_hba *); 68 static int lpfc_init_active_sgl_array(struct lpfc_hba *); 69 static void lpfc_free_active_sgl(struct lpfc_hba *); 70 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba); 71 static int lpfc_hba_down_post_s4(struct lpfc_hba *phba); 72 static int lpfc_sli4_cq_event_pool_create(struct lpfc_hba *); 73 static void lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *); 74 static void lpfc_sli4_cq_event_release_all(struct lpfc_hba *); 75 76 static struct scsi_transport_template *lpfc_transport_template = NULL; 77 static struct scsi_transport_template *lpfc_vport_transport_template = NULL; 78 static DEFINE_IDR(lpfc_hba_index); 79 80 /** 81 * lpfc_config_port_prep - Perform lpfc initialization prior to config port 82 * @phba: pointer to lpfc hba data structure. 83 * 84 * This routine will do LPFC initialization prior to issuing the CONFIG_PORT 85 * mailbox command. It retrieves the revision information from the HBA and 86 * collects the Vital Product Data (VPD) about the HBA for preparing the 87 * configuration of the HBA. 88 * 89 * Return codes: 90 * 0 - success. 91 * -ERESTART - requests the SLI layer to reset the HBA and try again. 92 * Any other value - indicates an error. 93 **/ 94 int 95 lpfc_config_port_prep(struct lpfc_hba *phba) 96 { 97 lpfc_vpd_t *vp = &phba->vpd; 98 int i = 0, rc; 99 LPFC_MBOXQ_t *pmb; 100 MAILBOX_t *mb; 101 char *lpfc_vpd_data = NULL; 102 uint16_t offset = 0; 103 static char licensed[56] = 104 "key unlock for use with gnu public licensed code only\0"; 105 static int init_key = 1; 106 107 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 108 if (!pmb) { 109 phba->link_state = LPFC_HBA_ERROR; 110 return -ENOMEM; 111 } 112 113 mb = &pmb->u.mb; 114 phba->link_state = LPFC_INIT_MBX_CMDS; 115 116 if (lpfc_is_LC_HBA(phba->pcidev->device)) { 117 if (init_key) { 118 uint32_t *ptext = (uint32_t *) licensed; 119 120 for (i = 0; i < 56; i += sizeof (uint32_t), ptext++) 121 *ptext = cpu_to_be32(*ptext); 122 init_key = 0; 123 } 124 125 lpfc_read_nv(phba, pmb); 126 memset((char*)mb->un.varRDnvp.rsvd3, 0, 127 sizeof (mb->un.varRDnvp.rsvd3)); 128 memcpy((char*)mb->un.varRDnvp.rsvd3, licensed, 129 sizeof (licensed)); 130 131 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 132 133 if (rc != MBX_SUCCESS) { 134 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 135 "0324 Config Port initialization " 136 "error, mbxCmd x%x READ_NVPARM, " 137 "mbxStatus x%x\n", 138 mb->mbxCommand, mb->mbxStatus); 139 mempool_free(pmb, phba->mbox_mem_pool); 140 return -ERESTART; 141 } 142 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename, 143 sizeof(phba->wwnn)); 144 memcpy(phba->wwpn, (char *)mb->un.varRDnvp.portname, 145 sizeof(phba->wwpn)); 146 } 147 148 phba->sli3_options = 0x0; 149 150 /* Setup and issue mailbox READ REV command */ 151 lpfc_read_rev(phba, pmb); 152 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 153 if (rc != MBX_SUCCESS) { 154 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 155 "0439 Adapter failed to init, mbxCmd x%x " 156 "READ_REV, mbxStatus x%x\n", 157 mb->mbxCommand, mb->mbxStatus); 158 mempool_free( pmb, phba->mbox_mem_pool); 159 return -ERESTART; 160 } 161 162 163 /* 164 * The value of rr must be 1 since the driver set the cv field to 1. 165 * This setting requires the FW to set all revision fields. 166 */ 167 if (mb->un.varRdRev.rr == 0) { 168 vp->rev.rBit = 0; 169 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 170 "0440 Adapter failed to init, READ_REV has " 171 "missing revision information.\n"); 172 mempool_free(pmb, phba->mbox_mem_pool); 173 return -ERESTART; 174 } 175 176 if (phba->sli_rev == 3 && !mb->un.varRdRev.v3rsp) { 177 mempool_free(pmb, phba->mbox_mem_pool); 178 return -EINVAL; 179 } 180 181 /* Save information as VPD data */ 182 vp->rev.rBit = 1; 183 memcpy(&vp->sli3Feat, &mb->un.varRdRev.sli3Feat, sizeof(uint32_t)); 184 vp->rev.sli1FwRev = mb->un.varRdRev.sli1FwRev; 185 memcpy(vp->rev.sli1FwName, (char*) mb->un.varRdRev.sli1FwName, 16); 186 vp->rev.sli2FwRev = mb->un.varRdRev.sli2FwRev; 187 memcpy(vp->rev.sli2FwName, (char *) mb->un.varRdRev.sli2FwName, 16); 188 vp->rev.biuRev = mb->un.varRdRev.biuRev; 189 vp->rev.smRev = mb->un.varRdRev.smRev; 190 vp->rev.smFwRev = mb->un.varRdRev.un.smFwRev; 191 vp->rev.endecRev = mb->un.varRdRev.endecRev; 192 vp->rev.fcphHigh = mb->un.varRdRev.fcphHigh; 193 vp->rev.fcphLow = mb->un.varRdRev.fcphLow; 194 vp->rev.feaLevelHigh = mb->un.varRdRev.feaLevelHigh; 195 vp->rev.feaLevelLow = mb->un.varRdRev.feaLevelLow; 196 vp->rev.postKernRev = mb->un.varRdRev.postKernRev; 197 vp->rev.opFwRev = mb->un.varRdRev.opFwRev; 198 199 /* If the sli feature level is less then 9, we must 200 * tear down all RPIs and VPIs on link down if NPIV 201 * is enabled. 202 */ 203 if (vp->rev.feaLevelHigh < 9) 204 phba->sli3_options |= LPFC_SLI3_VPORT_TEARDOWN; 205 206 if (lpfc_is_LC_HBA(phba->pcidev->device)) 207 memcpy(phba->RandomData, (char *)&mb->un.varWords[24], 208 sizeof (phba->RandomData)); 209 210 /* Get adapter VPD information */ 211 lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL); 212 if (!lpfc_vpd_data) 213 goto out_free_mbox; 214 do { 215 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD); 216 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 217 218 if (rc != MBX_SUCCESS) { 219 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 220 "0441 VPD not present on adapter, " 221 "mbxCmd x%x DUMP VPD, mbxStatus x%x\n", 222 mb->mbxCommand, mb->mbxStatus); 223 mb->un.varDmp.word_cnt = 0; 224 } 225 /* dump mem may return a zero when finished or we got a 226 * mailbox error, either way we are done. 227 */ 228 if (mb->un.varDmp.word_cnt == 0) 229 break; 230 if (mb->un.varDmp.word_cnt > DMP_VPD_SIZE - offset) 231 mb->un.varDmp.word_cnt = DMP_VPD_SIZE - offset; 232 lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET, 233 lpfc_vpd_data + offset, 234 mb->un.varDmp.word_cnt); 235 offset += mb->un.varDmp.word_cnt; 236 } while (mb->un.varDmp.word_cnt && offset < DMP_VPD_SIZE); 237 lpfc_parse_vpd(phba, lpfc_vpd_data, offset); 238 239 kfree(lpfc_vpd_data); 240 out_free_mbox: 241 mempool_free(pmb, phba->mbox_mem_pool); 242 return 0; 243 } 244 245 /** 246 * lpfc_config_async_cmpl - Completion handler for config async event mbox cmd 247 * @phba: pointer to lpfc hba data structure. 248 * @pmboxq: pointer to the driver internal queue element for mailbox command. 249 * 250 * This is the completion handler for driver's configuring asynchronous event 251 * mailbox command to the device. If the mailbox command returns successfully, 252 * it will set internal async event support flag to 1; otherwise, it will 253 * set internal async event support flag to 0. 254 **/ 255 static void 256 lpfc_config_async_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq) 257 { 258 if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS) 259 phba->temp_sensor_support = 1; 260 else 261 phba->temp_sensor_support = 0; 262 mempool_free(pmboxq, phba->mbox_mem_pool); 263 return; 264 } 265 266 /** 267 * lpfc_dump_wakeup_param_cmpl - dump memory mailbox command completion handler 268 * @phba: pointer to lpfc hba data structure. 269 * @pmboxq: pointer to the driver internal queue element for mailbox command. 270 * 271 * This is the completion handler for dump mailbox command for getting 272 * wake up parameters. When this command complete, the response contain 273 * Option rom version of the HBA. This function translate the version number 274 * into a human readable string and store it in OptionROMVersion. 275 **/ 276 static void 277 lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq) 278 { 279 struct prog_id *prg; 280 uint32_t prog_id_word; 281 char dist = ' '; 282 /* character array used for decoding dist type. */ 283 char dist_char[] = "nabx"; 284 285 if (pmboxq->u.mb.mbxStatus != MBX_SUCCESS) { 286 mempool_free(pmboxq, phba->mbox_mem_pool); 287 return; 288 } 289 290 prg = (struct prog_id *) &prog_id_word; 291 292 /* word 7 contain option rom version */ 293 prog_id_word = pmboxq->u.mb.un.varWords[7]; 294 295 /* Decode the Option rom version word to a readable string */ 296 if (prg->dist < 4) 297 dist = dist_char[prg->dist]; 298 299 if ((prg->dist == 3) && (prg->num == 0)) 300 sprintf(phba->OptionROMVersion, "%d.%d%d", 301 prg->ver, prg->rev, prg->lev); 302 else 303 sprintf(phba->OptionROMVersion, "%d.%d%d%c%d", 304 prg->ver, prg->rev, prg->lev, 305 dist, prg->num); 306 mempool_free(pmboxq, phba->mbox_mem_pool); 307 return; 308 } 309 310 /** 311 * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname, 312 * cfg_soft_wwnn, cfg_soft_wwpn 313 * @vport: pointer to lpfc vport data structure. 314 * 315 * 316 * Return codes 317 * None. 318 **/ 319 void 320 lpfc_update_vport_wwn(struct lpfc_vport *vport) 321 { 322 /* If the soft name exists then update it using the service params */ 323 if (vport->phba->cfg_soft_wwnn) 324 u64_to_wwn(vport->phba->cfg_soft_wwnn, 325 vport->fc_sparam.nodeName.u.wwn); 326 if (vport->phba->cfg_soft_wwpn) 327 u64_to_wwn(vport->phba->cfg_soft_wwpn, 328 vport->fc_sparam.portName.u.wwn); 329 330 /* 331 * If the name is empty or there exists a soft name 332 * then copy the service params name, otherwise use the fc name 333 */ 334 if (vport->fc_nodename.u.wwn[0] == 0 || vport->phba->cfg_soft_wwnn) 335 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName, 336 sizeof(struct lpfc_name)); 337 else 338 memcpy(&vport->fc_sparam.nodeName, &vport->fc_nodename, 339 sizeof(struct lpfc_name)); 340 341 if (vport->fc_portname.u.wwn[0] == 0 || vport->phba->cfg_soft_wwpn) 342 memcpy(&vport->fc_portname, &vport->fc_sparam.portName, 343 sizeof(struct lpfc_name)); 344 else 345 memcpy(&vport->fc_sparam.portName, &vport->fc_portname, 346 sizeof(struct lpfc_name)); 347 } 348 349 /** 350 * lpfc_config_port_post - Perform lpfc initialization after config port 351 * @phba: pointer to lpfc hba data structure. 352 * 353 * This routine will do LPFC initialization after the CONFIG_PORT mailbox 354 * command call. It performs all internal resource and state setups on the 355 * port: post IOCB buffers, enable appropriate host interrupt attentions, 356 * ELS ring timers, etc. 357 * 358 * Return codes 359 * 0 - success. 360 * Any other value - error. 361 **/ 362 int 363 lpfc_config_port_post(struct lpfc_hba *phba) 364 { 365 struct lpfc_vport *vport = phba->pport; 366 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 367 LPFC_MBOXQ_t *pmb; 368 MAILBOX_t *mb; 369 struct lpfc_dmabuf *mp; 370 struct lpfc_sli *psli = &phba->sli; 371 uint32_t status, timeout; 372 int i, j; 373 int rc; 374 375 spin_lock_irq(&phba->hbalock); 376 /* 377 * If the Config port completed correctly the HBA is not 378 * over heated any more. 379 */ 380 if (phba->over_temp_state == HBA_OVER_TEMP) 381 phba->over_temp_state = HBA_NORMAL_TEMP; 382 spin_unlock_irq(&phba->hbalock); 383 384 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 385 if (!pmb) { 386 phba->link_state = LPFC_HBA_ERROR; 387 return -ENOMEM; 388 } 389 mb = &pmb->u.mb; 390 391 /* Get login parameters for NID. */ 392 rc = lpfc_read_sparam(phba, pmb, 0); 393 if (rc) { 394 mempool_free(pmb, phba->mbox_mem_pool); 395 return -ENOMEM; 396 } 397 398 pmb->vport = vport; 399 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) { 400 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 401 "0448 Adapter failed init, mbxCmd x%x " 402 "READ_SPARM mbxStatus x%x\n", 403 mb->mbxCommand, mb->mbxStatus); 404 phba->link_state = LPFC_HBA_ERROR; 405 mp = (struct lpfc_dmabuf *) pmb->context1; 406 mempool_free(pmb, phba->mbox_mem_pool); 407 lpfc_mbuf_free(phba, mp->virt, mp->phys); 408 kfree(mp); 409 return -EIO; 410 } 411 412 mp = (struct lpfc_dmabuf *) pmb->context1; 413 414 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm)); 415 lpfc_mbuf_free(phba, mp->virt, mp->phys); 416 kfree(mp); 417 pmb->context1 = NULL; 418 lpfc_update_vport_wwn(vport); 419 420 /* Update the fc_host data structures with new wwn. */ 421 fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn); 422 fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn); 423 fc_host_max_npiv_vports(shost) = phba->max_vpi; 424 425 /* If no serial number in VPD data, use low 6 bytes of WWNN */ 426 /* This should be consolidated into parse_vpd ? - mr */ 427 if (phba->SerialNumber[0] == 0) { 428 uint8_t *outptr; 429 430 outptr = &vport->fc_nodename.u.s.IEEE[0]; 431 for (i = 0; i < 12; i++) { 432 status = *outptr++; 433 j = ((status & 0xf0) >> 4); 434 if (j <= 9) 435 phba->SerialNumber[i] = 436 (char)((uint8_t) 0x30 + (uint8_t) j); 437 else 438 phba->SerialNumber[i] = 439 (char)((uint8_t) 0x61 + (uint8_t) (j - 10)); 440 i++; 441 j = (status & 0xf); 442 if (j <= 9) 443 phba->SerialNumber[i] = 444 (char)((uint8_t) 0x30 + (uint8_t) j); 445 else 446 phba->SerialNumber[i] = 447 (char)((uint8_t) 0x61 + (uint8_t) (j - 10)); 448 } 449 } 450 451 lpfc_read_config(phba, pmb); 452 pmb->vport = vport; 453 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) { 454 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 455 "0453 Adapter failed to init, mbxCmd x%x " 456 "READ_CONFIG, mbxStatus x%x\n", 457 mb->mbxCommand, mb->mbxStatus); 458 phba->link_state = LPFC_HBA_ERROR; 459 mempool_free( pmb, phba->mbox_mem_pool); 460 return -EIO; 461 } 462 463 /* Check if the port is disabled */ 464 lpfc_sli_read_link_ste(phba); 465 466 /* Reset the DFT_HBA_Q_DEPTH to the max xri */ 467 if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1)) 468 phba->cfg_hba_queue_depth = 469 (mb->un.varRdConfig.max_xri + 1) - 470 lpfc_sli4_get_els_iocb_cnt(phba); 471 472 phba->lmt = mb->un.varRdConfig.lmt; 473 474 /* Get the default values for Model Name and Description */ 475 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc); 476 477 phba->link_state = LPFC_LINK_DOWN; 478 479 /* Only process IOCBs on ELS ring till hba_state is READY */ 480 if (psli->ring[psli->extra_ring].cmdringaddr) 481 psli->ring[psli->extra_ring].flag |= LPFC_STOP_IOCB_EVENT; 482 if (psli->ring[psli->fcp_ring].cmdringaddr) 483 psli->ring[psli->fcp_ring].flag |= LPFC_STOP_IOCB_EVENT; 484 if (psli->ring[psli->next_ring].cmdringaddr) 485 psli->ring[psli->next_ring].flag |= LPFC_STOP_IOCB_EVENT; 486 487 /* Post receive buffers for desired rings */ 488 if (phba->sli_rev != 3) 489 lpfc_post_rcv_buf(phba); 490 491 /* 492 * Configure HBA MSI-X attention conditions to messages if MSI-X mode 493 */ 494 if (phba->intr_type == MSIX) { 495 rc = lpfc_config_msi(phba, pmb); 496 if (rc) { 497 mempool_free(pmb, phba->mbox_mem_pool); 498 return -EIO; 499 } 500 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 501 if (rc != MBX_SUCCESS) { 502 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 503 "0352 Config MSI mailbox command " 504 "failed, mbxCmd x%x, mbxStatus x%x\n", 505 pmb->u.mb.mbxCommand, 506 pmb->u.mb.mbxStatus); 507 mempool_free(pmb, phba->mbox_mem_pool); 508 return -EIO; 509 } 510 } 511 512 spin_lock_irq(&phba->hbalock); 513 /* Initialize ERATT handling flag */ 514 phba->hba_flag &= ~HBA_ERATT_HANDLED; 515 516 /* Enable appropriate host interrupts */ 517 if (lpfc_readl(phba->HCregaddr, &status)) { 518 spin_unlock_irq(&phba->hbalock); 519 return -EIO; 520 } 521 status |= HC_MBINT_ENA | HC_ERINT_ENA | HC_LAINT_ENA; 522 if (psli->num_rings > 0) 523 status |= HC_R0INT_ENA; 524 if (psli->num_rings > 1) 525 status |= HC_R1INT_ENA; 526 if (psli->num_rings > 2) 527 status |= HC_R2INT_ENA; 528 if (psli->num_rings > 3) 529 status |= HC_R3INT_ENA; 530 531 if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) && 532 (phba->cfg_poll & DISABLE_FCP_RING_INT)) 533 status &= ~(HC_R0INT_ENA); 534 535 writel(status, phba->HCregaddr); 536 readl(phba->HCregaddr); /* flush */ 537 spin_unlock_irq(&phba->hbalock); 538 539 /* Set up ring-0 (ELS) timer */ 540 timeout = phba->fc_ratov * 2; 541 mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout); 542 /* Set up heart beat (HB) timer */ 543 mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL); 544 phba->hb_outstanding = 0; 545 phba->last_completion_time = jiffies; 546 /* Set up error attention (ERATT) polling timer */ 547 mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL); 548 549 if (phba->hba_flag & LINK_DISABLED) { 550 lpfc_printf_log(phba, 551 KERN_ERR, LOG_INIT, 552 "2598 Adapter Link is disabled.\n"); 553 lpfc_down_link(phba, pmb); 554 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 555 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 556 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) { 557 lpfc_printf_log(phba, 558 KERN_ERR, LOG_INIT, 559 "2599 Adapter failed to issue DOWN_LINK" 560 " mbox command rc 0x%x\n", rc); 561 562 mempool_free(pmb, phba->mbox_mem_pool); 563 return -EIO; 564 } 565 } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) { 566 mempool_free(pmb, phba->mbox_mem_pool); 567 rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT); 568 if (rc) 569 return rc; 570 } 571 /* MBOX buffer will be freed in mbox compl */ 572 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 573 if (!pmb) { 574 phba->link_state = LPFC_HBA_ERROR; 575 return -ENOMEM; 576 } 577 578 lpfc_config_async(phba, pmb, LPFC_ELS_RING); 579 pmb->mbox_cmpl = lpfc_config_async_cmpl; 580 pmb->vport = phba->pport; 581 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 582 583 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 584 lpfc_printf_log(phba, 585 KERN_ERR, 586 LOG_INIT, 587 "0456 Adapter failed to issue " 588 "ASYNCEVT_ENABLE mbox status x%x\n", 589 rc); 590 mempool_free(pmb, phba->mbox_mem_pool); 591 } 592 593 /* Get Option rom version */ 594 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 595 if (!pmb) { 596 phba->link_state = LPFC_HBA_ERROR; 597 return -ENOMEM; 598 } 599 600 lpfc_dump_wakeup_param(phba, pmb); 601 pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl; 602 pmb->vport = phba->pport; 603 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 604 605 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 606 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, "0435 Adapter failed " 607 "to get Option ROM version status x%x\n", rc); 608 mempool_free(pmb, phba->mbox_mem_pool); 609 } 610 611 return 0; 612 } 613 614 /** 615 * lpfc_hba_init_link - Initialize the FC link 616 * @phba: pointer to lpfc hba data structure. 617 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT 618 * 619 * This routine will issue the INIT_LINK mailbox command call. 620 * It is available to other drivers through the lpfc_hba data 621 * structure for use as a delayed link up mechanism with the 622 * module parameter lpfc_suppress_link_up. 623 * 624 * Return code 625 * 0 - success 626 * Any other value - error 627 **/ 628 int 629 lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag) 630 { 631 return lpfc_hba_init_link_fc_topology(phba, phba->cfg_topology, flag); 632 } 633 634 /** 635 * lpfc_hba_init_link_fc_topology - Initialize FC link with desired topology 636 * @phba: pointer to lpfc hba data structure. 637 * @fc_topology: desired fc topology. 638 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT 639 * 640 * This routine will issue the INIT_LINK mailbox command call. 641 * It is available to other drivers through the lpfc_hba data 642 * structure for use as a delayed link up mechanism with the 643 * module parameter lpfc_suppress_link_up. 644 * 645 * Return code 646 * 0 - success 647 * Any other value - error 648 **/ 649 int 650 lpfc_hba_init_link_fc_topology(struct lpfc_hba *phba, uint32_t fc_topology, 651 uint32_t flag) 652 { 653 struct lpfc_vport *vport = phba->pport; 654 LPFC_MBOXQ_t *pmb; 655 MAILBOX_t *mb; 656 int rc; 657 658 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 659 if (!pmb) { 660 phba->link_state = LPFC_HBA_ERROR; 661 return -ENOMEM; 662 } 663 mb = &pmb->u.mb; 664 pmb->vport = vport; 665 666 if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_MAX) || 667 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G) && 668 !(phba->lmt & LMT_1Gb)) || 669 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G) && 670 !(phba->lmt & LMT_2Gb)) || 671 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G) && 672 !(phba->lmt & LMT_4Gb)) || 673 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G) && 674 !(phba->lmt & LMT_8Gb)) || 675 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G) && 676 !(phba->lmt & LMT_10Gb)) || 677 ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G) && 678 !(phba->lmt & LMT_16Gb))) { 679 /* Reset link speed to auto */ 680 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 681 "1302 Invalid speed for this board:%d " 682 "Reset link speed to auto.\n", 683 phba->cfg_link_speed); 684 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO; 685 } 686 lpfc_init_link(phba, pmb, fc_topology, phba->cfg_link_speed); 687 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 688 if (phba->sli_rev < LPFC_SLI_REV4) 689 lpfc_set_loopback_flag(phba); 690 rc = lpfc_sli_issue_mbox(phba, pmb, flag); 691 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 692 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 693 "0498 Adapter failed to init, mbxCmd x%x " 694 "INIT_LINK, mbxStatus x%x\n", 695 mb->mbxCommand, mb->mbxStatus); 696 if (phba->sli_rev <= LPFC_SLI_REV3) { 697 /* Clear all interrupt enable conditions */ 698 writel(0, phba->HCregaddr); 699 readl(phba->HCregaddr); /* flush */ 700 /* Clear all pending interrupts */ 701 writel(0xffffffff, phba->HAregaddr); 702 readl(phba->HAregaddr); /* flush */ 703 } 704 phba->link_state = LPFC_HBA_ERROR; 705 if (rc != MBX_BUSY || flag == MBX_POLL) 706 mempool_free(pmb, phba->mbox_mem_pool); 707 return -EIO; 708 } 709 phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK; 710 if (flag == MBX_POLL) 711 mempool_free(pmb, phba->mbox_mem_pool); 712 713 return 0; 714 } 715 716 /** 717 * lpfc_hba_down_link - this routine downs the FC link 718 * @phba: pointer to lpfc hba data structure. 719 * @flag: mailbox command issue mode - either MBX_POLL or MBX_NOWAIT 720 * 721 * This routine will issue the DOWN_LINK mailbox command call. 722 * It is available to other drivers through the lpfc_hba data 723 * structure for use to stop the link. 724 * 725 * Return code 726 * 0 - success 727 * Any other value - error 728 **/ 729 int 730 lpfc_hba_down_link(struct lpfc_hba *phba, uint32_t flag) 731 { 732 LPFC_MBOXQ_t *pmb; 733 int rc; 734 735 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 736 if (!pmb) { 737 phba->link_state = LPFC_HBA_ERROR; 738 return -ENOMEM; 739 } 740 741 lpfc_printf_log(phba, 742 KERN_ERR, LOG_INIT, 743 "0491 Adapter Link is disabled.\n"); 744 lpfc_down_link(phba, pmb); 745 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 746 rc = lpfc_sli_issue_mbox(phba, pmb, flag); 747 if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) { 748 lpfc_printf_log(phba, 749 KERN_ERR, LOG_INIT, 750 "2522 Adapter failed to issue DOWN_LINK" 751 " mbox command rc 0x%x\n", rc); 752 753 mempool_free(pmb, phba->mbox_mem_pool); 754 return -EIO; 755 } 756 if (flag == MBX_POLL) 757 mempool_free(pmb, phba->mbox_mem_pool); 758 759 return 0; 760 } 761 762 /** 763 * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset 764 * @phba: pointer to lpfc HBA data structure. 765 * 766 * This routine will do LPFC uninitialization before the HBA is reset when 767 * bringing down the SLI Layer. 768 * 769 * Return codes 770 * 0 - success. 771 * Any other value - error. 772 **/ 773 int 774 lpfc_hba_down_prep(struct lpfc_hba *phba) 775 { 776 struct lpfc_vport **vports; 777 int i; 778 779 if (phba->sli_rev <= LPFC_SLI_REV3) { 780 /* Disable interrupts */ 781 writel(0, phba->HCregaddr); 782 readl(phba->HCregaddr); /* flush */ 783 } 784 785 if (phba->pport->load_flag & FC_UNLOADING) 786 lpfc_cleanup_discovery_resources(phba->pport); 787 else { 788 vports = lpfc_create_vport_work_array(phba); 789 if (vports != NULL) 790 for (i = 0; i <= phba->max_vports && 791 vports[i] != NULL; i++) 792 lpfc_cleanup_discovery_resources(vports[i]); 793 lpfc_destroy_vport_work_array(phba, vports); 794 } 795 return 0; 796 } 797 798 /** 799 * lpfc_hba_down_post_s3 - Perform lpfc uninitialization after HBA reset 800 * @phba: pointer to lpfc HBA data structure. 801 * 802 * This routine will do uninitialization after the HBA is reset when bring 803 * down the SLI Layer. 804 * 805 * Return codes 806 * 0 - success. 807 * Any other value - error. 808 **/ 809 static int 810 lpfc_hba_down_post_s3(struct lpfc_hba *phba) 811 { 812 struct lpfc_sli *psli = &phba->sli; 813 struct lpfc_sli_ring *pring; 814 struct lpfc_dmabuf *mp, *next_mp; 815 LIST_HEAD(completions); 816 int i; 817 818 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) 819 lpfc_sli_hbqbuf_free_all(phba); 820 else { 821 /* Cleanup preposted buffers on the ELS ring */ 822 pring = &psli->ring[LPFC_ELS_RING]; 823 list_for_each_entry_safe(mp, next_mp, &pring->postbufq, list) { 824 list_del(&mp->list); 825 pring->postbufq_cnt--; 826 lpfc_mbuf_free(phba, mp->virt, mp->phys); 827 kfree(mp); 828 } 829 } 830 831 spin_lock_irq(&phba->hbalock); 832 for (i = 0; i < psli->num_rings; i++) { 833 pring = &psli->ring[i]; 834 835 /* At this point in time the HBA is either reset or DOA. Either 836 * way, nothing should be on txcmplq as it will NEVER complete. 837 */ 838 list_splice_init(&pring->txcmplq, &completions); 839 pring->txcmplq_cnt = 0; 840 spin_unlock_irq(&phba->hbalock); 841 842 /* Cancel all the IOCBs from the completions list */ 843 lpfc_sli_cancel_iocbs(phba, &completions, IOSTAT_LOCAL_REJECT, 844 IOERR_SLI_ABORTED); 845 846 lpfc_sli_abort_iocb_ring(phba, pring); 847 spin_lock_irq(&phba->hbalock); 848 } 849 spin_unlock_irq(&phba->hbalock); 850 851 return 0; 852 } 853 854 /** 855 * lpfc_hba_down_post_s4 - Perform lpfc uninitialization after HBA reset 856 * @phba: pointer to lpfc HBA data structure. 857 * 858 * This routine will do uninitialization after the HBA is reset when bring 859 * down the SLI Layer. 860 * 861 * Return codes 862 * 0 - success. 863 * Any other value - error. 864 **/ 865 static int 866 lpfc_hba_down_post_s4(struct lpfc_hba *phba) 867 { 868 struct lpfc_scsi_buf *psb, *psb_next; 869 LIST_HEAD(aborts); 870 int ret; 871 unsigned long iflag = 0; 872 struct lpfc_sglq *sglq_entry = NULL; 873 874 ret = lpfc_hba_down_post_s3(phba); 875 if (ret) 876 return ret; 877 /* At this point in time the HBA is either reset or DOA. Either 878 * way, nothing should be on lpfc_abts_els_sgl_list, it needs to be 879 * on the lpfc_sgl_list so that it can either be freed if the 880 * driver is unloading or reposted if the driver is restarting 881 * the port. 882 */ 883 spin_lock_irq(&phba->hbalock); /* required for lpfc_sgl_list and */ 884 /* scsl_buf_list */ 885 /* abts_sgl_list_lock required because worker thread uses this 886 * list. 887 */ 888 spin_lock(&phba->sli4_hba.abts_sgl_list_lock); 889 list_for_each_entry(sglq_entry, 890 &phba->sli4_hba.lpfc_abts_els_sgl_list, list) 891 sglq_entry->state = SGL_FREED; 892 893 list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list, 894 &phba->sli4_hba.lpfc_sgl_list); 895 spin_unlock(&phba->sli4_hba.abts_sgl_list_lock); 896 /* abts_scsi_buf_list_lock required because worker thread uses this 897 * list. 898 */ 899 spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock); 900 list_splice_init(&phba->sli4_hba.lpfc_abts_scsi_buf_list, 901 &aborts); 902 spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock); 903 spin_unlock_irq(&phba->hbalock); 904 905 list_for_each_entry_safe(psb, psb_next, &aborts, list) { 906 psb->pCmd = NULL; 907 psb->status = IOSTAT_SUCCESS; 908 } 909 spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag); 910 list_splice(&aborts, &phba->lpfc_scsi_buf_list); 911 spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag); 912 return 0; 913 } 914 915 /** 916 * lpfc_hba_down_post - Wrapper func for hba down post routine 917 * @phba: pointer to lpfc HBA data structure. 918 * 919 * This routine wraps the actual SLI3 or SLI4 routine for performing 920 * uninitialization after the HBA is reset when bring down the SLI Layer. 921 * 922 * Return codes 923 * 0 - success. 924 * Any other value - error. 925 **/ 926 int 927 lpfc_hba_down_post(struct lpfc_hba *phba) 928 { 929 return (*phba->lpfc_hba_down_post)(phba); 930 } 931 932 /** 933 * lpfc_hb_timeout - The HBA-timer timeout handler 934 * @ptr: unsigned long holds the pointer to lpfc hba data structure. 935 * 936 * This is the HBA-timer timeout handler registered to the lpfc driver. When 937 * this timer fires, a HBA timeout event shall be posted to the lpfc driver 938 * work-port-events bitmap and the worker thread is notified. This timeout 939 * event will be used by the worker thread to invoke the actual timeout 940 * handler routine, lpfc_hb_timeout_handler. Any periodical operations will 941 * be performed in the timeout handler and the HBA timeout event bit shall 942 * be cleared by the worker thread after it has taken the event bitmap out. 943 **/ 944 static void 945 lpfc_hb_timeout(unsigned long ptr) 946 { 947 struct lpfc_hba *phba; 948 uint32_t tmo_posted; 949 unsigned long iflag; 950 951 phba = (struct lpfc_hba *)ptr; 952 953 /* Check for heart beat timeout conditions */ 954 spin_lock_irqsave(&phba->pport->work_port_lock, iflag); 955 tmo_posted = phba->pport->work_port_events & WORKER_HB_TMO; 956 if (!tmo_posted) 957 phba->pport->work_port_events |= WORKER_HB_TMO; 958 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag); 959 960 /* Tell the worker thread there is work to do */ 961 if (!tmo_posted) 962 lpfc_worker_wake_up(phba); 963 return; 964 } 965 966 /** 967 * lpfc_rrq_timeout - The RRQ-timer timeout handler 968 * @ptr: unsigned long holds the pointer to lpfc hba data structure. 969 * 970 * This is the RRQ-timer timeout handler registered to the lpfc driver. When 971 * this timer fires, a RRQ timeout event shall be posted to the lpfc driver 972 * work-port-events bitmap and the worker thread is notified. This timeout 973 * event will be used by the worker thread to invoke the actual timeout 974 * handler routine, lpfc_rrq_handler. Any periodical operations will 975 * be performed in the timeout handler and the RRQ timeout event bit shall 976 * be cleared by the worker thread after it has taken the event bitmap out. 977 **/ 978 static void 979 lpfc_rrq_timeout(unsigned long ptr) 980 { 981 struct lpfc_hba *phba; 982 unsigned long iflag; 983 984 phba = (struct lpfc_hba *)ptr; 985 spin_lock_irqsave(&phba->pport->work_port_lock, iflag); 986 phba->hba_flag |= HBA_RRQ_ACTIVE; 987 spin_unlock_irqrestore(&phba->pport->work_port_lock, iflag); 988 lpfc_worker_wake_up(phba); 989 } 990 991 /** 992 * lpfc_hb_mbox_cmpl - The lpfc heart-beat mailbox command callback function 993 * @phba: pointer to lpfc hba data structure. 994 * @pmboxq: pointer to the driver internal queue element for mailbox command. 995 * 996 * This is the callback function to the lpfc heart-beat mailbox command. 997 * If configured, the lpfc driver issues the heart-beat mailbox command to 998 * the HBA every LPFC_HB_MBOX_INTERVAL (current 5) seconds. At the time the 999 * heart-beat mailbox command is issued, the driver shall set up heart-beat 1000 * timeout timer to LPFC_HB_MBOX_TIMEOUT (current 30) seconds and marks 1001 * heart-beat outstanding state. Once the mailbox command comes back and 1002 * no error conditions detected, the heart-beat mailbox command timer is 1003 * reset to LPFC_HB_MBOX_INTERVAL seconds and the heart-beat outstanding 1004 * state is cleared for the next heart-beat. If the timer expired with the 1005 * heart-beat outstanding state set, the driver will put the HBA offline. 1006 **/ 1007 static void 1008 lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq) 1009 { 1010 unsigned long drvr_flag; 1011 1012 spin_lock_irqsave(&phba->hbalock, drvr_flag); 1013 phba->hb_outstanding = 0; 1014 spin_unlock_irqrestore(&phba->hbalock, drvr_flag); 1015 1016 /* Check and reset heart-beat timer is necessary */ 1017 mempool_free(pmboxq, phba->mbox_mem_pool); 1018 if (!(phba->pport->fc_flag & FC_OFFLINE_MODE) && 1019 !(phba->link_state == LPFC_HBA_ERROR) && 1020 !(phba->pport->load_flag & FC_UNLOADING)) 1021 mod_timer(&phba->hb_tmofunc, 1022 jiffies + HZ * LPFC_HB_MBOX_INTERVAL); 1023 return; 1024 } 1025 1026 /** 1027 * lpfc_hb_timeout_handler - The HBA-timer timeout handler 1028 * @phba: pointer to lpfc hba data structure. 1029 * 1030 * This is the actual HBA-timer timeout handler to be invoked by the worker 1031 * thread whenever the HBA timer fired and HBA-timeout event posted. This 1032 * handler performs any periodic operations needed for the device. If such 1033 * periodic event has already been attended to either in the interrupt handler 1034 * or by processing slow-ring or fast-ring events within the HBA-timer 1035 * timeout window (LPFC_HB_MBOX_INTERVAL), this handler just simply resets 1036 * the timer for the next timeout period. If lpfc heart-beat mailbox command 1037 * is configured and there is no heart-beat mailbox command outstanding, a 1038 * heart-beat mailbox is issued and timer set properly. Otherwise, if there 1039 * has been a heart-beat mailbox command outstanding, the HBA shall be put 1040 * to offline. 1041 **/ 1042 void 1043 lpfc_hb_timeout_handler(struct lpfc_hba *phba) 1044 { 1045 struct lpfc_vport **vports; 1046 LPFC_MBOXQ_t *pmboxq; 1047 struct lpfc_dmabuf *buf_ptr; 1048 int retval, i; 1049 struct lpfc_sli *psli = &phba->sli; 1050 LIST_HEAD(completions); 1051 1052 vports = lpfc_create_vport_work_array(phba); 1053 if (vports != NULL) 1054 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) 1055 lpfc_rcv_seq_check_edtov(vports[i]); 1056 lpfc_destroy_vport_work_array(phba, vports); 1057 1058 if ((phba->link_state == LPFC_HBA_ERROR) || 1059 (phba->pport->load_flag & FC_UNLOADING) || 1060 (phba->pport->fc_flag & FC_OFFLINE_MODE)) 1061 return; 1062 1063 spin_lock_irq(&phba->pport->work_port_lock); 1064 1065 if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ, 1066 jiffies)) { 1067 spin_unlock_irq(&phba->pport->work_port_lock); 1068 if (!phba->hb_outstanding) 1069 mod_timer(&phba->hb_tmofunc, 1070 jiffies + HZ * LPFC_HB_MBOX_INTERVAL); 1071 else 1072 mod_timer(&phba->hb_tmofunc, 1073 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT); 1074 return; 1075 } 1076 spin_unlock_irq(&phba->pport->work_port_lock); 1077 1078 if (phba->elsbuf_cnt && 1079 (phba->elsbuf_cnt == phba->elsbuf_prev_cnt)) { 1080 spin_lock_irq(&phba->hbalock); 1081 list_splice_init(&phba->elsbuf, &completions); 1082 phba->elsbuf_cnt = 0; 1083 phba->elsbuf_prev_cnt = 0; 1084 spin_unlock_irq(&phba->hbalock); 1085 1086 while (!list_empty(&completions)) { 1087 list_remove_head(&completions, buf_ptr, 1088 struct lpfc_dmabuf, list); 1089 lpfc_mbuf_free(phba, buf_ptr->virt, buf_ptr->phys); 1090 kfree(buf_ptr); 1091 } 1092 } 1093 phba->elsbuf_prev_cnt = phba->elsbuf_cnt; 1094 1095 /* If there is no heart beat outstanding, issue a heartbeat command */ 1096 if (phba->cfg_enable_hba_heartbeat) { 1097 if (!phba->hb_outstanding) { 1098 if ((!(psli->sli_flag & LPFC_SLI_MBOX_ACTIVE)) && 1099 (list_empty(&psli->mboxq))) { 1100 pmboxq = mempool_alloc(phba->mbox_mem_pool, 1101 GFP_KERNEL); 1102 if (!pmboxq) { 1103 mod_timer(&phba->hb_tmofunc, 1104 jiffies + 1105 HZ * LPFC_HB_MBOX_INTERVAL); 1106 return; 1107 } 1108 1109 lpfc_heart_beat(phba, pmboxq); 1110 pmboxq->mbox_cmpl = lpfc_hb_mbox_cmpl; 1111 pmboxq->vport = phba->pport; 1112 retval = lpfc_sli_issue_mbox(phba, pmboxq, 1113 MBX_NOWAIT); 1114 1115 if (retval != MBX_BUSY && 1116 retval != MBX_SUCCESS) { 1117 mempool_free(pmboxq, 1118 phba->mbox_mem_pool); 1119 mod_timer(&phba->hb_tmofunc, 1120 jiffies + 1121 HZ * LPFC_HB_MBOX_INTERVAL); 1122 return; 1123 } 1124 phba->skipped_hb = 0; 1125 phba->hb_outstanding = 1; 1126 } else if (time_before_eq(phba->last_completion_time, 1127 phba->skipped_hb)) { 1128 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 1129 "2857 Last completion time not " 1130 " updated in %d ms\n", 1131 jiffies_to_msecs(jiffies 1132 - phba->last_completion_time)); 1133 } else 1134 phba->skipped_hb = jiffies; 1135 1136 mod_timer(&phba->hb_tmofunc, 1137 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT); 1138 return; 1139 } else { 1140 /* 1141 * If heart beat timeout called with hb_outstanding set 1142 * we need to give the hb mailbox cmd a chance to 1143 * complete or TMO. 1144 */ 1145 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 1146 "0459 Adapter heartbeat still out" 1147 "standing:last compl time was %d ms.\n", 1148 jiffies_to_msecs(jiffies 1149 - phba->last_completion_time)); 1150 mod_timer(&phba->hb_tmofunc, 1151 jiffies + HZ * LPFC_HB_MBOX_TIMEOUT); 1152 } 1153 } 1154 } 1155 1156 /** 1157 * lpfc_offline_eratt - Bring lpfc offline on hardware error attention 1158 * @phba: pointer to lpfc hba data structure. 1159 * 1160 * This routine is called to bring the HBA offline when HBA hardware error 1161 * other than Port Error 6 has been detected. 1162 **/ 1163 static void 1164 lpfc_offline_eratt(struct lpfc_hba *phba) 1165 { 1166 struct lpfc_sli *psli = &phba->sli; 1167 1168 spin_lock_irq(&phba->hbalock); 1169 psli->sli_flag &= ~LPFC_SLI_ACTIVE; 1170 spin_unlock_irq(&phba->hbalock); 1171 lpfc_offline_prep(phba); 1172 1173 lpfc_offline(phba); 1174 lpfc_reset_barrier(phba); 1175 spin_lock_irq(&phba->hbalock); 1176 lpfc_sli_brdreset(phba); 1177 spin_unlock_irq(&phba->hbalock); 1178 lpfc_hba_down_post(phba); 1179 lpfc_sli_brdready(phba, HS_MBRDY); 1180 lpfc_unblock_mgmt_io(phba); 1181 phba->link_state = LPFC_HBA_ERROR; 1182 return; 1183 } 1184 1185 /** 1186 * lpfc_sli4_offline_eratt - Bring lpfc offline on SLI4 hardware error attention 1187 * @phba: pointer to lpfc hba data structure. 1188 * 1189 * This routine is called to bring a SLI4 HBA offline when HBA hardware error 1190 * other than Port Error 6 has been detected. 1191 **/ 1192 static void 1193 lpfc_sli4_offline_eratt(struct lpfc_hba *phba) 1194 { 1195 lpfc_offline_prep(phba); 1196 lpfc_offline(phba); 1197 lpfc_sli4_brdreset(phba); 1198 lpfc_hba_down_post(phba); 1199 lpfc_sli4_post_status_check(phba); 1200 lpfc_unblock_mgmt_io(phba); 1201 phba->link_state = LPFC_HBA_ERROR; 1202 } 1203 1204 /** 1205 * lpfc_handle_deferred_eratt - The HBA hardware deferred error handler 1206 * @phba: pointer to lpfc hba data structure. 1207 * 1208 * This routine is invoked to handle the deferred HBA hardware error 1209 * conditions. This type of error is indicated by HBA by setting ER1 1210 * and another ER bit in the host status register. The driver will 1211 * wait until the ER1 bit clears before handling the error condition. 1212 **/ 1213 static void 1214 lpfc_handle_deferred_eratt(struct lpfc_hba *phba) 1215 { 1216 uint32_t old_host_status = phba->work_hs; 1217 struct lpfc_sli_ring *pring; 1218 struct lpfc_sli *psli = &phba->sli; 1219 1220 /* If the pci channel is offline, ignore possible errors, 1221 * since we cannot communicate with the pci card anyway. 1222 */ 1223 if (pci_channel_offline(phba->pcidev)) { 1224 spin_lock_irq(&phba->hbalock); 1225 phba->hba_flag &= ~DEFER_ERATT; 1226 spin_unlock_irq(&phba->hbalock); 1227 return; 1228 } 1229 1230 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1231 "0479 Deferred Adapter Hardware Error " 1232 "Data: x%x x%x x%x\n", 1233 phba->work_hs, 1234 phba->work_status[0], phba->work_status[1]); 1235 1236 spin_lock_irq(&phba->hbalock); 1237 psli->sli_flag &= ~LPFC_SLI_ACTIVE; 1238 spin_unlock_irq(&phba->hbalock); 1239 1240 1241 /* 1242 * Firmware stops when it triggred erratt. That could cause the I/Os 1243 * dropped by the firmware. Error iocb (I/O) on txcmplq and let the 1244 * SCSI layer retry it after re-establishing link. 1245 */ 1246 pring = &psli->ring[psli->fcp_ring]; 1247 lpfc_sli_abort_iocb_ring(phba, pring); 1248 1249 /* 1250 * There was a firmware error. Take the hba offline and then 1251 * attempt to restart it. 1252 */ 1253 lpfc_offline_prep(phba); 1254 lpfc_offline(phba); 1255 1256 /* Wait for the ER1 bit to clear.*/ 1257 while (phba->work_hs & HS_FFER1) { 1258 msleep(100); 1259 if (lpfc_readl(phba->HSregaddr, &phba->work_hs)) { 1260 phba->work_hs = UNPLUG_ERR ; 1261 break; 1262 } 1263 /* If driver is unloading let the worker thread continue */ 1264 if (phba->pport->load_flag & FC_UNLOADING) { 1265 phba->work_hs = 0; 1266 break; 1267 } 1268 } 1269 1270 /* 1271 * This is to ptrotect against a race condition in which 1272 * first write to the host attention register clear the 1273 * host status register. 1274 */ 1275 if ((!phba->work_hs) && (!(phba->pport->load_flag & FC_UNLOADING))) 1276 phba->work_hs = old_host_status & ~HS_FFER1; 1277 1278 spin_lock_irq(&phba->hbalock); 1279 phba->hba_flag &= ~DEFER_ERATT; 1280 spin_unlock_irq(&phba->hbalock); 1281 phba->work_status[0] = readl(phba->MBslimaddr + 0xa8); 1282 phba->work_status[1] = readl(phba->MBslimaddr + 0xac); 1283 } 1284 1285 static void 1286 lpfc_board_errevt_to_mgmt(struct lpfc_hba *phba) 1287 { 1288 struct lpfc_board_event_header board_event; 1289 struct Scsi_Host *shost; 1290 1291 board_event.event_type = FC_REG_BOARD_EVENT; 1292 board_event.subcategory = LPFC_EVENT_PORTINTERR; 1293 shost = lpfc_shost_from_vport(phba->pport); 1294 fc_host_post_vendor_event(shost, fc_get_event_number(), 1295 sizeof(board_event), 1296 (char *) &board_event, 1297 LPFC_NL_VENDOR_ID); 1298 } 1299 1300 /** 1301 * lpfc_handle_eratt_s3 - The SLI3 HBA hardware error handler 1302 * @phba: pointer to lpfc hba data structure. 1303 * 1304 * This routine is invoked to handle the following HBA hardware error 1305 * conditions: 1306 * 1 - HBA error attention interrupt 1307 * 2 - DMA ring index out of range 1308 * 3 - Mailbox command came back as unknown 1309 **/ 1310 static void 1311 lpfc_handle_eratt_s3(struct lpfc_hba *phba) 1312 { 1313 struct lpfc_vport *vport = phba->pport; 1314 struct lpfc_sli *psli = &phba->sli; 1315 struct lpfc_sli_ring *pring; 1316 uint32_t event_data; 1317 unsigned long temperature; 1318 struct temp_event temp_event_data; 1319 struct Scsi_Host *shost; 1320 1321 /* If the pci channel is offline, ignore possible errors, 1322 * since we cannot communicate with the pci card anyway. 1323 */ 1324 if (pci_channel_offline(phba->pcidev)) { 1325 spin_lock_irq(&phba->hbalock); 1326 phba->hba_flag &= ~DEFER_ERATT; 1327 spin_unlock_irq(&phba->hbalock); 1328 return; 1329 } 1330 1331 /* If resets are disabled then leave the HBA alone and return */ 1332 if (!phba->cfg_enable_hba_reset) 1333 return; 1334 1335 /* Send an internal error event to mgmt application */ 1336 lpfc_board_errevt_to_mgmt(phba); 1337 1338 if (phba->hba_flag & DEFER_ERATT) 1339 lpfc_handle_deferred_eratt(phba); 1340 1341 if ((phba->work_hs & HS_FFER6) || (phba->work_hs & HS_FFER8)) { 1342 if (phba->work_hs & HS_FFER6) 1343 /* Re-establishing Link */ 1344 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT, 1345 "1301 Re-establishing Link " 1346 "Data: x%x x%x x%x\n", 1347 phba->work_hs, phba->work_status[0], 1348 phba->work_status[1]); 1349 if (phba->work_hs & HS_FFER8) 1350 /* Device Zeroization */ 1351 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT, 1352 "2861 Host Authentication device " 1353 "zeroization Data:x%x x%x x%x\n", 1354 phba->work_hs, phba->work_status[0], 1355 phba->work_status[1]); 1356 1357 spin_lock_irq(&phba->hbalock); 1358 psli->sli_flag &= ~LPFC_SLI_ACTIVE; 1359 spin_unlock_irq(&phba->hbalock); 1360 1361 /* 1362 * Firmware stops when it triggled erratt with HS_FFER6. 1363 * That could cause the I/Os dropped by the firmware. 1364 * Error iocb (I/O) on txcmplq and let the SCSI layer 1365 * retry it after re-establishing link. 1366 */ 1367 pring = &psli->ring[psli->fcp_ring]; 1368 lpfc_sli_abort_iocb_ring(phba, pring); 1369 1370 /* 1371 * There was a firmware error. Take the hba offline and then 1372 * attempt to restart it. 1373 */ 1374 lpfc_offline_prep(phba); 1375 lpfc_offline(phba); 1376 lpfc_sli_brdrestart(phba); 1377 if (lpfc_online(phba) == 0) { /* Initialize the HBA */ 1378 lpfc_unblock_mgmt_io(phba); 1379 return; 1380 } 1381 lpfc_unblock_mgmt_io(phba); 1382 } else if (phba->work_hs & HS_CRIT_TEMP) { 1383 temperature = readl(phba->MBslimaddr + TEMPERATURE_OFFSET); 1384 temp_event_data.event_type = FC_REG_TEMPERATURE_EVENT; 1385 temp_event_data.event_code = LPFC_CRIT_TEMP; 1386 temp_event_data.data = (uint32_t)temperature; 1387 1388 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1389 "0406 Adapter maximum temperature exceeded " 1390 "(%ld), taking this port offline " 1391 "Data: x%x x%x x%x\n", 1392 temperature, phba->work_hs, 1393 phba->work_status[0], phba->work_status[1]); 1394 1395 shost = lpfc_shost_from_vport(phba->pport); 1396 fc_host_post_vendor_event(shost, fc_get_event_number(), 1397 sizeof(temp_event_data), 1398 (char *) &temp_event_data, 1399 SCSI_NL_VID_TYPE_PCI 1400 | PCI_VENDOR_ID_EMULEX); 1401 1402 spin_lock_irq(&phba->hbalock); 1403 phba->over_temp_state = HBA_OVER_TEMP; 1404 spin_unlock_irq(&phba->hbalock); 1405 lpfc_offline_eratt(phba); 1406 1407 } else { 1408 /* The if clause above forces this code path when the status 1409 * failure is a value other than FFER6. Do not call the offline 1410 * twice. This is the adapter hardware error path. 1411 */ 1412 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1413 "0457 Adapter Hardware Error " 1414 "Data: x%x x%x x%x\n", 1415 phba->work_hs, 1416 phba->work_status[0], phba->work_status[1]); 1417 1418 event_data = FC_REG_DUMP_EVENT; 1419 shost = lpfc_shost_from_vport(vport); 1420 fc_host_post_vendor_event(shost, fc_get_event_number(), 1421 sizeof(event_data), (char *) &event_data, 1422 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX); 1423 1424 lpfc_offline_eratt(phba); 1425 } 1426 return; 1427 } 1428 1429 /** 1430 * lpfc_handle_eratt_s4 - The SLI4 HBA hardware error handler 1431 * @phba: pointer to lpfc hba data structure. 1432 * 1433 * This routine is invoked to handle the SLI4 HBA hardware error attention 1434 * conditions. 1435 **/ 1436 static void 1437 lpfc_handle_eratt_s4(struct lpfc_hba *phba) 1438 { 1439 struct lpfc_vport *vport = phba->pport; 1440 uint32_t event_data; 1441 struct Scsi_Host *shost; 1442 uint32_t if_type; 1443 struct lpfc_register portstat_reg = {0}; 1444 uint32_t reg_err1, reg_err2; 1445 uint32_t uerrlo_reg, uemasklo_reg; 1446 uint32_t pci_rd_rc1, pci_rd_rc2; 1447 int rc; 1448 1449 /* If the pci channel is offline, ignore possible errors, since 1450 * we cannot communicate with the pci card anyway. 1451 */ 1452 if (pci_channel_offline(phba->pcidev)) 1453 return; 1454 /* If resets are disabled then leave the HBA alone and return */ 1455 if (!phba->cfg_enable_hba_reset) 1456 return; 1457 1458 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 1459 switch (if_type) { 1460 case LPFC_SLI_INTF_IF_TYPE_0: 1461 pci_rd_rc1 = lpfc_readl( 1462 phba->sli4_hba.u.if_type0.UERRLOregaddr, 1463 &uerrlo_reg); 1464 pci_rd_rc2 = lpfc_readl( 1465 phba->sli4_hba.u.if_type0.UEMASKLOregaddr, 1466 &uemasklo_reg); 1467 /* consider PCI bus read error as pci_channel_offline */ 1468 if (pci_rd_rc1 == -EIO && pci_rd_rc2 == -EIO) 1469 return; 1470 lpfc_sli4_offline_eratt(phba); 1471 break; 1472 case LPFC_SLI_INTF_IF_TYPE_2: 1473 pci_rd_rc1 = lpfc_readl( 1474 phba->sli4_hba.u.if_type2.STATUSregaddr, 1475 &portstat_reg.word0); 1476 /* consider PCI bus read error as pci_channel_offline */ 1477 if (pci_rd_rc1 == -EIO) 1478 return; 1479 reg_err1 = readl(phba->sli4_hba.u.if_type2.ERR1regaddr); 1480 reg_err2 = readl(phba->sli4_hba.u.if_type2.ERR2regaddr); 1481 if (bf_get(lpfc_sliport_status_oti, &portstat_reg)) { 1482 /* TODO: Register for Overtemp async events. */ 1483 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1484 "2889 Port Overtemperature event, " 1485 "taking port offline\n"); 1486 spin_lock_irq(&phba->hbalock); 1487 phba->over_temp_state = HBA_OVER_TEMP; 1488 spin_unlock_irq(&phba->hbalock); 1489 lpfc_sli4_offline_eratt(phba); 1490 break; 1491 } 1492 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 && 1493 reg_err2 == SLIPORT_ERR2_REG_FW_RESTART) 1494 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1495 "3143 Port Down: Firmware Restarted\n"); 1496 else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 && 1497 reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP) 1498 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1499 "3144 Port Down: Debug Dump\n"); 1500 else if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 && 1501 reg_err2 == SLIPORT_ERR2_REG_FUNC_PROVISON) 1502 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1503 "3145 Port Down: Provisioning\n"); 1504 /* 1505 * On error status condition, driver need to wait for port 1506 * ready before performing reset. 1507 */ 1508 rc = lpfc_sli4_pdev_status_reg_wait(phba); 1509 if (!rc) { 1510 /* need reset: attempt for port recovery */ 1511 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 1512 "2887 Reset Needed: Attempting Port " 1513 "Recovery...\n"); 1514 lpfc_offline_prep(phba); 1515 lpfc_offline(phba); 1516 lpfc_sli_brdrestart(phba); 1517 if (lpfc_online(phba) == 0) { 1518 lpfc_unblock_mgmt_io(phba); 1519 /* don't report event on forced debug dump */ 1520 if (reg_err1 == SLIPORT_ERR1_REG_ERR_CODE_2 && 1521 reg_err2 == SLIPORT_ERR2_REG_FORCED_DUMP) 1522 return; 1523 else 1524 break; 1525 } 1526 /* fall through for not able to recover */ 1527 } 1528 lpfc_sli4_offline_eratt(phba); 1529 break; 1530 case LPFC_SLI_INTF_IF_TYPE_1: 1531 default: 1532 break; 1533 } 1534 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 1535 "3123 Report dump event to upper layer\n"); 1536 /* Send an internal error event to mgmt application */ 1537 lpfc_board_errevt_to_mgmt(phba); 1538 1539 event_data = FC_REG_DUMP_EVENT; 1540 shost = lpfc_shost_from_vport(vport); 1541 fc_host_post_vendor_event(shost, fc_get_event_number(), 1542 sizeof(event_data), (char *) &event_data, 1543 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX); 1544 } 1545 1546 /** 1547 * lpfc_handle_eratt - Wrapper func for handling hba error attention 1548 * @phba: pointer to lpfc HBA data structure. 1549 * 1550 * This routine wraps the actual SLI3 or SLI4 hba error attention handling 1551 * routine from the API jump table function pointer from the lpfc_hba struct. 1552 * 1553 * Return codes 1554 * 0 - success. 1555 * Any other value - error. 1556 **/ 1557 void 1558 lpfc_handle_eratt(struct lpfc_hba *phba) 1559 { 1560 (*phba->lpfc_handle_eratt)(phba); 1561 } 1562 1563 /** 1564 * lpfc_handle_latt - The HBA link event handler 1565 * @phba: pointer to lpfc hba data structure. 1566 * 1567 * This routine is invoked from the worker thread to handle a HBA host 1568 * attention link event. 1569 **/ 1570 void 1571 lpfc_handle_latt(struct lpfc_hba *phba) 1572 { 1573 struct lpfc_vport *vport = phba->pport; 1574 struct lpfc_sli *psli = &phba->sli; 1575 LPFC_MBOXQ_t *pmb; 1576 volatile uint32_t control; 1577 struct lpfc_dmabuf *mp; 1578 int rc = 0; 1579 1580 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1581 if (!pmb) { 1582 rc = 1; 1583 goto lpfc_handle_latt_err_exit; 1584 } 1585 1586 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 1587 if (!mp) { 1588 rc = 2; 1589 goto lpfc_handle_latt_free_pmb; 1590 } 1591 1592 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); 1593 if (!mp->virt) { 1594 rc = 3; 1595 goto lpfc_handle_latt_free_mp; 1596 } 1597 1598 /* Cleanup any outstanding ELS commands */ 1599 lpfc_els_flush_all_cmd(phba); 1600 1601 psli->slistat.link_event++; 1602 lpfc_read_topology(phba, pmb, mp); 1603 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology; 1604 pmb->vport = vport; 1605 /* Block ELS IOCBs until we have processed this mbox command */ 1606 phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT; 1607 rc = lpfc_sli_issue_mbox (phba, pmb, MBX_NOWAIT); 1608 if (rc == MBX_NOT_FINISHED) { 1609 rc = 4; 1610 goto lpfc_handle_latt_free_mbuf; 1611 } 1612 1613 /* Clear Link Attention in HA REG */ 1614 spin_lock_irq(&phba->hbalock); 1615 writel(HA_LATT, phba->HAregaddr); 1616 readl(phba->HAregaddr); /* flush */ 1617 spin_unlock_irq(&phba->hbalock); 1618 1619 return; 1620 1621 lpfc_handle_latt_free_mbuf: 1622 phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT; 1623 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1624 lpfc_handle_latt_free_mp: 1625 kfree(mp); 1626 lpfc_handle_latt_free_pmb: 1627 mempool_free(pmb, phba->mbox_mem_pool); 1628 lpfc_handle_latt_err_exit: 1629 /* Enable Link attention interrupts */ 1630 spin_lock_irq(&phba->hbalock); 1631 psli->sli_flag |= LPFC_PROCESS_LA; 1632 control = readl(phba->HCregaddr); 1633 control |= HC_LAINT_ENA; 1634 writel(control, phba->HCregaddr); 1635 readl(phba->HCregaddr); /* flush */ 1636 1637 /* Clear Link Attention in HA REG */ 1638 writel(HA_LATT, phba->HAregaddr); 1639 readl(phba->HAregaddr); /* flush */ 1640 spin_unlock_irq(&phba->hbalock); 1641 lpfc_linkdown(phba); 1642 phba->link_state = LPFC_HBA_ERROR; 1643 1644 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX, 1645 "0300 LATT: Cannot issue READ_LA: Data:%d\n", rc); 1646 1647 return; 1648 } 1649 1650 /** 1651 * lpfc_parse_vpd - Parse VPD (Vital Product Data) 1652 * @phba: pointer to lpfc hba data structure. 1653 * @vpd: pointer to the vital product data. 1654 * @len: length of the vital product data in bytes. 1655 * 1656 * This routine parses the Vital Product Data (VPD). The VPD is treated as 1657 * an array of characters. In this routine, the ModelName, ProgramType, and 1658 * ModelDesc, etc. fields of the phba data structure will be populated. 1659 * 1660 * Return codes 1661 * 0 - pointer to the VPD passed in is NULL 1662 * 1 - success 1663 **/ 1664 int 1665 lpfc_parse_vpd(struct lpfc_hba *phba, uint8_t *vpd, int len) 1666 { 1667 uint8_t lenlo, lenhi; 1668 int Length; 1669 int i, j; 1670 int finished = 0; 1671 int index = 0; 1672 1673 if (!vpd) 1674 return 0; 1675 1676 /* Vital Product */ 1677 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 1678 "0455 Vital Product Data: x%x x%x x%x x%x\n", 1679 (uint32_t) vpd[0], (uint32_t) vpd[1], (uint32_t) vpd[2], 1680 (uint32_t) vpd[3]); 1681 while (!finished && (index < (len - 4))) { 1682 switch (vpd[index]) { 1683 case 0x82: 1684 case 0x91: 1685 index += 1; 1686 lenlo = vpd[index]; 1687 index += 1; 1688 lenhi = vpd[index]; 1689 index += 1; 1690 i = ((((unsigned short)lenhi) << 8) + lenlo); 1691 index += i; 1692 break; 1693 case 0x90: 1694 index += 1; 1695 lenlo = vpd[index]; 1696 index += 1; 1697 lenhi = vpd[index]; 1698 index += 1; 1699 Length = ((((unsigned short)lenhi) << 8) + lenlo); 1700 if (Length > len - index) 1701 Length = len - index; 1702 while (Length > 0) { 1703 /* Look for Serial Number */ 1704 if ((vpd[index] == 'S') && (vpd[index+1] == 'N')) { 1705 index += 2; 1706 i = vpd[index]; 1707 index += 1; 1708 j = 0; 1709 Length -= (3+i); 1710 while(i--) { 1711 phba->SerialNumber[j++] = vpd[index++]; 1712 if (j == 31) 1713 break; 1714 } 1715 phba->SerialNumber[j] = 0; 1716 continue; 1717 } 1718 else if ((vpd[index] == 'V') && (vpd[index+1] == '1')) { 1719 phba->vpd_flag |= VPD_MODEL_DESC; 1720 index += 2; 1721 i = vpd[index]; 1722 index += 1; 1723 j = 0; 1724 Length -= (3+i); 1725 while(i--) { 1726 phba->ModelDesc[j++] = vpd[index++]; 1727 if (j == 255) 1728 break; 1729 } 1730 phba->ModelDesc[j] = 0; 1731 continue; 1732 } 1733 else if ((vpd[index] == 'V') && (vpd[index+1] == '2')) { 1734 phba->vpd_flag |= VPD_MODEL_NAME; 1735 index += 2; 1736 i = vpd[index]; 1737 index += 1; 1738 j = 0; 1739 Length -= (3+i); 1740 while(i--) { 1741 phba->ModelName[j++] = vpd[index++]; 1742 if (j == 79) 1743 break; 1744 } 1745 phba->ModelName[j] = 0; 1746 continue; 1747 } 1748 else if ((vpd[index] == 'V') && (vpd[index+1] == '3')) { 1749 phba->vpd_flag |= VPD_PROGRAM_TYPE; 1750 index += 2; 1751 i = vpd[index]; 1752 index += 1; 1753 j = 0; 1754 Length -= (3+i); 1755 while(i--) { 1756 phba->ProgramType[j++] = vpd[index++]; 1757 if (j == 255) 1758 break; 1759 } 1760 phba->ProgramType[j] = 0; 1761 continue; 1762 } 1763 else if ((vpd[index] == 'V') && (vpd[index+1] == '4')) { 1764 phba->vpd_flag |= VPD_PORT; 1765 index += 2; 1766 i = vpd[index]; 1767 index += 1; 1768 j = 0; 1769 Length -= (3+i); 1770 while(i--) { 1771 if ((phba->sli_rev == LPFC_SLI_REV4) && 1772 (phba->sli4_hba.pport_name_sta == 1773 LPFC_SLI4_PPNAME_GET)) { 1774 j++; 1775 index++; 1776 } else 1777 phba->Port[j++] = vpd[index++]; 1778 if (j == 19) 1779 break; 1780 } 1781 if ((phba->sli_rev != LPFC_SLI_REV4) || 1782 (phba->sli4_hba.pport_name_sta == 1783 LPFC_SLI4_PPNAME_NON)) 1784 phba->Port[j] = 0; 1785 continue; 1786 } 1787 else { 1788 index += 2; 1789 i = vpd[index]; 1790 index += 1; 1791 index += i; 1792 Length -= (3 + i); 1793 } 1794 } 1795 finished = 0; 1796 break; 1797 case 0x78: 1798 finished = 1; 1799 break; 1800 default: 1801 index ++; 1802 break; 1803 } 1804 } 1805 1806 return(1); 1807 } 1808 1809 /** 1810 * lpfc_get_hba_model_desc - Retrieve HBA device model name and description 1811 * @phba: pointer to lpfc hba data structure. 1812 * @mdp: pointer to the data structure to hold the derived model name. 1813 * @descp: pointer to the data structure to hold the derived description. 1814 * 1815 * This routine retrieves HBA's description based on its registered PCI device 1816 * ID. The @descp passed into this function points to an array of 256 chars. It 1817 * shall be returned with the model name, maximum speed, and the host bus type. 1818 * The @mdp passed into this function points to an array of 80 chars. When the 1819 * function returns, the @mdp will be filled with the model name. 1820 **/ 1821 static void 1822 lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp) 1823 { 1824 lpfc_vpd_t *vp; 1825 uint16_t dev_id = phba->pcidev->device; 1826 int max_speed; 1827 int GE = 0; 1828 int oneConnect = 0; /* default is not a oneConnect */ 1829 struct { 1830 char *name; 1831 char *bus; 1832 char *function; 1833 } m = {"<Unknown>", "", ""}; 1834 1835 if (mdp && mdp[0] != '\0' 1836 && descp && descp[0] != '\0') 1837 return; 1838 1839 if (phba->lmt & LMT_16Gb) 1840 max_speed = 16; 1841 else if (phba->lmt & LMT_10Gb) 1842 max_speed = 10; 1843 else if (phba->lmt & LMT_8Gb) 1844 max_speed = 8; 1845 else if (phba->lmt & LMT_4Gb) 1846 max_speed = 4; 1847 else if (phba->lmt & LMT_2Gb) 1848 max_speed = 2; 1849 else 1850 max_speed = 1; 1851 1852 vp = &phba->vpd; 1853 1854 switch (dev_id) { 1855 case PCI_DEVICE_ID_FIREFLY: 1856 m = (typeof(m)){"LP6000", "PCI", "Fibre Channel Adapter"}; 1857 break; 1858 case PCI_DEVICE_ID_SUPERFLY: 1859 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3) 1860 m = (typeof(m)){"LP7000", "PCI", 1861 "Fibre Channel Adapter"}; 1862 else 1863 m = (typeof(m)){"LP7000E", "PCI", 1864 "Fibre Channel Adapter"}; 1865 break; 1866 case PCI_DEVICE_ID_DRAGONFLY: 1867 m = (typeof(m)){"LP8000", "PCI", 1868 "Fibre Channel Adapter"}; 1869 break; 1870 case PCI_DEVICE_ID_CENTAUR: 1871 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID) 1872 m = (typeof(m)){"LP9002", "PCI", 1873 "Fibre Channel Adapter"}; 1874 else 1875 m = (typeof(m)){"LP9000", "PCI", 1876 "Fibre Channel Adapter"}; 1877 break; 1878 case PCI_DEVICE_ID_RFLY: 1879 m = (typeof(m)){"LP952", "PCI", 1880 "Fibre Channel Adapter"}; 1881 break; 1882 case PCI_DEVICE_ID_PEGASUS: 1883 m = (typeof(m)){"LP9802", "PCI-X", 1884 "Fibre Channel Adapter"}; 1885 break; 1886 case PCI_DEVICE_ID_THOR: 1887 m = (typeof(m)){"LP10000", "PCI-X", 1888 "Fibre Channel Adapter"}; 1889 break; 1890 case PCI_DEVICE_ID_VIPER: 1891 m = (typeof(m)){"LPX1000", "PCI-X", 1892 "Fibre Channel Adapter"}; 1893 break; 1894 case PCI_DEVICE_ID_PFLY: 1895 m = (typeof(m)){"LP982", "PCI-X", 1896 "Fibre Channel Adapter"}; 1897 break; 1898 case PCI_DEVICE_ID_TFLY: 1899 m = (typeof(m)){"LP1050", "PCI-X", 1900 "Fibre Channel Adapter"}; 1901 break; 1902 case PCI_DEVICE_ID_HELIOS: 1903 m = (typeof(m)){"LP11000", "PCI-X2", 1904 "Fibre Channel Adapter"}; 1905 break; 1906 case PCI_DEVICE_ID_HELIOS_SCSP: 1907 m = (typeof(m)){"LP11000-SP", "PCI-X2", 1908 "Fibre Channel Adapter"}; 1909 break; 1910 case PCI_DEVICE_ID_HELIOS_DCSP: 1911 m = (typeof(m)){"LP11002-SP", "PCI-X2", 1912 "Fibre Channel Adapter"}; 1913 break; 1914 case PCI_DEVICE_ID_NEPTUNE: 1915 m = (typeof(m)){"LPe1000", "PCIe", "Fibre Channel Adapter"}; 1916 break; 1917 case PCI_DEVICE_ID_NEPTUNE_SCSP: 1918 m = (typeof(m)){"LPe1000-SP", "PCIe", "Fibre Channel Adapter"}; 1919 break; 1920 case PCI_DEVICE_ID_NEPTUNE_DCSP: 1921 m = (typeof(m)){"LPe1002-SP", "PCIe", "Fibre Channel Adapter"}; 1922 break; 1923 case PCI_DEVICE_ID_BMID: 1924 m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"}; 1925 break; 1926 case PCI_DEVICE_ID_BSMB: 1927 m = (typeof(m)){"LP111", "PCI-X2", "Fibre Channel Adapter"}; 1928 break; 1929 case PCI_DEVICE_ID_ZEPHYR: 1930 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"}; 1931 break; 1932 case PCI_DEVICE_ID_ZEPHYR_SCSP: 1933 m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"}; 1934 break; 1935 case PCI_DEVICE_ID_ZEPHYR_DCSP: 1936 m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"}; 1937 GE = 1; 1938 break; 1939 case PCI_DEVICE_ID_ZMID: 1940 m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"}; 1941 break; 1942 case PCI_DEVICE_ID_ZSMB: 1943 m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"}; 1944 break; 1945 case PCI_DEVICE_ID_LP101: 1946 m = (typeof(m)){"LP101", "PCI-X", "Fibre Channel Adapter"}; 1947 break; 1948 case PCI_DEVICE_ID_LP10000S: 1949 m = (typeof(m)){"LP10000-S", "PCI", "Fibre Channel Adapter"}; 1950 break; 1951 case PCI_DEVICE_ID_LP11000S: 1952 m = (typeof(m)){"LP11000-S", "PCI-X2", "Fibre Channel Adapter"}; 1953 break; 1954 case PCI_DEVICE_ID_LPE11000S: 1955 m = (typeof(m)){"LPe11000-S", "PCIe", "Fibre Channel Adapter"}; 1956 break; 1957 case PCI_DEVICE_ID_SAT: 1958 m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"}; 1959 break; 1960 case PCI_DEVICE_ID_SAT_MID: 1961 m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"}; 1962 break; 1963 case PCI_DEVICE_ID_SAT_SMB: 1964 m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"}; 1965 break; 1966 case PCI_DEVICE_ID_SAT_DCSP: 1967 m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"}; 1968 break; 1969 case PCI_DEVICE_ID_SAT_SCSP: 1970 m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"}; 1971 break; 1972 case PCI_DEVICE_ID_SAT_S: 1973 m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"}; 1974 break; 1975 case PCI_DEVICE_ID_HORNET: 1976 m = (typeof(m)){"LP21000", "PCIe", "FCoE Adapter"}; 1977 GE = 1; 1978 break; 1979 case PCI_DEVICE_ID_PROTEUS_VF: 1980 m = (typeof(m)){"LPev12000", "PCIe IOV", 1981 "Fibre Channel Adapter"}; 1982 break; 1983 case PCI_DEVICE_ID_PROTEUS_PF: 1984 m = (typeof(m)){"LPev12000", "PCIe IOV", 1985 "Fibre Channel Adapter"}; 1986 break; 1987 case PCI_DEVICE_ID_PROTEUS_S: 1988 m = (typeof(m)){"LPemv12002-S", "PCIe IOV", 1989 "Fibre Channel Adapter"}; 1990 break; 1991 case PCI_DEVICE_ID_TIGERSHARK: 1992 oneConnect = 1; 1993 m = (typeof(m)){"OCe10100", "PCIe", "FCoE"}; 1994 break; 1995 case PCI_DEVICE_ID_TOMCAT: 1996 oneConnect = 1; 1997 m = (typeof(m)){"OCe11100", "PCIe", "FCoE"}; 1998 break; 1999 case PCI_DEVICE_ID_FALCON: 2000 m = (typeof(m)){"LPSe12002-ML1-E", "PCIe", 2001 "EmulexSecure Fibre"}; 2002 break; 2003 case PCI_DEVICE_ID_BALIUS: 2004 m = (typeof(m)){"LPVe12002", "PCIe Shared I/O", 2005 "Fibre Channel Adapter"}; 2006 break; 2007 case PCI_DEVICE_ID_LANCER_FC: 2008 case PCI_DEVICE_ID_LANCER_FC_VF: 2009 m = (typeof(m)){"LPe16000", "PCIe", "Fibre Channel Adapter"}; 2010 break; 2011 case PCI_DEVICE_ID_LANCER_FCOE: 2012 case PCI_DEVICE_ID_LANCER_FCOE_VF: 2013 oneConnect = 1; 2014 m = (typeof(m)){"OCe15100", "PCIe", "FCoE"}; 2015 break; 2016 default: 2017 m = (typeof(m)){"Unknown", "", ""}; 2018 break; 2019 } 2020 2021 if (mdp && mdp[0] == '\0') 2022 snprintf(mdp, 79,"%s", m.name); 2023 /* 2024 * oneConnect hba requires special processing, they are all initiators 2025 * and we put the port number on the end 2026 */ 2027 if (descp && descp[0] == '\0') { 2028 if (oneConnect) 2029 snprintf(descp, 255, 2030 "Emulex OneConnect %s, %s Initiator, Port %s", 2031 m.name, m.function, 2032 phba->Port); 2033 else 2034 snprintf(descp, 255, 2035 "Emulex %s %d%s %s %s", 2036 m.name, max_speed, (GE) ? "GE" : "Gb", 2037 m.bus, m.function); 2038 } 2039 } 2040 2041 /** 2042 * lpfc_post_buffer - Post IOCB(s) with DMA buffer descriptor(s) to a IOCB ring 2043 * @phba: pointer to lpfc hba data structure. 2044 * @pring: pointer to a IOCB ring. 2045 * @cnt: the number of IOCBs to be posted to the IOCB ring. 2046 * 2047 * This routine posts a given number of IOCBs with the associated DMA buffer 2048 * descriptors specified by the cnt argument to the given IOCB ring. 2049 * 2050 * Return codes 2051 * The number of IOCBs NOT able to be posted to the IOCB ring. 2052 **/ 2053 int 2054 lpfc_post_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, int cnt) 2055 { 2056 IOCB_t *icmd; 2057 struct lpfc_iocbq *iocb; 2058 struct lpfc_dmabuf *mp1, *mp2; 2059 2060 cnt += pring->missbufcnt; 2061 2062 /* While there are buffers to post */ 2063 while (cnt > 0) { 2064 /* Allocate buffer for command iocb */ 2065 iocb = lpfc_sli_get_iocbq(phba); 2066 if (iocb == NULL) { 2067 pring->missbufcnt = cnt; 2068 return cnt; 2069 } 2070 icmd = &iocb->iocb; 2071 2072 /* 2 buffers can be posted per command */ 2073 /* Allocate buffer to post */ 2074 mp1 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 2075 if (mp1) 2076 mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI, &mp1->phys); 2077 if (!mp1 || !mp1->virt) { 2078 kfree(mp1); 2079 lpfc_sli_release_iocbq(phba, iocb); 2080 pring->missbufcnt = cnt; 2081 return cnt; 2082 } 2083 2084 INIT_LIST_HEAD(&mp1->list); 2085 /* Allocate buffer to post */ 2086 if (cnt > 1) { 2087 mp2 = kmalloc(sizeof (struct lpfc_dmabuf), GFP_KERNEL); 2088 if (mp2) 2089 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI, 2090 &mp2->phys); 2091 if (!mp2 || !mp2->virt) { 2092 kfree(mp2); 2093 lpfc_mbuf_free(phba, mp1->virt, mp1->phys); 2094 kfree(mp1); 2095 lpfc_sli_release_iocbq(phba, iocb); 2096 pring->missbufcnt = cnt; 2097 return cnt; 2098 } 2099 2100 INIT_LIST_HEAD(&mp2->list); 2101 } else { 2102 mp2 = NULL; 2103 } 2104 2105 icmd->un.cont64[0].addrHigh = putPaddrHigh(mp1->phys); 2106 icmd->un.cont64[0].addrLow = putPaddrLow(mp1->phys); 2107 icmd->un.cont64[0].tus.f.bdeSize = FCELSSIZE; 2108 icmd->ulpBdeCount = 1; 2109 cnt--; 2110 if (mp2) { 2111 icmd->un.cont64[1].addrHigh = putPaddrHigh(mp2->phys); 2112 icmd->un.cont64[1].addrLow = putPaddrLow(mp2->phys); 2113 icmd->un.cont64[1].tus.f.bdeSize = FCELSSIZE; 2114 cnt--; 2115 icmd->ulpBdeCount = 2; 2116 } 2117 2118 icmd->ulpCommand = CMD_QUE_RING_BUF64_CN; 2119 icmd->ulpLe = 1; 2120 2121 if (lpfc_sli_issue_iocb(phba, pring->ringno, iocb, 0) == 2122 IOCB_ERROR) { 2123 lpfc_mbuf_free(phba, mp1->virt, mp1->phys); 2124 kfree(mp1); 2125 cnt++; 2126 if (mp2) { 2127 lpfc_mbuf_free(phba, mp2->virt, mp2->phys); 2128 kfree(mp2); 2129 cnt++; 2130 } 2131 lpfc_sli_release_iocbq(phba, iocb); 2132 pring->missbufcnt = cnt; 2133 return cnt; 2134 } 2135 lpfc_sli_ringpostbuf_put(phba, pring, mp1); 2136 if (mp2) 2137 lpfc_sli_ringpostbuf_put(phba, pring, mp2); 2138 } 2139 pring->missbufcnt = 0; 2140 return 0; 2141 } 2142 2143 /** 2144 * lpfc_post_rcv_buf - Post the initial receive IOCB buffers to ELS ring 2145 * @phba: pointer to lpfc hba data structure. 2146 * 2147 * This routine posts initial receive IOCB buffers to the ELS ring. The 2148 * current number of initial IOCB buffers specified by LPFC_BUF_RING0 is 2149 * set to 64 IOCBs. 2150 * 2151 * Return codes 2152 * 0 - success (currently always success) 2153 **/ 2154 static int 2155 lpfc_post_rcv_buf(struct lpfc_hba *phba) 2156 { 2157 struct lpfc_sli *psli = &phba->sli; 2158 2159 /* Ring 0, ELS / CT buffers */ 2160 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0); 2161 /* Ring 2 - FCP no buffers needed */ 2162 2163 return 0; 2164 } 2165 2166 #define S(N,V) (((V)<<(N))|((V)>>(32-(N)))) 2167 2168 /** 2169 * lpfc_sha_init - Set up initial array of hash table entries 2170 * @HashResultPointer: pointer to an array as hash table. 2171 * 2172 * This routine sets up the initial values to the array of hash table entries 2173 * for the LC HBAs. 2174 **/ 2175 static void 2176 lpfc_sha_init(uint32_t * HashResultPointer) 2177 { 2178 HashResultPointer[0] = 0x67452301; 2179 HashResultPointer[1] = 0xEFCDAB89; 2180 HashResultPointer[2] = 0x98BADCFE; 2181 HashResultPointer[3] = 0x10325476; 2182 HashResultPointer[4] = 0xC3D2E1F0; 2183 } 2184 2185 /** 2186 * lpfc_sha_iterate - Iterate initial hash table with the working hash table 2187 * @HashResultPointer: pointer to an initial/result hash table. 2188 * @HashWorkingPointer: pointer to an working hash table. 2189 * 2190 * This routine iterates an initial hash table pointed by @HashResultPointer 2191 * with the values from the working hash table pointeed by @HashWorkingPointer. 2192 * The results are putting back to the initial hash table, returned through 2193 * the @HashResultPointer as the result hash table. 2194 **/ 2195 static void 2196 lpfc_sha_iterate(uint32_t * HashResultPointer, uint32_t * HashWorkingPointer) 2197 { 2198 int t; 2199 uint32_t TEMP; 2200 uint32_t A, B, C, D, E; 2201 t = 16; 2202 do { 2203 HashWorkingPointer[t] = 2204 S(1, 2205 HashWorkingPointer[t - 3] ^ HashWorkingPointer[t - 2206 8] ^ 2207 HashWorkingPointer[t - 14] ^ HashWorkingPointer[t - 16]); 2208 } while (++t <= 79); 2209 t = 0; 2210 A = HashResultPointer[0]; 2211 B = HashResultPointer[1]; 2212 C = HashResultPointer[2]; 2213 D = HashResultPointer[3]; 2214 E = HashResultPointer[4]; 2215 2216 do { 2217 if (t < 20) { 2218 TEMP = ((B & C) | ((~B) & D)) + 0x5A827999; 2219 } else if (t < 40) { 2220 TEMP = (B ^ C ^ D) + 0x6ED9EBA1; 2221 } else if (t < 60) { 2222 TEMP = ((B & C) | (B & D) | (C & D)) + 0x8F1BBCDC; 2223 } else { 2224 TEMP = (B ^ C ^ D) + 0xCA62C1D6; 2225 } 2226 TEMP += S(5, A) + E + HashWorkingPointer[t]; 2227 E = D; 2228 D = C; 2229 C = S(30, B); 2230 B = A; 2231 A = TEMP; 2232 } while (++t <= 79); 2233 2234 HashResultPointer[0] += A; 2235 HashResultPointer[1] += B; 2236 HashResultPointer[2] += C; 2237 HashResultPointer[3] += D; 2238 HashResultPointer[4] += E; 2239 2240 } 2241 2242 /** 2243 * lpfc_challenge_key - Create challenge key based on WWPN of the HBA 2244 * @RandomChallenge: pointer to the entry of host challenge random number array. 2245 * @HashWorking: pointer to the entry of the working hash array. 2246 * 2247 * This routine calculates the working hash array referred by @HashWorking 2248 * from the challenge random numbers associated with the host, referred by 2249 * @RandomChallenge. The result is put into the entry of the working hash 2250 * array and returned by reference through @HashWorking. 2251 **/ 2252 static void 2253 lpfc_challenge_key(uint32_t * RandomChallenge, uint32_t * HashWorking) 2254 { 2255 *HashWorking = (*RandomChallenge ^ *HashWorking); 2256 } 2257 2258 /** 2259 * lpfc_hba_init - Perform special handling for LC HBA initialization 2260 * @phba: pointer to lpfc hba data structure. 2261 * @hbainit: pointer to an array of unsigned 32-bit integers. 2262 * 2263 * This routine performs the special handling for LC HBA initialization. 2264 **/ 2265 void 2266 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit) 2267 { 2268 int t; 2269 uint32_t *HashWorking; 2270 uint32_t *pwwnn = (uint32_t *) phba->wwnn; 2271 2272 HashWorking = kcalloc(80, sizeof(uint32_t), GFP_KERNEL); 2273 if (!HashWorking) 2274 return; 2275 2276 HashWorking[0] = HashWorking[78] = *pwwnn++; 2277 HashWorking[1] = HashWorking[79] = *pwwnn; 2278 2279 for (t = 0; t < 7; t++) 2280 lpfc_challenge_key(phba->RandomData + t, HashWorking + t); 2281 2282 lpfc_sha_init(hbainit); 2283 lpfc_sha_iterate(hbainit, HashWorking); 2284 kfree(HashWorking); 2285 } 2286 2287 /** 2288 * lpfc_cleanup - Performs vport cleanups before deleting a vport 2289 * @vport: pointer to a virtual N_Port data structure. 2290 * 2291 * This routine performs the necessary cleanups before deleting the @vport. 2292 * It invokes the discovery state machine to perform necessary state 2293 * transitions and to release the ndlps associated with the @vport. Note, 2294 * the physical port is treated as @vport 0. 2295 **/ 2296 void 2297 lpfc_cleanup(struct lpfc_vport *vport) 2298 { 2299 struct lpfc_hba *phba = vport->phba; 2300 struct lpfc_nodelist *ndlp, *next_ndlp; 2301 int i = 0; 2302 2303 if (phba->link_state > LPFC_LINK_DOWN) 2304 lpfc_port_link_failure(vport); 2305 2306 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 2307 if (!NLP_CHK_NODE_ACT(ndlp)) { 2308 ndlp = lpfc_enable_node(vport, ndlp, 2309 NLP_STE_UNUSED_NODE); 2310 if (!ndlp) 2311 continue; 2312 spin_lock_irq(&phba->ndlp_lock); 2313 NLP_SET_FREE_REQ(ndlp); 2314 spin_unlock_irq(&phba->ndlp_lock); 2315 /* Trigger the release of the ndlp memory */ 2316 lpfc_nlp_put(ndlp); 2317 continue; 2318 } 2319 spin_lock_irq(&phba->ndlp_lock); 2320 if (NLP_CHK_FREE_REQ(ndlp)) { 2321 /* The ndlp should not be in memory free mode already */ 2322 spin_unlock_irq(&phba->ndlp_lock); 2323 continue; 2324 } else 2325 /* Indicate request for freeing ndlp memory */ 2326 NLP_SET_FREE_REQ(ndlp); 2327 spin_unlock_irq(&phba->ndlp_lock); 2328 2329 if (vport->port_type != LPFC_PHYSICAL_PORT && 2330 ndlp->nlp_DID == Fabric_DID) { 2331 /* Just free up ndlp with Fabric_DID for vports */ 2332 lpfc_nlp_put(ndlp); 2333 continue; 2334 } 2335 2336 if (ndlp->nlp_type & NLP_FABRIC) 2337 lpfc_disc_state_machine(vport, ndlp, NULL, 2338 NLP_EVT_DEVICE_RECOVERY); 2339 2340 lpfc_disc_state_machine(vport, ndlp, NULL, 2341 NLP_EVT_DEVICE_RM); 2342 2343 } 2344 2345 /* At this point, ALL ndlp's should be gone 2346 * because of the previous NLP_EVT_DEVICE_RM. 2347 * Lets wait for this to happen, if needed. 2348 */ 2349 while (!list_empty(&vport->fc_nodes)) { 2350 if (i++ > 3000) { 2351 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2352 "0233 Nodelist not empty\n"); 2353 list_for_each_entry_safe(ndlp, next_ndlp, 2354 &vport->fc_nodes, nlp_listp) { 2355 lpfc_printf_vlog(ndlp->vport, KERN_ERR, 2356 LOG_NODE, 2357 "0282 did:x%x ndlp:x%p " 2358 "usgmap:x%x refcnt:%d\n", 2359 ndlp->nlp_DID, (void *)ndlp, 2360 ndlp->nlp_usg_map, 2361 atomic_read( 2362 &ndlp->kref.refcount)); 2363 } 2364 break; 2365 } 2366 2367 /* Wait for any activity on ndlps to settle */ 2368 msleep(10); 2369 } 2370 lpfc_cleanup_vports_rrqs(vport, NULL); 2371 } 2372 2373 /** 2374 * lpfc_stop_vport_timers - Stop all the timers associated with a vport 2375 * @vport: pointer to a virtual N_Port data structure. 2376 * 2377 * This routine stops all the timers associated with a @vport. This function 2378 * is invoked before disabling or deleting a @vport. Note that the physical 2379 * port is treated as @vport 0. 2380 **/ 2381 void 2382 lpfc_stop_vport_timers(struct lpfc_vport *vport) 2383 { 2384 del_timer_sync(&vport->els_tmofunc); 2385 del_timer_sync(&vport->fc_fdmitmo); 2386 del_timer_sync(&vport->delayed_disc_tmo); 2387 lpfc_can_disctmo(vport); 2388 return; 2389 } 2390 2391 /** 2392 * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer 2393 * @phba: pointer to lpfc hba data structure. 2394 * 2395 * This routine stops the SLI4 FCF rediscover wait timer if it's on. The 2396 * caller of this routine should already hold the host lock. 2397 **/ 2398 void 2399 __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba) 2400 { 2401 /* Clear pending FCF rediscovery wait flag */ 2402 phba->fcf.fcf_flag &= ~FCF_REDISC_PEND; 2403 2404 /* Now, try to stop the timer */ 2405 del_timer(&phba->fcf.redisc_wait); 2406 } 2407 2408 /** 2409 * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer 2410 * @phba: pointer to lpfc hba data structure. 2411 * 2412 * This routine stops the SLI4 FCF rediscover wait timer if it's on. It 2413 * checks whether the FCF rediscovery wait timer is pending with the host 2414 * lock held before proceeding with disabling the timer and clearing the 2415 * wait timer pendig flag. 2416 **/ 2417 void 2418 lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba) 2419 { 2420 spin_lock_irq(&phba->hbalock); 2421 if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) { 2422 /* FCF rediscovery timer already fired or stopped */ 2423 spin_unlock_irq(&phba->hbalock); 2424 return; 2425 } 2426 __lpfc_sli4_stop_fcf_redisc_wait_timer(phba); 2427 /* Clear failover in progress flags */ 2428 phba->fcf.fcf_flag &= ~(FCF_DEAD_DISC | FCF_ACVL_DISC); 2429 spin_unlock_irq(&phba->hbalock); 2430 } 2431 2432 /** 2433 * lpfc_stop_hba_timers - Stop all the timers associated with an HBA 2434 * @phba: pointer to lpfc hba data structure. 2435 * 2436 * This routine stops all the timers associated with a HBA. This function is 2437 * invoked before either putting a HBA offline or unloading the driver. 2438 **/ 2439 void 2440 lpfc_stop_hba_timers(struct lpfc_hba *phba) 2441 { 2442 lpfc_stop_vport_timers(phba->pport); 2443 del_timer_sync(&phba->sli.mbox_tmo); 2444 del_timer_sync(&phba->fabric_block_timer); 2445 del_timer_sync(&phba->eratt_poll); 2446 del_timer_sync(&phba->hb_tmofunc); 2447 if (phba->sli_rev == LPFC_SLI_REV4) { 2448 del_timer_sync(&phba->rrq_tmr); 2449 phba->hba_flag &= ~HBA_RRQ_ACTIVE; 2450 } 2451 phba->hb_outstanding = 0; 2452 2453 switch (phba->pci_dev_grp) { 2454 case LPFC_PCI_DEV_LP: 2455 /* Stop any LightPulse device specific driver timers */ 2456 del_timer_sync(&phba->fcp_poll_timer); 2457 break; 2458 case LPFC_PCI_DEV_OC: 2459 /* Stop any OneConnect device sepcific driver timers */ 2460 lpfc_sli4_stop_fcf_redisc_wait_timer(phba); 2461 break; 2462 default: 2463 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 2464 "0297 Invalid device group (x%x)\n", 2465 phba->pci_dev_grp); 2466 break; 2467 } 2468 return; 2469 } 2470 2471 /** 2472 * lpfc_block_mgmt_io - Mark a HBA's management interface as blocked 2473 * @phba: pointer to lpfc hba data structure. 2474 * 2475 * This routine marks a HBA's management interface as blocked. Once the HBA's 2476 * management interface is marked as blocked, all the user space access to 2477 * the HBA, whether they are from sysfs interface or libdfc interface will 2478 * all be blocked. The HBA is set to block the management interface when the 2479 * driver prepares the HBA interface for online or offline. 2480 **/ 2481 static void 2482 lpfc_block_mgmt_io(struct lpfc_hba * phba) 2483 { 2484 unsigned long iflag; 2485 uint8_t actcmd = MBX_HEARTBEAT; 2486 unsigned long timeout; 2487 2488 timeout = msecs_to_jiffies(LPFC_MBOX_TMO * 1000) + jiffies; 2489 spin_lock_irqsave(&phba->hbalock, iflag); 2490 phba->sli.sli_flag |= LPFC_BLOCK_MGMT_IO; 2491 if (phba->sli.mbox_active) { 2492 actcmd = phba->sli.mbox_active->u.mb.mbxCommand; 2493 /* Determine how long we might wait for the active mailbox 2494 * command to be gracefully completed by firmware. 2495 */ 2496 timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, 2497 phba->sli.mbox_active) * 1000) + jiffies; 2498 } 2499 spin_unlock_irqrestore(&phba->hbalock, iflag); 2500 2501 /* Wait for the outstnading mailbox command to complete */ 2502 while (phba->sli.mbox_active) { 2503 /* Check active mailbox complete status every 2ms */ 2504 msleep(2); 2505 if (time_after(jiffies, timeout)) { 2506 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 2507 "2813 Mgmt IO is Blocked %x " 2508 "- mbox cmd %x still active\n", 2509 phba->sli.sli_flag, actcmd); 2510 break; 2511 } 2512 } 2513 } 2514 2515 /** 2516 * lpfc_online - Initialize and bring a HBA online 2517 * @phba: pointer to lpfc hba data structure. 2518 * 2519 * This routine initializes the HBA and brings a HBA online. During this 2520 * process, the management interface is blocked to prevent user space access 2521 * to the HBA interfering with the driver initialization. 2522 * 2523 * Return codes 2524 * 0 - successful 2525 * 1 - failed 2526 **/ 2527 int 2528 lpfc_online(struct lpfc_hba *phba) 2529 { 2530 struct lpfc_vport *vport; 2531 struct lpfc_vport **vports; 2532 int i; 2533 2534 if (!phba) 2535 return 0; 2536 vport = phba->pport; 2537 2538 if (!(vport->fc_flag & FC_OFFLINE_MODE)) 2539 return 0; 2540 2541 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 2542 "0458 Bring Adapter online\n"); 2543 2544 lpfc_block_mgmt_io(phba); 2545 2546 if (!lpfc_sli_queue_setup(phba)) { 2547 lpfc_unblock_mgmt_io(phba); 2548 return 1; 2549 } 2550 2551 if (phba->sli_rev == LPFC_SLI_REV4) { 2552 if (lpfc_sli4_hba_setup(phba)) { /* Initialize SLI4 HBA */ 2553 lpfc_unblock_mgmt_io(phba); 2554 return 1; 2555 } 2556 } else { 2557 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */ 2558 lpfc_unblock_mgmt_io(phba); 2559 return 1; 2560 } 2561 } 2562 2563 vports = lpfc_create_vport_work_array(phba); 2564 if (vports != NULL) 2565 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2566 struct Scsi_Host *shost; 2567 shost = lpfc_shost_from_vport(vports[i]); 2568 spin_lock_irq(shost->host_lock); 2569 vports[i]->fc_flag &= ~FC_OFFLINE_MODE; 2570 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 2571 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 2572 if (phba->sli_rev == LPFC_SLI_REV4) 2573 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI; 2574 spin_unlock_irq(shost->host_lock); 2575 } 2576 lpfc_destroy_vport_work_array(phba, vports); 2577 2578 lpfc_unblock_mgmt_io(phba); 2579 return 0; 2580 } 2581 2582 /** 2583 * lpfc_unblock_mgmt_io - Mark a HBA's management interface to be not blocked 2584 * @phba: pointer to lpfc hba data structure. 2585 * 2586 * This routine marks a HBA's management interface as not blocked. Once the 2587 * HBA's management interface is marked as not blocked, all the user space 2588 * access to the HBA, whether they are from sysfs interface or libdfc 2589 * interface will be allowed. The HBA is set to block the management interface 2590 * when the driver prepares the HBA interface for online or offline and then 2591 * set to unblock the management interface afterwards. 2592 **/ 2593 void 2594 lpfc_unblock_mgmt_io(struct lpfc_hba * phba) 2595 { 2596 unsigned long iflag; 2597 2598 spin_lock_irqsave(&phba->hbalock, iflag); 2599 phba->sli.sli_flag &= ~LPFC_BLOCK_MGMT_IO; 2600 spin_unlock_irqrestore(&phba->hbalock, iflag); 2601 } 2602 2603 /** 2604 * lpfc_offline_prep - Prepare a HBA to be brought offline 2605 * @phba: pointer to lpfc hba data structure. 2606 * 2607 * This routine is invoked to prepare a HBA to be brought offline. It performs 2608 * unregistration login to all the nodes on all vports and flushes the mailbox 2609 * queue to make it ready to be brought offline. 2610 **/ 2611 void 2612 lpfc_offline_prep(struct lpfc_hba * phba) 2613 { 2614 struct lpfc_vport *vport = phba->pport; 2615 struct lpfc_nodelist *ndlp, *next_ndlp; 2616 struct lpfc_vport **vports; 2617 struct Scsi_Host *shost; 2618 int i; 2619 2620 if (vport->fc_flag & FC_OFFLINE_MODE) 2621 return; 2622 2623 lpfc_block_mgmt_io(phba); 2624 2625 lpfc_linkdown(phba); 2626 2627 /* Issue an unreg_login to all nodes on all vports */ 2628 vports = lpfc_create_vport_work_array(phba); 2629 if (vports != NULL) { 2630 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2631 if (vports[i]->load_flag & FC_UNLOADING) 2632 continue; 2633 shost = lpfc_shost_from_vport(vports[i]); 2634 spin_lock_irq(shost->host_lock); 2635 vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED; 2636 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 2637 vports[i]->fc_flag &= ~FC_VFI_REGISTERED; 2638 spin_unlock_irq(shost->host_lock); 2639 2640 shost = lpfc_shost_from_vport(vports[i]); 2641 list_for_each_entry_safe(ndlp, next_ndlp, 2642 &vports[i]->fc_nodes, 2643 nlp_listp) { 2644 if (!NLP_CHK_NODE_ACT(ndlp)) 2645 continue; 2646 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 2647 continue; 2648 if (ndlp->nlp_type & NLP_FABRIC) { 2649 lpfc_disc_state_machine(vports[i], ndlp, 2650 NULL, NLP_EVT_DEVICE_RECOVERY); 2651 lpfc_disc_state_machine(vports[i], ndlp, 2652 NULL, NLP_EVT_DEVICE_RM); 2653 } 2654 spin_lock_irq(shost->host_lock); 2655 ndlp->nlp_flag &= ~NLP_NPR_ADISC; 2656 spin_unlock_irq(shost->host_lock); 2657 lpfc_unreg_rpi(vports[i], ndlp); 2658 } 2659 } 2660 } 2661 lpfc_destroy_vport_work_array(phba, vports); 2662 2663 lpfc_sli_mbox_sys_shutdown(phba); 2664 } 2665 2666 /** 2667 * lpfc_offline - Bring a HBA offline 2668 * @phba: pointer to lpfc hba data structure. 2669 * 2670 * This routine actually brings a HBA offline. It stops all the timers 2671 * associated with the HBA, brings down the SLI layer, and eventually 2672 * marks the HBA as in offline state for the upper layer protocol. 2673 **/ 2674 void 2675 lpfc_offline(struct lpfc_hba *phba) 2676 { 2677 struct Scsi_Host *shost; 2678 struct lpfc_vport **vports; 2679 int i; 2680 2681 if (phba->pport->fc_flag & FC_OFFLINE_MODE) 2682 return; 2683 2684 /* stop port and all timers associated with this hba */ 2685 lpfc_stop_port(phba); 2686 vports = lpfc_create_vport_work_array(phba); 2687 if (vports != NULL) 2688 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) 2689 lpfc_stop_vport_timers(vports[i]); 2690 lpfc_destroy_vport_work_array(phba, vports); 2691 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 2692 "0460 Bring Adapter offline\n"); 2693 /* Bring down the SLI Layer and cleanup. The HBA is offline 2694 now. */ 2695 lpfc_sli_hba_down(phba); 2696 spin_lock_irq(&phba->hbalock); 2697 phba->work_ha = 0; 2698 spin_unlock_irq(&phba->hbalock); 2699 vports = lpfc_create_vport_work_array(phba); 2700 if (vports != NULL) 2701 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) { 2702 shost = lpfc_shost_from_vport(vports[i]); 2703 spin_lock_irq(shost->host_lock); 2704 vports[i]->work_port_events = 0; 2705 vports[i]->fc_flag |= FC_OFFLINE_MODE; 2706 spin_unlock_irq(shost->host_lock); 2707 } 2708 lpfc_destroy_vport_work_array(phba, vports); 2709 } 2710 2711 /** 2712 * lpfc_scsi_buf_update - Update the scsi_buffers that are already allocated. 2713 * @phba: pointer to lpfc hba data structure. 2714 * 2715 * This routine goes through all the scsi buffers in the system and updates the 2716 * Physical XRIs assigned to the SCSI buffer because these may change after any 2717 * firmware reset 2718 * 2719 * Return codes 2720 * 0 - successful (for now, it always returns 0) 2721 **/ 2722 int 2723 lpfc_scsi_buf_update(struct lpfc_hba *phba) 2724 { 2725 struct lpfc_scsi_buf *sb, *sb_next; 2726 2727 spin_lock_irq(&phba->hbalock); 2728 spin_lock(&phba->scsi_buf_list_lock); 2729 list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) 2730 sb->cur_iocbq.sli4_xritag = 2731 phba->sli4_hba.xri_ids[sb->cur_iocbq.sli4_lxritag]; 2732 spin_unlock(&phba->scsi_buf_list_lock); 2733 spin_unlock_irq(&phba->hbalock); 2734 return 0; 2735 } 2736 2737 /** 2738 * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists 2739 * @phba: pointer to lpfc hba data structure. 2740 * 2741 * This routine is to free all the SCSI buffers and IOCBs from the driver 2742 * list back to kernel. It is called from lpfc_pci_remove_one to free 2743 * the internal resources before the device is removed from the system. 2744 * 2745 * Return codes 2746 * 0 - successful (for now, it always returns 0) 2747 **/ 2748 static int 2749 lpfc_scsi_free(struct lpfc_hba *phba) 2750 { 2751 struct lpfc_scsi_buf *sb, *sb_next; 2752 struct lpfc_iocbq *io, *io_next; 2753 2754 spin_lock_irq(&phba->hbalock); 2755 /* Release all the lpfc_scsi_bufs maintained by this host. */ 2756 spin_lock(&phba->scsi_buf_list_lock); 2757 list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) { 2758 list_del(&sb->list); 2759 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data, 2760 sb->dma_handle); 2761 kfree(sb); 2762 phba->total_scsi_bufs--; 2763 } 2764 spin_unlock(&phba->scsi_buf_list_lock); 2765 2766 /* Release all the lpfc_iocbq entries maintained by this host. */ 2767 list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) { 2768 list_del(&io->list); 2769 kfree(io); 2770 phba->total_iocbq_bufs--; 2771 } 2772 2773 spin_unlock_irq(&phba->hbalock); 2774 return 0; 2775 } 2776 2777 /** 2778 * lpfc_create_port - Create an FC port 2779 * @phba: pointer to lpfc hba data structure. 2780 * @instance: a unique integer ID to this FC port. 2781 * @dev: pointer to the device data structure. 2782 * 2783 * This routine creates a FC port for the upper layer protocol. The FC port 2784 * can be created on top of either a physical port or a virtual port provided 2785 * by the HBA. This routine also allocates a SCSI host data structure (shost) 2786 * and associates the FC port created before adding the shost into the SCSI 2787 * layer. 2788 * 2789 * Return codes 2790 * @vport - pointer to the virtual N_Port data structure. 2791 * NULL - port create failed. 2792 **/ 2793 struct lpfc_vport * 2794 lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev) 2795 { 2796 struct lpfc_vport *vport; 2797 struct Scsi_Host *shost; 2798 int error = 0; 2799 2800 if (dev != &phba->pcidev->dev) 2801 shost = scsi_host_alloc(&lpfc_vport_template, 2802 sizeof(struct lpfc_vport)); 2803 else 2804 shost = scsi_host_alloc(&lpfc_template, 2805 sizeof(struct lpfc_vport)); 2806 if (!shost) 2807 goto out; 2808 2809 vport = (struct lpfc_vport *) shost->hostdata; 2810 vport->phba = phba; 2811 vport->load_flag |= FC_LOADING; 2812 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 2813 vport->fc_rscn_flush = 0; 2814 2815 lpfc_get_vport_cfgparam(vport); 2816 shost->unique_id = instance; 2817 shost->max_id = LPFC_MAX_TARGET; 2818 shost->max_lun = vport->cfg_max_luns; 2819 shost->this_id = -1; 2820 shost->max_cmd_len = 16; 2821 if (phba->sli_rev == LPFC_SLI_REV4) { 2822 shost->dma_boundary = 2823 phba->sli4_hba.pc_sli4_params.sge_supp_len-1; 2824 shost->sg_tablesize = phba->cfg_sg_seg_cnt; 2825 } 2826 2827 /* 2828 * Set initial can_queue value since 0 is no longer supported and 2829 * scsi_add_host will fail. This will be adjusted later based on the 2830 * max xri value determined in hba setup. 2831 */ 2832 shost->can_queue = phba->cfg_hba_queue_depth - 10; 2833 if (dev != &phba->pcidev->dev) { 2834 shost->transportt = lpfc_vport_transport_template; 2835 vport->port_type = LPFC_NPIV_PORT; 2836 } else { 2837 shost->transportt = lpfc_transport_template; 2838 vport->port_type = LPFC_PHYSICAL_PORT; 2839 } 2840 2841 /* Initialize all internally managed lists. */ 2842 INIT_LIST_HEAD(&vport->fc_nodes); 2843 INIT_LIST_HEAD(&vport->rcv_buffer_list); 2844 spin_lock_init(&vport->work_port_lock); 2845 2846 init_timer(&vport->fc_disctmo); 2847 vport->fc_disctmo.function = lpfc_disc_timeout; 2848 vport->fc_disctmo.data = (unsigned long)vport; 2849 2850 init_timer(&vport->fc_fdmitmo); 2851 vport->fc_fdmitmo.function = lpfc_fdmi_tmo; 2852 vport->fc_fdmitmo.data = (unsigned long)vport; 2853 2854 init_timer(&vport->els_tmofunc); 2855 vport->els_tmofunc.function = lpfc_els_timeout; 2856 vport->els_tmofunc.data = (unsigned long)vport; 2857 2858 init_timer(&vport->delayed_disc_tmo); 2859 vport->delayed_disc_tmo.function = lpfc_delayed_disc_tmo; 2860 vport->delayed_disc_tmo.data = (unsigned long)vport; 2861 2862 error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev); 2863 if (error) 2864 goto out_put_shost; 2865 2866 spin_lock_irq(&phba->hbalock); 2867 list_add_tail(&vport->listentry, &phba->port_list); 2868 spin_unlock_irq(&phba->hbalock); 2869 return vport; 2870 2871 out_put_shost: 2872 scsi_host_put(shost); 2873 out: 2874 return NULL; 2875 } 2876 2877 /** 2878 * destroy_port - destroy an FC port 2879 * @vport: pointer to an lpfc virtual N_Port data structure. 2880 * 2881 * This routine destroys a FC port from the upper layer protocol. All the 2882 * resources associated with the port are released. 2883 **/ 2884 void 2885 destroy_port(struct lpfc_vport *vport) 2886 { 2887 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2888 struct lpfc_hba *phba = vport->phba; 2889 2890 lpfc_debugfs_terminate(vport); 2891 fc_remove_host(shost); 2892 scsi_remove_host(shost); 2893 2894 spin_lock_irq(&phba->hbalock); 2895 list_del_init(&vport->listentry); 2896 spin_unlock_irq(&phba->hbalock); 2897 2898 lpfc_cleanup(vport); 2899 return; 2900 } 2901 2902 /** 2903 * lpfc_get_instance - Get a unique integer ID 2904 * 2905 * This routine allocates a unique integer ID from lpfc_hba_index pool. It 2906 * uses the kernel idr facility to perform the task. 2907 * 2908 * Return codes: 2909 * instance - a unique integer ID allocated as the new instance. 2910 * -1 - lpfc get instance failed. 2911 **/ 2912 int 2913 lpfc_get_instance(void) 2914 { 2915 int instance = 0; 2916 2917 /* Assign an unused number */ 2918 if (!idr_pre_get(&lpfc_hba_index, GFP_KERNEL)) 2919 return -1; 2920 if (idr_get_new(&lpfc_hba_index, NULL, &instance)) 2921 return -1; 2922 return instance; 2923 } 2924 2925 /** 2926 * lpfc_scan_finished - method for SCSI layer to detect whether scan is done 2927 * @shost: pointer to SCSI host data structure. 2928 * @time: elapsed time of the scan in jiffies. 2929 * 2930 * This routine is called by the SCSI layer with a SCSI host to determine 2931 * whether the scan host is finished. 2932 * 2933 * Note: there is no scan_start function as adapter initialization will have 2934 * asynchronously kicked off the link initialization. 2935 * 2936 * Return codes 2937 * 0 - SCSI host scan is not over yet. 2938 * 1 - SCSI host scan is over. 2939 **/ 2940 int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time) 2941 { 2942 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2943 struct lpfc_hba *phba = vport->phba; 2944 int stat = 0; 2945 2946 spin_lock_irq(shost->host_lock); 2947 2948 if (vport->load_flag & FC_UNLOADING) { 2949 stat = 1; 2950 goto finished; 2951 } 2952 if (time >= 30 * HZ) { 2953 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 2954 "0461 Scanning longer than 30 " 2955 "seconds. Continuing initialization\n"); 2956 stat = 1; 2957 goto finished; 2958 } 2959 if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) { 2960 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 2961 "0465 Link down longer than 15 " 2962 "seconds. Continuing initialization\n"); 2963 stat = 1; 2964 goto finished; 2965 } 2966 2967 if (vport->port_state != LPFC_VPORT_READY) 2968 goto finished; 2969 if (vport->num_disc_nodes || vport->fc_prli_sent) 2970 goto finished; 2971 if (vport->fc_map_cnt == 0 && time < 2 * HZ) 2972 goto finished; 2973 if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0) 2974 goto finished; 2975 2976 stat = 1; 2977 2978 finished: 2979 spin_unlock_irq(shost->host_lock); 2980 return stat; 2981 } 2982 2983 /** 2984 * lpfc_host_attrib_init - Initialize SCSI host attributes on a FC port 2985 * @shost: pointer to SCSI host data structure. 2986 * 2987 * This routine initializes a given SCSI host attributes on a FC port. The 2988 * SCSI host can be either on top of a physical port or a virtual port. 2989 **/ 2990 void lpfc_host_attrib_init(struct Scsi_Host *shost) 2991 { 2992 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 2993 struct lpfc_hba *phba = vport->phba; 2994 /* 2995 * Set fixed host attributes. Must done after lpfc_sli_hba_setup(). 2996 */ 2997 2998 fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn); 2999 fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn); 3000 fc_host_supported_classes(shost) = FC_COS_CLASS3; 3001 3002 memset(fc_host_supported_fc4s(shost), 0, 3003 sizeof(fc_host_supported_fc4s(shost))); 3004 fc_host_supported_fc4s(shost)[2] = 1; 3005 fc_host_supported_fc4s(shost)[7] = 1; 3006 3007 lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost), 3008 sizeof fc_host_symbolic_name(shost)); 3009 3010 fc_host_supported_speeds(shost) = 0; 3011 if (phba->lmt & LMT_16Gb) 3012 fc_host_supported_speeds(shost) |= FC_PORTSPEED_16GBIT; 3013 if (phba->lmt & LMT_10Gb) 3014 fc_host_supported_speeds(shost) |= FC_PORTSPEED_10GBIT; 3015 if (phba->lmt & LMT_8Gb) 3016 fc_host_supported_speeds(shost) |= FC_PORTSPEED_8GBIT; 3017 if (phba->lmt & LMT_4Gb) 3018 fc_host_supported_speeds(shost) |= FC_PORTSPEED_4GBIT; 3019 if (phba->lmt & LMT_2Gb) 3020 fc_host_supported_speeds(shost) |= FC_PORTSPEED_2GBIT; 3021 if (phba->lmt & LMT_1Gb) 3022 fc_host_supported_speeds(shost) |= FC_PORTSPEED_1GBIT; 3023 3024 fc_host_maxframe_size(shost) = 3025 (((uint32_t) vport->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) | 3026 (uint32_t) vport->fc_sparam.cmn.bbRcvSizeLsb; 3027 3028 fc_host_dev_loss_tmo(shost) = vport->cfg_devloss_tmo; 3029 3030 /* This value is also unchanging */ 3031 memset(fc_host_active_fc4s(shost), 0, 3032 sizeof(fc_host_active_fc4s(shost))); 3033 fc_host_active_fc4s(shost)[2] = 1; 3034 fc_host_active_fc4s(shost)[7] = 1; 3035 3036 fc_host_max_npiv_vports(shost) = phba->max_vpi; 3037 spin_lock_irq(shost->host_lock); 3038 vport->load_flag &= ~FC_LOADING; 3039 spin_unlock_irq(shost->host_lock); 3040 } 3041 3042 /** 3043 * lpfc_stop_port_s3 - Stop SLI3 device port 3044 * @phba: pointer to lpfc hba data structure. 3045 * 3046 * This routine is invoked to stop an SLI3 device port, it stops the device 3047 * from generating interrupts and stops the device driver's timers for the 3048 * device. 3049 **/ 3050 static void 3051 lpfc_stop_port_s3(struct lpfc_hba *phba) 3052 { 3053 /* Clear all interrupt enable conditions */ 3054 writel(0, phba->HCregaddr); 3055 readl(phba->HCregaddr); /* flush */ 3056 /* Clear all pending interrupts */ 3057 writel(0xffffffff, phba->HAregaddr); 3058 readl(phba->HAregaddr); /* flush */ 3059 3060 /* Reset some HBA SLI setup states */ 3061 lpfc_stop_hba_timers(phba); 3062 phba->pport->work_port_events = 0; 3063 } 3064 3065 /** 3066 * lpfc_stop_port_s4 - Stop SLI4 device port 3067 * @phba: pointer to lpfc hba data structure. 3068 * 3069 * This routine is invoked to stop an SLI4 device port, it stops the device 3070 * from generating interrupts and stops the device driver's timers for the 3071 * device. 3072 **/ 3073 static void 3074 lpfc_stop_port_s4(struct lpfc_hba *phba) 3075 { 3076 /* Reset some HBA SLI4 setup states */ 3077 lpfc_stop_hba_timers(phba); 3078 phba->pport->work_port_events = 0; 3079 phba->sli4_hba.intr_enable = 0; 3080 } 3081 3082 /** 3083 * lpfc_stop_port - Wrapper function for stopping hba port 3084 * @phba: Pointer to HBA context object. 3085 * 3086 * This routine wraps the actual SLI3 or SLI4 hba stop port routine from 3087 * the API jump table function pointer from the lpfc_hba struct. 3088 **/ 3089 void 3090 lpfc_stop_port(struct lpfc_hba *phba) 3091 { 3092 phba->lpfc_stop_port(phba); 3093 } 3094 3095 /** 3096 * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer 3097 * @phba: Pointer to hba for which this call is being executed. 3098 * 3099 * This routine starts the timer waiting for the FCF rediscovery to complete. 3100 **/ 3101 void 3102 lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba) 3103 { 3104 unsigned long fcf_redisc_wait_tmo = 3105 (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO)); 3106 /* Start fcf rediscovery wait period timer */ 3107 mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo); 3108 spin_lock_irq(&phba->hbalock); 3109 /* Allow action to new fcf asynchronous event */ 3110 phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE); 3111 /* Mark the FCF rediscovery pending state */ 3112 phba->fcf.fcf_flag |= FCF_REDISC_PEND; 3113 spin_unlock_irq(&phba->hbalock); 3114 } 3115 3116 /** 3117 * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout 3118 * @ptr: Map to lpfc_hba data structure pointer. 3119 * 3120 * This routine is invoked when waiting for FCF table rediscover has been 3121 * timed out. If new FCF record(s) has (have) been discovered during the 3122 * wait period, a new FCF event shall be added to the FCOE async event 3123 * list, and then worker thread shall be waked up for processing from the 3124 * worker thread context. 3125 **/ 3126 void 3127 lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr) 3128 { 3129 struct lpfc_hba *phba = (struct lpfc_hba *)ptr; 3130 3131 /* Don't send FCF rediscovery event if timer cancelled */ 3132 spin_lock_irq(&phba->hbalock); 3133 if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) { 3134 spin_unlock_irq(&phba->hbalock); 3135 return; 3136 } 3137 /* Clear FCF rediscovery timer pending flag */ 3138 phba->fcf.fcf_flag &= ~FCF_REDISC_PEND; 3139 /* FCF rediscovery event to worker thread */ 3140 phba->fcf.fcf_flag |= FCF_REDISC_EVT; 3141 spin_unlock_irq(&phba->hbalock); 3142 lpfc_printf_log(phba, KERN_INFO, LOG_FIP, 3143 "2776 FCF rediscover quiescent timer expired\n"); 3144 /* wake up worker thread */ 3145 lpfc_worker_wake_up(phba); 3146 } 3147 3148 /** 3149 * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code 3150 * @phba: pointer to lpfc hba data structure. 3151 * @acqe_link: pointer to the async link completion queue entry. 3152 * 3153 * This routine is to parse the SLI4 link-attention link fault code and 3154 * translate it into the base driver's read link attention mailbox command 3155 * status. 3156 * 3157 * Return: Link-attention status in terms of base driver's coding. 3158 **/ 3159 static uint16_t 3160 lpfc_sli4_parse_latt_fault(struct lpfc_hba *phba, 3161 struct lpfc_acqe_link *acqe_link) 3162 { 3163 uint16_t latt_fault; 3164 3165 switch (bf_get(lpfc_acqe_link_fault, acqe_link)) { 3166 case LPFC_ASYNC_LINK_FAULT_NONE: 3167 case LPFC_ASYNC_LINK_FAULT_LOCAL: 3168 case LPFC_ASYNC_LINK_FAULT_REMOTE: 3169 latt_fault = 0; 3170 break; 3171 default: 3172 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3173 "0398 Invalid link fault code: x%x\n", 3174 bf_get(lpfc_acqe_link_fault, acqe_link)); 3175 latt_fault = MBXERR_ERROR; 3176 break; 3177 } 3178 return latt_fault; 3179 } 3180 3181 /** 3182 * lpfc_sli4_parse_latt_type - Parse sli4 link attention type 3183 * @phba: pointer to lpfc hba data structure. 3184 * @acqe_link: pointer to the async link completion queue entry. 3185 * 3186 * This routine is to parse the SLI4 link attention type and translate it 3187 * into the base driver's link attention type coding. 3188 * 3189 * Return: Link attention type in terms of base driver's coding. 3190 **/ 3191 static uint8_t 3192 lpfc_sli4_parse_latt_type(struct lpfc_hba *phba, 3193 struct lpfc_acqe_link *acqe_link) 3194 { 3195 uint8_t att_type; 3196 3197 switch (bf_get(lpfc_acqe_link_status, acqe_link)) { 3198 case LPFC_ASYNC_LINK_STATUS_DOWN: 3199 case LPFC_ASYNC_LINK_STATUS_LOGICAL_DOWN: 3200 att_type = LPFC_ATT_LINK_DOWN; 3201 break; 3202 case LPFC_ASYNC_LINK_STATUS_UP: 3203 /* Ignore physical link up events - wait for logical link up */ 3204 att_type = LPFC_ATT_RESERVED; 3205 break; 3206 case LPFC_ASYNC_LINK_STATUS_LOGICAL_UP: 3207 att_type = LPFC_ATT_LINK_UP; 3208 break; 3209 default: 3210 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3211 "0399 Invalid link attention type: x%x\n", 3212 bf_get(lpfc_acqe_link_status, acqe_link)); 3213 att_type = LPFC_ATT_RESERVED; 3214 break; 3215 } 3216 return att_type; 3217 } 3218 3219 /** 3220 * lpfc_sli4_parse_latt_link_speed - Parse sli4 link-attention link speed 3221 * @phba: pointer to lpfc hba data structure. 3222 * @acqe_link: pointer to the async link completion queue entry. 3223 * 3224 * This routine is to parse the SLI4 link-attention link speed and translate 3225 * it into the base driver's link-attention link speed coding. 3226 * 3227 * Return: Link-attention link speed in terms of base driver's coding. 3228 **/ 3229 static uint8_t 3230 lpfc_sli4_parse_latt_link_speed(struct lpfc_hba *phba, 3231 struct lpfc_acqe_link *acqe_link) 3232 { 3233 uint8_t link_speed; 3234 3235 switch (bf_get(lpfc_acqe_link_speed, acqe_link)) { 3236 case LPFC_ASYNC_LINK_SPEED_ZERO: 3237 case LPFC_ASYNC_LINK_SPEED_10MBPS: 3238 case LPFC_ASYNC_LINK_SPEED_100MBPS: 3239 link_speed = LPFC_LINK_SPEED_UNKNOWN; 3240 break; 3241 case LPFC_ASYNC_LINK_SPEED_1GBPS: 3242 link_speed = LPFC_LINK_SPEED_1GHZ; 3243 break; 3244 case LPFC_ASYNC_LINK_SPEED_10GBPS: 3245 link_speed = LPFC_LINK_SPEED_10GHZ; 3246 break; 3247 default: 3248 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 3249 "0483 Invalid link-attention link speed: x%x\n", 3250 bf_get(lpfc_acqe_link_speed, acqe_link)); 3251 link_speed = LPFC_LINK_SPEED_UNKNOWN; 3252 break; 3253 } 3254 return link_speed; 3255 } 3256 3257 /** 3258 * lpfc_sli4_async_link_evt - Process the asynchronous FCoE link event 3259 * @phba: pointer to lpfc hba data structure. 3260 * @acqe_link: pointer to the async link completion queue entry. 3261 * 3262 * This routine is to handle the SLI4 asynchronous FCoE link event. 3263 **/ 3264 static void 3265 lpfc_sli4_async_link_evt(struct lpfc_hba *phba, 3266 struct lpfc_acqe_link *acqe_link) 3267 { 3268 struct lpfc_dmabuf *mp; 3269 LPFC_MBOXQ_t *pmb; 3270 MAILBOX_t *mb; 3271 struct lpfc_mbx_read_top *la; 3272 uint8_t att_type; 3273 int rc; 3274 3275 att_type = lpfc_sli4_parse_latt_type(phba, acqe_link); 3276 if (att_type != LPFC_ATT_LINK_DOWN && att_type != LPFC_ATT_LINK_UP) 3277 return; 3278 phba->fcoe_eventtag = acqe_link->event_tag; 3279 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 3280 if (!pmb) { 3281 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3282 "0395 The mboxq allocation failed\n"); 3283 return; 3284 } 3285 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 3286 if (!mp) { 3287 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3288 "0396 The lpfc_dmabuf allocation failed\n"); 3289 goto out_free_pmb; 3290 } 3291 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); 3292 if (!mp->virt) { 3293 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3294 "0397 The mbuf allocation failed\n"); 3295 goto out_free_dmabuf; 3296 } 3297 3298 /* Cleanup any outstanding ELS commands */ 3299 lpfc_els_flush_all_cmd(phba); 3300 3301 /* Block ELS IOCBs until we have done process link event */ 3302 phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT; 3303 3304 /* Update link event statistics */ 3305 phba->sli.slistat.link_event++; 3306 3307 /* Create lpfc_handle_latt mailbox command from link ACQE */ 3308 lpfc_read_topology(phba, pmb, mp); 3309 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology; 3310 pmb->vport = phba->pport; 3311 3312 /* Keep the link status for extra SLI4 state machine reference */ 3313 phba->sli4_hba.link_state.speed = 3314 bf_get(lpfc_acqe_link_speed, acqe_link); 3315 phba->sli4_hba.link_state.duplex = 3316 bf_get(lpfc_acqe_link_duplex, acqe_link); 3317 phba->sli4_hba.link_state.status = 3318 bf_get(lpfc_acqe_link_status, acqe_link); 3319 phba->sli4_hba.link_state.type = 3320 bf_get(lpfc_acqe_link_type, acqe_link); 3321 phba->sli4_hba.link_state.number = 3322 bf_get(lpfc_acqe_link_number, acqe_link); 3323 phba->sli4_hba.link_state.fault = 3324 bf_get(lpfc_acqe_link_fault, acqe_link); 3325 phba->sli4_hba.link_state.logical_speed = 3326 bf_get(lpfc_acqe_logical_link_speed, acqe_link); 3327 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 3328 "2900 Async FC/FCoE Link event - Speed:%dGBit " 3329 "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d " 3330 "Logical speed:%dMbps Fault:%d\n", 3331 phba->sli4_hba.link_state.speed, 3332 phba->sli4_hba.link_state.topology, 3333 phba->sli4_hba.link_state.status, 3334 phba->sli4_hba.link_state.type, 3335 phba->sli4_hba.link_state.number, 3336 phba->sli4_hba.link_state.logical_speed * 10, 3337 phba->sli4_hba.link_state.fault); 3338 /* 3339 * For FC Mode: issue the READ_TOPOLOGY mailbox command to fetch 3340 * topology info. Note: Optional for non FC-AL ports. 3341 */ 3342 if (!(phba->hba_flag & HBA_FCOE_MODE)) { 3343 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 3344 if (rc == MBX_NOT_FINISHED) 3345 goto out_free_dmabuf; 3346 return; 3347 } 3348 /* 3349 * For FCoE Mode: fill in all the topology information we need and call 3350 * the READ_TOPOLOGY completion routine to continue without actually 3351 * sending the READ_TOPOLOGY mailbox command to the port. 3352 */ 3353 /* Parse and translate status field */ 3354 mb = &pmb->u.mb; 3355 mb->mbxStatus = lpfc_sli4_parse_latt_fault(phba, acqe_link); 3356 3357 /* Parse and translate link attention fields */ 3358 la = (struct lpfc_mbx_read_top *) &pmb->u.mb.un.varReadTop; 3359 la->eventTag = acqe_link->event_tag; 3360 bf_set(lpfc_mbx_read_top_att_type, la, att_type); 3361 bf_set(lpfc_mbx_read_top_link_spd, la, 3362 lpfc_sli4_parse_latt_link_speed(phba, acqe_link)); 3363 3364 /* Fake the the following irrelvant fields */ 3365 bf_set(lpfc_mbx_read_top_topology, la, LPFC_TOPOLOGY_PT_PT); 3366 bf_set(lpfc_mbx_read_top_alpa_granted, la, 0); 3367 bf_set(lpfc_mbx_read_top_il, la, 0); 3368 bf_set(lpfc_mbx_read_top_pb, la, 0); 3369 bf_set(lpfc_mbx_read_top_fa, la, 0); 3370 bf_set(lpfc_mbx_read_top_mm, la, 0); 3371 3372 /* Invoke the lpfc_handle_latt mailbox command callback function */ 3373 lpfc_mbx_cmpl_read_topology(phba, pmb); 3374 3375 return; 3376 3377 out_free_dmabuf: 3378 kfree(mp); 3379 out_free_pmb: 3380 mempool_free(pmb, phba->mbox_mem_pool); 3381 } 3382 3383 /** 3384 * lpfc_sli4_async_fc_evt - Process the asynchronous FC link event 3385 * @phba: pointer to lpfc hba data structure. 3386 * @acqe_fc: pointer to the async fc completion queue entry. 3387 * 3388 * This routine is to handle the SLI4 asynchronous FC event. It will simply log 3389 * that the event was received and then issue a read_topology mailbox command so 3390 * that the rest of the driver will treat it the same as SLI3. 3391 **/ 3392 static void 3393 lpfc_sli4_async_fc_evt(struct lpfc_hba *phba, struct lpfc_acqe_fc_la *acqe_fc) 3394 { 3395 struct lpfc_dmabuf *mp; 3396 LPFC_MBOXQ_t *pmb; 3397 int rc; 3398 3399 if (bf_get(lpfc_trailer_type, acqe_fc) != 3400 LPFC_FC_LA_EVENT_TYPE_FC_LINK) { 3401 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3402 "2895 Non FC link Event detected.(%d)\n", 3403 bf_get(lpfc_trailer_type, acqe_fc)); 3404 return; 3405 } 3406 /* Keep the link status for extra SLI4 state machine reference */ 3407 phba->sli4_hba.link_state.speed = 3408 bf_get(lpfc_acqe_fc_la_speed, acqe_fc); 3409 phba->sli4_hba.link_state.duplex = LPFC_ASYNC_LINK_DUPLEX_FULL; 3410 phba->sli4_hba.link_state.topology = 3411 bf_get(lpfc_acqe_fc_la_topology, acqe_fc); 3412 phba->sli4_hba.link_state.status = 3413 bf_get(lpfc_acqe_fc_la_att_type, acqe_fc); 3414 phba->sli4_hba.link_state.type = 3415 bf_get(lpfc_acqe_fc_la_port_type, acqe_fc); 3416 phba->sli4_hba.link_state.number = 3417 bf_get(lpfc_acqe_fc_la_port_number, acqe_fc); 3418 phba->sli4_hba.link_state.fault = 3419 bf_get(lpfc_acqe_link_fault, acqe_fc); 3420 phba->sli4_hba.link_state.logical_speed = 3421 bf_get(lpfc_acqe_fc_la_llink_spd, acqe_fc); 3422 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 3423 "2896 Async FC event - Speed:%dGBaud Topology:x%x " 3424 "LA Type:x%x Port Type:%d Port Number:%d Logical speed:" 3425 "%dMbps Fault:%d\n", 3426 phba->sli4_hba.link_state.speed, 3427 phba->sli4_hba.link_state.topology, 3428 phba->sli4_hba.link_state.status, 3429 phba->sli4_hba.link_state.type, 3430 phba->sli4_hba.link_state.number, 3431 phba->sli4_hba.link_state.logical_speed * 10, 3432 phba->sli4_hba.link_state.fault); 3433 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 3434 if (!pmb) { 3435 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3436 "2897 The mboxq allocation failed\n"); 3437 return; 3438 } 3439 mp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 3440 if (!mp) { 3441 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3442 "2898 The lpfc_dmabuf allocation failed\n"); 3443 goto out_free_pmb; 3444 } 3445 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys); 3446 if (!mp->virt) { 3447 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3448 "2899 The mbuf allocation failed\n"); 3449 goto out_free_dmabuf; 3450 } 3451 3452 /* Cleanup any outstanding ELS commands */ 3453 lpfc_els_flush_all_cmd(phba); 3454 3455 /* Block ELS IOCBs until we have done process link event */ 3456 phba->sli.ring[LPFC_ELS_RING].flag |= LPFC_STOP_IOCB_EVENT; 3457 3458 /* Update link event statistics */ 3459 phba->sli.slistat.link_event++; 3460 3461 /* Create lpfc_handle_latt mailbox command from link ACQE */ 3462 lpfc_read_topology(phba, pmb, mp); 3463 pmb->mbox_cmpl = lpfc_mbx_cmpl_read_topology; 3464 pmb->vport = phba->pport; 3465 3466 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT); 3467 if (rc == MBX_NOT_FINISHED) 3468 goto out_free_dmabuf; 3469 return; 3470 3471 out_free_dmabuf: 3472 kfree(mp); 3473 out_free_pmb: 3474 mempool_free(pmb, phba->mbox_mem_pool); 3475 } 3476 3477 /** 3478 * lpfc_sli4_async_sli_evt - Process the asynchronous SLI link event 3479 * @phba: pointer to lpfc hba data structure. 3480 * @acqe_fc: pointer to the async SLI completion queue entry. 3481 * 3482 * This routine is to handle the SLI4 asynchronous SLI events. 3483 **/ 3484 static void 3485 lpfc_sli4_async_sli_evt(struct lpfc_hba *phba, struct lpfc_acqe_sli *acqe_sli) 3486 { 3487 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 3488 "2901 Async SLI event - Event Data1:x%08x Event Data2:" 3489 "x%08x SLI Event Type:%d", 3490 acqe_sli->event_data1, acqe_sli->event_data2, 3491 bf_get(lpfc_trailer_type, acqe_sli)); 3492 return; 3493 } 3494 3495 /** 3496 * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport 3497 * @vport: pointer to vport data structure. 3498 * 3499 * This routine is to perform Clear Virtual Link (CVL) on a vport in 3500 * response to a CVL event. 3501 * 3502 * Return the pointer to the ndlp with the vport if successful, otherwise 3503 * return NULL. 3504 **/ 3505 static struct lpfc_nodelist * 3506 lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport) 3507 { 3508 struct lpfc_nodelist *ndlp; 3509 struct Scsi_Host *shost; 3510 struct lpfc_hba *phba; 3511 3512 if (!vport) 3513 return NULL; 3514 phba = vport->phba; 3515 if (!phba) 3516 return NULL; 3517 ndlp = lpfc_findnode_did(vport, Fabric_DID); 3518 if (!ndlp) { 3519 /* Cannot find existing Fabric ndlp, so allocate a new one */ 3520 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 3521 if (!ndlp) 3522 return 0; 3523 lpfc_nlp_init(vport, ndlp, Fabric_DID); 3524 /* Set the node type */ 3525 ndlp->nlp_type |= NLP_FABRIC; 3526 /* Put ndlp onto node list */ 3527 lpfc_enqueue_node(vport, ndlp); 3528 } else if (!NLP_CHK_NODE_ACT(ndlp)) { 3529 /* re-setup ndlp without removing from node list */ 3530 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_UNUSED_NODE); 3531 if (!ndlp) 3532 return 0; 3533 } 3534 if ((phba->pport->port_state < LPFC_FLOGI) && 3535 (phba->pport->port_state != LPFC_VPORT_FAILED)) 3536 return NULL; 3537 /* If virtual link is not yet instantiated ignore CVL */ 3538 if ((vport != phba->pport) && (vport->port_state < LPFC_FDISC) 3539 && (vport->port_state != LPFC_VPORT_FAILED)) 3540 return NULL; 3541 shost = lpfc_shost_from_vport(vport); 3542 if (!shost) 3543 return NULL; 3544 lpfc_linkdown_port(vport); 3545 lpfc_cleanup_pending_mbox(vport); 3546 spin_lock_irq(shost->host_lock); 3547 vport->fc_flag |= FC_VPORT_CVL_RCVD; 3548 spin_unlock_irq(shost->host_lock); 3549 3550 return ndlp; 3551 } 3552 3553 /** 3554 * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports 3555 * @vport: pointer to lpfc hba data structure. 3556 * 3557 * This routine is to perform Clear Virtual Link (CVL) on all vports in 3558 * response to a FCF dead event. 3559 **/ 3560 static void 3561 lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba) 3562 { 3563 struct lpfc_vport **vports; 3564 int i; 3565 3566 vports = lpfc_create_vport_work_array(phba); 3567 if (vports) 3568 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) 3569 lpfc_sli4_perform_vport_cvl(vports[i]); 3570 lpfc_destroy_vport_work_array(phba, vports); 3571 } 3572 3573 /** 3574 * lpfc_sli4_async_fip_evt - Process the asynchronous FCoE FIP event 3575 * @phba: pointer to lpfc hba data structure. 3576 * @acqe_link: pointer to the async fcoe completion queue entry. 3577 * 3578 * This routine is to handle the SLI4 asynchronous fcoe event. 3579 **/ 3580 static void 3581 lpfc_sli4_async_fip_evt(struct lpfc_hba *phba, 3582 struct lpfc_acqe_fip *acqe_fip) 3583 { 3584 uint8_t event_type = bf_get(lpfc_trailer_type, acqe_fip); 3585 int rc; 3586 struct lpfc_vport *vport; 3587 struct lpfc_nodelist *ndlp; 3588 struct Scsi_Host *shost; 3589 int active_vlink_present; 3590 struct lpfc_vport **vports; 3591 int i; 3592 3593 phba->fc_eventTag = acqe_fip->event_tag; 3594 phba->fcoe_eventtag = acqe_fip->event_tag; 3595 switch (event_type) { 3596 case LPFC_FIP_EVENT_TYPE_NEW_FCF: 3597 case LPFC_FIP_EVENT_TYPE_FCF_PARAM_MOD: 3598 if (event_type == LPFC_FIP_EVENT_TYPE_NEW_FCF) 3599 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | 3600 LOG_DISCOVERY, 3601 "2546 New FCF event, evt_tag:x%x, " 3602 "index:x%x\n", 3603 acqe_fip->event_tag, 3604 acqe_fip->index); 3605 else 3606 lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | 3607 LOG_DISCOVERY, 3608 "2788 FCF param modified event, " 3609 "evt_tag:x%x, index:x%x\n", 3610 acqe_fip->event_tag, 3611 acqe_fip->index); 3612 if (phba->fcf.fcf_flag & FCF_DISCOVERY) { 3613 /* 3614 * During period of FCF discovery, read the FCF 3615 * table record indexed by the event to update 3616 * FCF roundrobin failover eligible FCF bmask. 3617 */ 3618 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | 3619 LOG_DISCOVERY, 3620 "2779 Read FCF (x%x) for updating " 3621 "roundrobin FCF failover bmask\n", 3622 acqe_fip->index); 3623 rc = lpfc_sli4_read_fcf_rec(phba, acqe_fip->index); 3624 } 3625 3626 /* If the FCF discovery is in progress, do nothing. */ 3627 spin_lock_irq(&phba->hbalock); 3628 if (phba->hba_flag & FCF_TS_INPROG) { 3629 spin_unlock_irq(&phba->hbalock); 3630 break; 3631 } 3632 /* If fast FCF failover rescan event is pending, do nothing */ 3633 if (phba->fcf.fcf_flag & FCF_REDISC_EVT) { 3634 spin_unlock_irq(&phba->hbalock); 3635 break; 3636 } 3637 3638 /* If the FCF has been in discovered state, do nothing. */ 3639 if (phba->fcf.fcf_flag & FCF_SCAN_DONE) { 3640 spin_unlock_irq(&phba->hbalock); 3641 break; 3642 } 3643 spin_unlock_irq(&phba->hbalock); 3644 3645 /* Otherwise, scan the entire FCF table and re-discover SAN */ 3646 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY, 3647 "2770 Start FCF table scan per async FCF " 3648 "event, evt_tag:x%x, index:x%x\n", 3649 acqe_fip->event_tag, acqe_fip->index); 3650 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, 3651 LPFC_FCOE_FCF_GET_FIRST); 3652 if (rc) 3653 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY, 3654 "2547 Issue FCF scan read FCF mailbox " 3655 "command failed (x%x)\n", rc); 3656 break; 3657 3658 case LPFC_FIP_EVENT_TYPE_FCF_TABLE_FULL: 3659 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3660 "2548 FCF Table full count 0x%x tag 0x%x\n", 3661 bf_get(lpfc_acqe_fip_fcf_count, acqe_fip), 3662 acqe_fip->event_tag); 3663 break; 3664 3665 case LPFC_FIP_EVENT_TYPE_FCF_DEAD: 3666 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY, 3667 "2549 FCF (x%x) disconnected from network, " 3668 "tag:x%x\n", acqe_fip->index, acqe_fip->event_tag); 3669 /* 3670 * If we are in the middle of FCF failover process, clear 3671 * the corresponding FCF bit in the roundrobin bitmap. 3672 */ 3673 spin_lock_irq(&phba->hbalock); 3674 if (phba->fcf.fcf_flag & FCF_DISCOVERY) { 3675 spin_unlock_irq(&phba->hbalock); 3676 /* Update FLOGI FCF failover eligible FCF bmask */ 3677 lpfc_sli4_fcf_rr_index_clear(phba, acqe_fip->index); 3678 break; 3679 } 3680 spin_unlock_irq(&phba->hbalock); 3681 3682 /* If the event is not for currently used fcf do nothing */ 3683 if (phba->fcf.current_rec.fcf_indx != acqe_fip->index) 3684 break; 3685 3686 /* 3687 * Otherwise, request the port to rediscover the entire FCF 3688 * table for a fast recovery from case that the current FCF 3689 * is no longer valid as we are not in the middle of FCF 3690 * failover process already. 3691 */ 3692 spin_lock_irq(&phba->hbalock); 3693 /* Mark the fast failover process in progress */ 3694 phba->fcf.fcf_flag |= FCF_DEAD_DISC; 3695 spin_unlock_irq(&phba->hbalock); 3696 3697 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY, 3698 "2771 Start FCF fast failover process due to " 3699 "FCF DEAD event: evt_tag:x%x, fcf_index:x%x " 3700 "\n", acqe_fip->event_tag, acqe_fip->index); 3701 rc = lpfc_sli4_redisc_fcf_table(phba); 3702 if (rc) { 3703 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | 3704 LOG_DISCOVERY, 3705 "2772 Issue FCF rediscover mabilbox " 3706 "command failed, fail through to FCF " 3707 "dead event\n"); 3708 spin_lock_irq(&phba->hbalock); 3709 phba->fcf.fcf_flag &= ~FCF_DEAD_DISC; 3710 spin_unlock_irq(&phba->hbalock); 3711 /* 3712 * Last resort will fail over by treating this 3713 * as a link down to FCF registration. 3714 */ 3715 lpfc_sli4_fcf_dead_failthrough(phba); 3716 } else { 3717 /* Reset FCF roundrobin bmask for new discovery */ 3718 lpfc_sli4_clear_fcf_rr_bmask(phba); 3719 /* 3720 * Handling fast FCF failover to a DEAD FCF event is 3721 * considered equalivant to receiving CVL to all vports. 3722 */ 3723 lpfc_sli4_perform_all_vport_cvl(phba); 3724 } 3725 break; 3726 case LPFC_FIP_EVENT_TYPE_CVL: 3727 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY, 3728 "2718 Clear Virtual Link Received for VPI 0x%x" 3729 " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag); 3730 3731 vport = lpfc_find_vport_by_vpid(phba, 3732 acqe_fip->index); 3733 ndlp = lpfc_sli4_perform_vport_cvl(vport); 3734 if (!ndlp) 3735 break; 3736 active_vlink_present = 0; 3737 3738 vports = lpfc_create_vport_work_array(phba); 3739 if (vports) { 3740 for (i = 0; i <= phba->max_vports && vports[i] != NULL; 3741 i++) { 3742 if ((!(vports[i]->fc_flag & 3743 FC_VPORT_CVL_RCVD)) && 3744 (vports[i]->port_state > LPFC_FDISC)) { 3745 active_vlink_present = 1; 3746 break; 3747 } 3748 } 3749 lpfc_destroy_vport_work_array(phba, vports); 3750 } 3751 3752 if (active_vlink_present) { 3753 /* 3754 * If there are other active VLinks present, 3755 * re-instantiate the Vlink using FDISC. 3756 */ 3757 mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ); 3758 shost = lpfc_shost_from_vport(vport); 3759 spin_lock_irq(shost->host_lock); 3760 ndlp->nlp_flag |= NLP_DELAY_TMO; 3761 spin_unlock_irq(shost->host_lock); 3762 ndlp->nlp_last_elscmd = ELS_CMD_FDISC; 3763 vport->port_state = LPFC_FDISC; 3764 } else { 3765 /* 3766 * Otherwise, we request port to rediscover 3767 * the entire FCF table for a fast recovery 3768 * from possible case that the current FCF 3769 * is no longer valid if we are not already 3770 * in the FCF failover process. 3771 */ 3772 spin_lock_irq(&phba->hbalock); 3773 if (phba->fcf.fcf_flag & FCF_DISCOVERY) { 3774 spin_unlock_irq(&phba->hbalock); 3775 break; 3776 } 3777 /* Mark the fast failover process in progress */ 3778 phba->fcf.fcf_flag |= FCF_ACVL_DISC; 3779 spin_unlock_irq(&phba->hbalock); 3780 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | 3781 LOG_DISCOVERY, 3782 "2773 Start FCF failover per CVL, " 3783 "evt_tag:x%x\n", acqe_fip->event_tag); 3784 rc = lpfc_sli4_redisc_fcf_table(phba); 3785 if (rc) { 3786 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | 3787 LOG_DISCOVERY, 3788 "2774 Issue FCF rediscover " 3789 "mabilbox command failed, " 3790 "through to CVL event\n"); 3791 spin_lock_irq(&phba->hbalock); 3792 phba->fcf.fcf_flag &= ~FCF_ACVL_DISC; 3793 spin_unlock_irq(&phba->hbalock); 3794 /* 3795 * Last resort will be re-try on the 3796 * the current registered FCF entry. 3797 */ 3798 lpfc_retry_pport_discovery(phba); 3799 } else 3800 /* 3801 * Reset FCF roundrobin bmask for new 3802 * discovery. 3803 */ 3804 lpfc_sli4_clear_fcf_rr_bmask(phba); 3805 } 3806 break; 3807 default: 3808 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3809 "0288 Unknown FCoE event type 0x%x event tag " 3810 "0x%x\n", event_type, acqe_fip->event_tag); 3811 break; 3812 } 3813 } 3814 3815 /** 3816 * lpfc_sli4_async_dcbx_evt - Process the asynchronous dcbx event 3817 * @phba: pointer to lpfc hba data structure. 3818 * @acqe_link: pointer to the async dcbx completion queue entry. 3819 * 3820 * This routine is to handle the SLI4 asynchronous dcbx event. 3821 **/ 3822 static void 3823 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba, 3824 struct lpfc_acqe_dcbx *acqe_dcbx) 3825 { 3826 phba->fc_eventTag = acqe_dcbx->event_tag; 3827 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3828 "0290 The SLI4 DCBX asynchronous event is not " 3829 "handled yet\n"); 3830 } 3831 3832 /** 3833 * lpfc_sli4_async_grp5_evt - Process the asynchronous group5 event 3834 * @phba: pointer to lpfc hba data structure. 3835 * @acqe_link: pointer to the async grp5 completion queue entry. 3836 * 3837 * This routine is to handle the SLI4 asynchronous grp5 event. A grp5 event 3838 * is an asynchronous notified of a logical link speed change. The Port 3839 * reports the logical link speed in units of 10Mbps. 3840 **/ 3841 static void 3842 lpfc_sli4_async_grp5_evt(struct lpfc_hba *phba, 3843 struct lpfc_acqe_grp5 *acqe_grp5) 3844 { 3845 uint16_t prev_ll_spd; 3846 3847 phba->fc_eventTag = acqe_grp5->event_tag; 3848 phba->fcoe_eventtag = acqe_grp5->event_tag; 3849 prev_ll_spd = phba->sli4_hba.link_state.logical_speed; 3850 phba->sli4_hba.link_state.logical_speed = 3851 (bf_get(lpfc_acqe_grp5_llink_spd, acqe_grp5)); 3852 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 3853 "2789 GRP5 Async Event: Updating logical link speed " 3854 "from %dMbps to %dMbps\n", (prev_ll_spd * 10), 3855 (phba->sli4_hba.link_state.logical_speed*10)); 3856 } 3857 3858 /** 3859 * lpfc_sli4_async_event_proc - Process all the pending asynchronous event 3860 * @phba: pointer to lpfc hba data structure. 3861 * 3862 * This routine is invoked by the worker thread to process all the pending 3863 * SLI4 asynchronous events. 3864 **/ 3865 void lpfc_sli4_async_event_proc(struct lpfc_hba *phba) 3866 { 3867 struct lpfc_cq_event *cq_event; 3868 3869 /* First, declare the async event has been handled */ 3870 spin_lock_irq(&phba->hbalock); 3871 phba->hba_flag &= ~ASYNC_EVENT; 3872 spin_unlock_irq(&phba->hbalock); 3873 /* Now, handle all the async events */ 3874 while (!list_empty(&phba->sli4_hba.sp_asynce_work_queue)) { 3875 /* Get the first event from the head of the event queue */ 3876 spin_lock_irq(&phba->hbalock); 3877 list_remove_head(&phba->sli4_hba.sp_asynce_work_queue, 3878 cq_event, struct lpfc_cq_event, list); 3879 spin_unlock_irq(&phba->hbalock); 3880 /* Process the asynchronous event */ 3881 switch (bf_get(lpfc_trailer_code, &cq_event->cqe.mcqe_cmpl)) { 3882 case LPFC_TRAILER_CODE_LINK: 3883 lpfc_sli4_async_link_evt(phba, 3884 &cq_event->cqe.acqe_link); 3885 break; 3886 case LPFC_TRAILER_CODE_FCOE: 3887 lpfc_sli4_async_fip_evt(phba, &cq_event->cqe.acqe_fip); 3888 break; 3889 case LPFC_TRAILER_CODE_DCBX: 3890 lpfc_sli4_async_dcbx_evt(phba, 3891 &cq_event->cqe.acqe_dcbx); 3892 break; 3893 case LPFC_TRAILER_CODE_GRP5: 3894 lpfc_sli4_async_grp5_evt(phba, 3895 &cq_event->cqe.acqe_grp5); 3896 break; 3897 case LPFC_TRAILER_CODE_FC: 3898 lpfc_sli4_async_fc_evt(phba, &cq_event->cqe.acqe_fc); 3899 break; 3900 case LPFC_TRAILER_CODE_SLI: 3901 lpfc_sli4_async_sli_evt(phba, &cq_event->cqe.acqe_sli); 3902 break; 3903 default: 3904 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 3905 "1804 Invalid asynchrous event code: " 3906 "x%x\n", bf_get(lpfc_trailer_code, 3907 &cq_event->cqe.mcqe_cmpl)); 3908 break; 3909 } 3910 /* Free the completion event processed to the free pool */ 3911 lpfc_sli4_cq_event_release(phba, cq_event); 3912 } 3913 } 3914 3915 /** 3916 * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event 3917 * @phba: pointer to lpfc hba data structure. 3918 * 3919 * This routine is invoked by the worker thread to process FCF table 3920 * rediscovery pending completion event. 3921 **/ 3922 void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba) 3923 { 3924 int rc; 3925 3926 spin_lock_irq(&phba->hbalock); 3927 /* Clear FCF rediscovery timeout event */ 3928 phba->fcf.fcf_flag &= ~FCF_REDISC_EVT; 3929 /* Clear driver fast failover FCF record flag */ 3930 phba->fcf.failover_rec.flag = 0; 3931 /* Set state for FCF fast failover */ 3932 phba->fcf.fcf_flag |= FCF_REDISC_FOV; 3933 spin_unlock_irq(&phba->hbalock); 3934 3935 /* Scan FCF table from the first entry to re-discover SAN */ 3936 lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY, 3937 "2777 Start post-quiescent FCF table scan\n"); 3938 rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST); 3939 if (rc) 3940 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY, 3941 "2747 Issue FCF scan read FCF mailbox " 3942 "command failed 0x%x\n", rc); 3943 } 3944 3945 /** 3946 * lpfc_api_table_setup - Set up per hba pci-device group func api jump table 3947 * @phba: pointer to lpfc hba data structure. 3948 * @dev_grp: The HBA PCI-Device group number. 3949 * 3950 * This routine is invoked to set up the per HBA PCI-Device group function 3951 * API jump table entries. 3952 * 3953 * Return: 0 if success, otherwise -ENODEV 3954 **/ 3955 int 3956 lpfc_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp) 3957 { 3958 int rc; 3959 3960 /* Set up lpfc PCI-device group */ 3961 phba->pci_dev_grp = dev_grp; 3962 3963 /* The LPFC_PCI_DEV_OC uses SLI4 */ 3964 if (dev_grp == LPFC_PCI_DEV_OC) 3965 phba->sli_rev = LPFC_SLI_REV4; 3966 3967 /* Set up device INIT API function jump table */ 3968 rc = lpfc_init_api_table_setup(phba, dev_grp); 3969 if (rc) 3970 return -ENODEV; 3971 /* Set up SCSI API function jump table */ 3972 rc = lpfc_scsi_api_table_setup(phba, dev_grp); 3973 if (rc) 3974 return -ENODEV; 3975 /* Set up SLI API function jump table */ 3976 rc = lpfc_sli_api_table_setup(phba, dev_grp); 3977 if (rc) 3978 return -ENODEV; 3979 /* Set up MBOX API function jump table */ 3980 rc = lpfc_mbox_api_table_setup(phba, dev_grp); 3981 if (rc) 3982 return -ENODEV; 3983 3984 return 0; 3985 } 3986 3987 /** 3988 * lpfc_log_intr_mode - Log the active interrupt mode 3989 * @phba: pointer to lpfc hba data structure. 3990 * @intr_mode: active interrupt mode adopted. 3991 * 3992 * This routine it invoked to log the currently used active interrupt mode 3993 * to the device. 3994 **/ 3995 static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode) 3996 { 3997 switch (intr_mode) { 3998 case 0: 3999 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 4000 "0470 Enable INTx interrupt mode.\n"); 4001 break; 4002 case 1: 4003 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 4004 "0481 Enabled MSI interrupt mode.\n"); 4005 break; 4006 case 2: 4007 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 4008 "0480 Enabled MSI-X interrupt mode.\n"); 4009 break; 4010 default: 4011 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4012 "0482 Illegal interrupt mode.\n"); 4013 break; 4014 } 4015 return; 4016 } 4017 4018 /** 4019 * lpfc_enable_pci_dev - Enable a generic PCI device. 4020 * @phba: pointer to lpfc hba data structure. 4021 * 4022 * This routine is invoked to enable the PCI device that is common to all 4023 * PCI devices. 4024 * 4025 * Return codes 4026 * 0 - successful 4027 * other values - error 4028 **/ 4029 static int 4030 lpfc_enable_pci_dev(struct lpfc_hba *phba) 4031 { 4032 struct pci_dev *pdev; 4033 int bars = 0; 4034 4035 /* Obtain PCI device reference */ 4036 if (!phba->pcidev) 4037 goto out_error; 4038 else 4039 pdev = phba->pcidev; 4040 /* Select PCI BARs */ 4041 bars = pci_select_bars(pdev, IORESOURCE_MEM); 4042 /* Enable PCI device */ 4043 if (pci_enable_device_mem(pdev)) 4044 goto out_error; 4045 /* Request PCI resource for the device */ 4046 if (pci_request_selected_regions(pdev, bars, LPFC_DRIVER_NAME)) 4047 goto out_disable_device; 4048 /* Set up device as PCI master and save state for EEH */ 4049 pci_set_master(pdev); 4050 pci_try_set_mwi(pdev); 4051 pci_save_state(pdev); 4052 4053 /* PCIe EEH recovery on powerpc platforms needs fundamental reset */ 4054 if (pci_find_capability(pdev, PCI_CAP_ID_EXP)) 4055 pdev->needs_freset = 1; 4056 4057 return 0; 4058 4059 out_disable_device: 4060 pci_disable_device(pdev); 4061 out_error: 4062 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4063 "1401 Failed to enable pci device, bars:x%x\n", bars); 4064 return -ENODEV; 4065 } 4066 4067 /** 4068 * lpfc_disable_pci_dev - Disable a generic PCI device. 4069 * @phba: pointer to lpfc hba data structure. 4070 * 4071 * This routine is invoked to disable the PCI device that is common to all 4072 * PCI devices. 4073 **/ 4074 static void 4075 lpfc_disable_pci_dev(struct lpfc_hba *phba) 4076 { 4077 struct pci_dev *pdev; 4078 int bars; 4079 4080 /* Obtain PCI device reference */ 4081 if (!phba->pcidev) 4082 return; 4083 else 4084 pdev = phba->pcidev; 4085 /* Select PCI BARs */ 4086 bars = pci_select_bars(pdev, IORESOURCE_MEM); 4087 /* Release PCI resource and disable PCI device */ 4088 pci_release_selected_regions(pdev, bars); 4089 pci_disable_device(pdev); 4090 /* Null out PCI private reference to driver */ 4091 pci_set_drvdata(pdev, NULL); 4092 4093 return; 4094 } 4095 4096 /** 4097 * lpfc_reset_hba - Reset a hba 4098 * @phba: pointer to lpfc hba data structure. 4099 * 4100 * This routine is invoked to reset a hba device. It brings the HBA 4101 * offline, performs a board restart, and then brings the board back 4102 * online. The lpfc_offline calls lpfc_sli_hba_down which will clean up 4103 * on outstanding mailbox commands. 4104 **/ 4105 void 4106 lpfc_reset_hba(struct lpfc_hba *phba) 4107 { 4108 /* If resets are disabled then set error state and return. */ 4109 if (!phba->cfg_enable_hba_reset) { 4110 phba->link_state = LPFC_HBA_ERROR; 4111 return; 4112 } 4113 lpfc_offline_prep(phba); 4114 lpfc_offline(phba); 4115 lpfc_sli_brdrestart(phba); 4116 lpfc_online(phba); 4117 lpfc_unblock_mgmt_io(phba); 4118 } 4119 4120 /** 4121 * lpfc_sli_sriov_nr_virtfn_get - Get the number of sr-iov virtual functions 4122 * @phba: pointer to lpfc hba data structure. 4123 * 4124 * This function enables the PCI SR-IOV virtual functions to a physical 4125 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to 4126 * enable the number of virtual functions to the physical function. As 4127 * not all devices support SR-IOV, the return code from the pci_enable_sriov() 4128 * API call does not considered as an error condition for most of the device. 4129 **/ 4130 uint16_t 4131 lpfc_sli_sriov_nr_virtfn_get(struct lpfc_hba *phba) 4132 { 4133 struct pci_dev *pdev = phba->pcidev; 4134 uint16_t nr_virtfn; 4135 int pos; 4136 4137 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV); 4138 if (pos == 0) 4139 return 0; 4140 4141 pci_read_config_word(pdev, pos + PCI_SRIOV_TOTAL_VF, &nr_virtfn); 4142 return nr_virtfn; 4143 } 4144 4145 /** 4146 * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions 4147 * @phba: pointer to lpfc hba data structure. 4148 * @nr_vfn: number of virtual functions to be enabled. 4149 * 4150 * This function enables the PCI SR-IOV virtual functions to a physical 4151 * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to 4152 * enable the number of virtual functions to the physical function. As 4153 * not all devices support SR-IOV, the return code from the pci_enable_sriov() 4154 * API call does not considered as an error condition for most of the device. 4155 **/ 4156 int 4157 lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn) 4158 { 4159 struct pci_dev *pdev = phba->pcidev; 4160 uint16_t max_nr_vfn; 4161 int rc; 4162 4163 max_nr_vfn = lpfc_sli_sriov_nr_virtfn_get(phba); 4164 if (nr_vfn > max_nr_vfn) { 4165 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4166 "3057 Requested vfs (%d) greater than " 4167 "supported vfs (%d)", nr_vfn, max_nr_vfn); 4168 return -EINVAL; 4169 } 4170 4171 rc = pci_enable_sriov(pdev, nr_vfn); 4172 if (rc) { 4173 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 4174 "2806 Failed to enable sriov on this device " 4175 "with vfn number nr_vf:%d, rc:%d\n", 4176 nr_vfn, rc); 4177 } else 4178 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 4179 "2807 Successful enable sriov on this device " 4180 "with vfn number nr_vf:%d\n", nr_vfn); 4181 return rc; 4182 } 4183 4184 /** 4185 * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev. 4186 * @phba: pointer to lpfc hba data structure. 4187 * 4188 * This routine is invoked to set up the driver internal resources specific to 4189 * support the SLI-3 HBA device it attached to. 4190 * 4191 * Return codes 4192 * 0 - successful 4193 * other values - error 4194 **/ 4195 static int 4196 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba) 4197 { 4198 struct lpfc_sli *psli; 4199 int rc; 4200 4201 /* 4202 * Initialize timers used by driver 4203 */ 4204 4205 /* Heartbeat timer */ 4206 init_timer(&phba->hb_tmofunc); 4207 phba->hb_tmofunc.function = lpfc_hb_timeout; 4208 phba->hb_tmofunc.data = (unsigned long)phba; 4209 4210 psli = &phba->sli; 4211 /* MBOX heartbeat timer */ 4212 init_timer(&psli->mbox_tmo); 4213 psli->mbox_tmo.function = lpfc_mbox_timeout; 4214 psli->mbox_tmo.data = (unsigned long) phba; 4215 /* FCP polling mode timer */ 4216 init_timer(&phba->fcp_poll_timer); 4217 phba->fcp_poll_timer.function = lpfc_poll_timeout; 4218 phba->fcp_poll_timer.data = (unsigned long) phba; 4219 /* Fabric block timer */ 4220 init_timer(&phba->fabric_block_timer); 4221 phba->fabric_block_timer.function = lpfc_fabric_block_timeout; 4222 phba->fabric_block_timer.data = (unsigned long) phba; 4223 /* EA polling mode timer */ 4224 init_timer(&phba->eratt_poll); 4225 phba->eratt_poll.function = lpfc_poll_eratt; 4226 phba->eratt_poll.data = (unsigned long) phba; 4227 4228 /* Host attention work mask setup */ 4229 phba->work_ha_mask = (HA_ERATT | HA_MBATT | HA_LATT); 4230 phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4)); 4231 4232 /* Get all the module params for configuring this host */ 4233 lpfc_get_cfgparam(phba); 4234 if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) { 4235 phba->menlo_flag |= HBA_MENLO_SUPPORT; 4236 /* check for menlo minimum sg count */ 4237 if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT) 4238 phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT; 4239 } 4240 4241 /* 4242 * Since the sg_tablesize is module parameter, the sg_dma_buf_size 4243 * used to create the sg_dma_buf_pool must be dynamically calculated. 4244 * 2 segments are added since the IOCB needs a command and response bde. 4245 */ 4246 phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) + 4247 sizeof(struct fcp_rsp) + 4248 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64)); 4249 4250 if (phba->cfg_enable_bg) { 4251 phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT; 4252 phba->cfg_sg_dma_buf_size += 4253 phba->cfg_prot_sg_seg_cnt * sizeof(struct ulp_bde64); 4254 } 4255 4256 /* Also reinitialize the host templates with new values. */ 4257 lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt; 4258 lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt; 4259 4260 phba->max_vpi = LPFC_MAX_VPI; 4261 /* This will be set to correct value after config_port mbox */ 4262 phba->max_vports = 0; 4263 4264 /* 4265 * Initialize the SLI Layer to run with lpfc HBAs. 4266 */ 4267 lpfc_sli_setup(phba); 4268 lpfc_sli_queue_setup(phba); 4269 4270 /* Allocate device driver memory */ 4271 if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ)) 4272 return -ENOMEM; 4273 4274 /* 4275 * Enable sr-iov virtual functions if supported and configured 4276 * through the module parameter. 4277 */ 4278 if (phba->cfg_sriov_nr_virtfn > 0) { 4279 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, 4280 phba->cfg_sriov_nr_virtfn); 4281 if (rc) { 4282 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 4283 "2808 Requested number of SR-IOV " 4284 "virtual functions (%d) is not " 4285 "supported\n", 4286 phba->cfg_sriov_nr_virtfn); 4287 phba->cfg_sriov_nr_virtfn = 0; 4288 } 4289 } 4290 4291 return 0; 4292 } 4293 4294 /** 4295 * lpfc_sli_driver_resource_unset - Unset drvr internal resources for SLI3 dev 4296 * @phba: pointer to lpfc hba data structure. 4297 * 4298 * This routine is invoked to unset the driver internal resources set up 4299 * specific for supporting the SLI-3 HBA device it attached to. 4300 **/ 4301 static void 4302 lpfc_sli_driver_resource_unset(struct lpfc_hba *phba) 4303 { 4304 /* Free device driver memory allocated */ 4305 lpfc_mem_free_all(phba); 4306 4307 return; 4308 } 4309 4310 /** 4311 * lpfc_sli4_driver_resource_setup - Setup drvr internal resources for SLI4 dev 4312 * @phba: pointer to lpfc hba data structure. 4313 * 4314 * This routine is invoked to set up the driver internal resources specific to 4315 * support the SLI-4 HBA device it attached to. 4316 * 4317 * Return codes 4318 * 0 - successful 4319 * other values - error 4320 **/ 4321 static int 4322 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba) 4323 { 4324 struct lpfc_sli *psli; 4325 LPFC_MBOXQ_t *mboxq; 4326 int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size; 4327 uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0}; 4328 struct lpfc_mqe *mqe; 4329 int longs, sli_family; 4330 4331 /* Before proceed, wait for POST done and device ready */ 4332 rc = lpfc_sli4_post_status_check(phba); 4333 if (rc) 4334 return -ENODEV; 4335 4336 /* 4337 * Initialize timers used by driver 4338 */ 4339 4340 /* Heartbeat timer */ 4341 init_timer(&phba->hb_tmofunc); 4342 phba->hb_tmofunc.function = lpfc_hb_timeout; 4343 phba->hb_tmofunc.data = (unsigned long)phba; 4344 init_timer(&phba->rrq_tmr); 4345 phba->rrq_tmr.function = lpfc_rrq_timeout; 4346 phba->rrq_tmr.data = (unsigned long)phba; 4347 4348 psli = &phba->sli; 4349 /* MBOX heartbeat timer */ 4350 init_timer(&psli->mbox_tmo); 4351 psli->mbox_tmo.function = lpfc_mbox_timeout; 4352 psli->mbox_tmo.data = (unsigned long) phba; 4353 /* Fabric block timer */ 4354 init_timer(&phba->fabric_block_timer); 4355 phba->fabric_block_timer.function = lpfc_fabric_block_timeout; 4356 phba->fabric_block_timer.data = (unsigned long) phba; 4357 /* EA polling mode timer */ 4358 init_timer(&phba->eratt_poll); 4359 phba->eratt_poll.function = lpfc_poll_eratt; 4360 phba->eratt_poll.data = (unsigned long) phba; 4361 /* FCF rediscover timer */ 4362 init_timer(&phba->fcf.redisc_wait); 4363 phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo; 4364 phba->fcf.redisc_wait.data = (unsigned long)phba; 4365 4366 /* 4367 * Control structure for handling external multi-buffer mailbox 4368 * command pass-through. 4369 */ 4370 memset((uint8_t *)&phba->mbox_ext_buf_ctx, 0, 4371 sizeof(struct lpfc_mbox_ext_buf_ctx)); 4372 INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list); 4373 4374 /* 4375 * We need to do a READ_CONFIG mailbox command here before 4376 * calling lpfc_get_cfgparam. For VFs this will report the 4377 * MAX_XRI, MAX_VPI, MAX_RPI, MAX_IOCB, and MAX_VFI settings. 4378 * All of the resources allocated 4379 * for this Port are tied to these values. 4380 */ 4381 /* Get all the module params for configuring this host */ 4382 lpfc_get_cfgparam(phba); 4383 phba->max_vpi = LPFC_MAX_VPI; 4384 /* This will be set to correct value after the read_config mbox */ 4385 phba->max_vports = 0; 4386 4387 /* Program the default value of vlan_id and fc_map */ 4388 phba->valid_vlan = 0; 4389 phba->fc_map[0] = LPFC_FCOE_FCF_MAP0; 4390 phba->fc_map[1] = LPFC_FCOE_FCF_MAP1; 4391 phba->fc_map[2] = LPFC_FCOE_FCF_MAP2; 4392 4393 /* 4394 * Since the sg_tablesize is module parameter, the sg_dma_buf_size 4395 * used to create the sg_dma_buf_pool must be dynamically calculated. 4396 * 2 segments are added since the IOCB needs a command and response bde. 4397 * To insure that the scsi sgl does not cross a 4k page boundary only 4398 * sgl sizes of must be a power of 2. 4399 */ 4400 buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) + 4401 ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge))); 4402 4403 sli_family = bf_get(lpfc_sli_intf_sli_family, &phba->sli4_hba.sli_intf); 4404 max_buf_size = LPFC_SLI4_MAX_BUF_SIZE; 4405 switch (sli_family) { 4406 case LPFC_SLI_INTF_FAMILY_BE2: 4407 case LPFC_SLI_INTF_FAMILY_BE3: 4408 /* There is a single hint for BE - 2 pages per BPL. */ 4409 if (bf_get(lpfc_sli_intf_sli_hint1, &phba->sli4_hba.sli_intf) == 4410 LPFC_SLI_INTF_SLI_HINT1_1) 4411 max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE; 4412 break; 4413 case LPFC_SLI_INTF_FAMILY_LNCR_A0: 4414 case LPFC_SLI_INTF_FAMILY_LNCR_B0: 4415 default: 4416 break; 4417 } 4418 for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE; 4419 dma_buf_size < max_buf_size && buf_size > dma_buf_size; 4420 dma_buf_size = dma_buf_size << 1) 4421 ; 4422 if (dma_buf_size == max_buf_size) 4423 phba->cfg_sg_seg_cnt = (dma_buf_size - 4424 sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) - 4425 (2 * sizeof(struct sli4_sge))) / 4426 sizeof(struct sli4_sge); 4427 phba->cfg_sg_dma_buf_size = dma_buf_size; 4428 4429 /* Initialize buffer queue management fields */ 4430 hbq_count = lpfc_sli_hbq_count(); 4431 for (i = 0; i < hbq_count; ++i) 4432 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list); 4433 INIT_LIST_HEAD(&phba->rb_pend_list); 4434 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_sli4_rb_alloc; 4435 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_sli4_rb_free; 4436 4437 /* 4438 * Initialize the SLI Layer to run with lpfc SLI4 HBAs. 4439 */ 4440 /* Initialize the Abort scsi buffer list used by driver */ 4441 spin_lock_init(&phba->sli4_hba.abts_scsi_buf_list_lock); 4442 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_scsi_buf_list); 4443 /* This abort list used by worker thread */ 4444 spin_lock_init(&phba->sli4_hba.abts_sgl_list_lock); 4445 4446 /* 4447 * Initialize driver internal slow-path work queues 4448 */ 4449 4450 /* Driver internel slow-path CQ Event pool */ 4451 INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool); 4452 /* Response IOCB work queue list */ 4453 INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event); 4454 /* Asynchronous event CQ Event work queue list */ 4455 INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue); 4456 /* Fast-path XRI aborted CQ Event work queue list */ 4457 INIT_LIST_HEAD(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue); 4458 /* Slow-path XRI aborted CQ Event work queue list */ 4459 INIT_LIST_HEAD(&phba->sli4_hba.sp_els_xri_aborted_work_queue); 4460 /* Receive queue CQ Event work queue list */ 4461 INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue); 4462 4463 /* Initialize extent block lists. */ 4464 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_blk_list); 4465 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_xri_blk_list); 4466 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_vfi_blk_list); 4467 INIT_LIST_HEAD(&phba->lpfc_vpi_blk_list); 4468 4469 /* Initialize the driver internal SLI layer lists. */ 4470 lpfc_sli_setup(phba); 4471 lpfc_sli_queue_setup(phba); 4472 4473 /* Allocate device driver memory */ 4474 rc = lpfc_mem_alloc(phba, SGL_ALIGN_SZ); 4475 if (rc) 4476 return -ENOMEM; 4477 4478 /* IF Type 2 ports get initialized now. */ 4479 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) == 4480 LPFC_SLI_INTF_IF_TYPE_2) { 4481 rc = lpfc_pci_function_reset(phba); 4482 if (unlikely(rc)) 4483 return -ENODEV; 4484 } 4485 4486 /* Create the bootstrap mailbox command */ 4487 rc = lpfc_create_bootstrap_mbox(phba); 4488 if (unlikely(rc)) 4489 goto out_free_mem; 4490 4491 /* Set up the host's endian order with the device. */ 4492 rc = lpfc_setup_endian_order(phba); 4493 if (unlikely(rc)) 4494 goto out_free_bsmbx; 4495 4496 /* Set up the hba's configuration parameters. */ 4497 rc = lpfc_sli4_read_config(phba); 4498 if (unlikely(rc)) 4499 goto out_free_bsmbx; 4500 4501 /* IF Type 0 ports get initialized now. */ 4502 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) == 4503 LPFC_SLI_INTF_IF_TYPE_0) { 4504 rc = lpfc_pci_function_reset(phba); 4505 if (unlikely(rc)) 4506 goto out_free_bsmbx; 4507 } 4508 4509 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, 4510 GFP_KERNEL); 4511 if (!mboxq) { 4512 rc = -ENOMEM; 4513 goto out_free_bsmbx; 4514 } 4515 4516 /* Get the Supported Pages if PORT_CAPABILITIES is supported by port. */ 4517 lpfc_supported_pages(mboxq); 4518 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 4519 if (!rc) { 4520 mqe = &mboxq->u.mqe; 4521 memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3), 4522 LPFC_MAX_SUPPORTED_PAGES); 4523 for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) { 4524 switch (pn_page[i]) { 4525 case LPFC_SLI4_PARAMETERS: 4526 phba->sli4_hba.pc_sli4_params.supported = 1; 4527 break; 4528 default: 4529 break; 4530 } 4531 } 4532 /* Read the port's SLI4 Parameters capabilities if supported. */ 4533 if (phba->sli4_hba.pc_sli4_params.supported) 4534 rc = lpfc_pc_sli4_params_get(phba, mboxq); 4535 if (rc) { 4536 mempool_free(mboxq, phba->mbox_mem_pool); 4537 rc = -EIO; 4538 goto out_free_bsmbx; 4539 } 4540 } 4541 /* 4542 * Get sli4 parameters that override parameters from Port capabilities. 4543 * If this call fails, it isn't critical unless the SLI4 parameters come 4544 * back in conflict. 4545 */ 4546 rc = lpfc_get_sli4_parameters(phba, mboxq); 4547 if (rc) { 4548 if (phba->sli4_hba.extents_in_use && 4549 phba->sli4_hba.rpi_hdrs_in_use) { 4550 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4551 "2999 Unsupported SLI4 Parameters " 4552 "Extents and RPI headers enabled.\n"); 4553 goto out_free_bsmbx; 4554 } 4555 } 4556 mempool_free(mboxq, phba->mbox_mem_pool); 4557 /* Verify all the SLI4 queues */ 4558 rc = lpfc_sli4_queue_verify(phba); 4559 if (rc) 4560 goto out_free_bsmbx; 4561 4562 /* Create driver internal CQE event pool */ 4563 rc = lpfc_sli4_cq_event_pool_create(phba); 4564 if (rc) 4565 goto out_free_bsmbx; 4566 4567 /* Initialize and populate the iocb list per host */ 4568 rc = lpfc_init_sgl_list(phba); 4569 if (rc) { 4570 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4571 "1400 Failed to initialize sgl list.\n"); 4572 goto out_destroy_cq_event_pool; 4573 } 4574 rc = lpfc_init_active_sgl_array(phba); 4575 if (rc) { 4576 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4577 "1430 Failed to initialize sgl list.\n"); 4578 goto out_free_sgl_list; 4579 } 4580 rc = lpfc_sli4_init_rpi_hdrs(phba); 4581 if (rc) { 4582 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4583 "1432 Failed to initialize rpi headers.\n"); 4584 goto out_free_active_sgl; 4585 } 4586 4587 /* Allocate eligible FCF bmask memory for FCF roundrobin failover */ 4588 longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG; 4589 phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long), 4590 GFP_KERNEL); 4591 if (!phba->fcf.fcf_rr_bmask) { 4592 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4593 "2759 Failed allocate memory for FCF round " 4594 "robin failover bmask\n"); 4595 rc = -ENOMEM; 4596 goto out_remove_rpi_hdrs; 4597 } 4598 4599 /* 4600 * The cfg_fcp_eq_count can be zero whenever there is exactly one 4601 * interrupt vector. This is not an error 4602 */ 4603 if (phba->cfg_fcp_eq_count) { 4604 phba->sli4_hba.fcp_eq_hdl = 4605 kzalloc((sizeof(struct lpfc_fcp_eq_hdl) * 4606 phba->cfg_fcp_eq_count), GFP_KERNEL); 4607 if (!phba->sli4_hba.fcp_eq_hdl) { 4608 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4609 "2572 Failed allocate memory for " 4610 "fast-path per-EQ handle array\n"); 4611 rc = -ENOMEM; 4612 goto out_free_fcf_rr_bmask; 4613 } 4614 } 4615 4616 phba->sli4_hba.msix_entries = kzalloc((sizeof(struct msix_entry) * 4617 phba->sli4_hba.cfg_eqn), GFP_KERNEL); 4618 if (!phba->sli4_hba.msix_entries) { 4619 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4620 "2573 Failed allocate memory for msi-x " 4621 "interrupt vector entries\n"); 4622 rc = -ENOMEM; 4623 goto out_free_fcp_eq_hdl; 4624 } 4625 4626 /* 4627 * Enable sr-iov virtual functions if supported and configured 4628 * through the module parameter. 4629 */ 4630 if (phba->cfg_sriov_nr_virtfn > 0) { 4631 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, 4632 phba->cfg_sriov_nr_virtfn); 4633 if (rc) { 4634 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 4635 "3020 Requested number of SR-IOV " 4636 "virtual functions (%d) is not " 4637 "supported\n", 4638 phba->cfg_sriov_nr_virtfn); 4639 phba->cfg_sriov_nr_virtfn = 0; 4640 } 4641 } 4642 4643 return 0; 4644 4645 out_free_fcp_eq_hdl: 4646 kfree(phba->sli4_hba.fcp_eq_hdl); 4647 out_free_fcf_rr_bmask: 4648 kfree(phba->fcf.fcf_rr_bmask); 4649 out_remove_rpi_hdrs: 4650 lpfc_sli4_remove_rpi_hdrs(phba); 4651 out_free_active_sgl: 4652 lpfc_free_active_sgl(phba); 4653 out_free_sgl_list: 4654 lpfc_free_sgl_list(phba); 4655 out_destroy_cq_event_pool: 4656 lpfc_sli4_cq_event_pool_destroy(phba); 4657 out_free_bsmbx: 4658 lpfc_destroy_bootstrap_mbox(phba); 4659 out_free_mem: 4660 lpfc_mem_free(phba); 4661 return rc; 4662 } 4663 4664 /** 4665 * lpfc_sli4_driver_resource_unset - Unset drvr internal resources for SLI4 dev 4666 * @phba: pointer to lpfc hba data structure. 4667 * 4668 * This routine is invoked to unset the driver internal resources set up 4669 * specific for supporting the SLI-4 HBA device it attached to. 4670 **/ 4671 static void 4672 lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba) 4673 { 4674 struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry; 4675 4676 /* Free memory allocated for msi-x interrupt vector entries */ 4677 kfree(phba->sli4_hba.msix_entries); 4678 4679 /* Free memory allocated for fast-path work queue handles */ 4680 kfree(phba->sli4_hba.fcp_eq_hdl); 4681 4682 /* Free the allocated rpi headers. */ 4683 lpfc_sli4_remove_rpi_hdrs(phba); 4684 lpfc_sli4_remove_rpis(phba); 4685 4686 /* Free eligible FCF index bmask */ 4687 kfree(phba->fcf.fcf_rr_bmask); 4688 4689 /* Free the ELS sgl list */ 4690 lpfc_free_active_sgl(phba); 4691 lpfc_free_sgl_list(phba); 4692 4693 /* Free the SCSI sgl management array */ 4694 kfree(phba->sli4_hba.lpfc_scsi_psb_array); 4695 4696 /* Free the completion queue EQ event pool */ 4697 lpfc_sli4_cq_event_release_all(phba); 4698 lpfc_sli4_cq_event_pool_destroy(phba); 4699 4700 /* Release resource identifiers. */ 4701 lpfc_sli4_dealloc_resource_identifiers(phba); 4702 4703 /* Free the bsmbx region. */ 4704 lpfc_destroy_bootstrap_mbox(phba); 4705 4706 /* Free the SLI Layer memory with SLI4 HBAs */ 4707 lpfc_mem_free_all(phba); 4708 4709 /* Free the current connect table */ 4710 list_for_each_entry_safe(conn_entry, next_conn_entry, 4711 &phba->fcf_conn_rec_list, list) { 4712 list_del_init(&conn_entry->list); 4713 kfree(conn_entry); 4714 } 4715 4716 return; 4717 } 4718 4719 /** 4720 * lpfc_init_api_table_setup - Set up init api function jump table 4721 * @phba: The hba struct for which this call is being executed. 4722 * @dev_grp: The HBA PCI-Device group number. 4723 * 4724 * This routine sets up the device INIT interface API function jump table 4725 * in @phba struct. 4726 * 4727 * Returns: 0 - success, -ENODEV - failure. 4728 **/ 4729 int 4730 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp) 4731 { 4732 phba->lpfc_hba_init_link = lpfc_hba_init_link; 4733 phba->lpfc_hba_down_link = lpfc_hba_down_link; 4734 phba->lpfc_selective_reset = lpfc_selective_reset; 4735 switch (dev_grp) { 4736 case LPFC_PCI_DEV_LP: 4737 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3; 4738 phba->lpfc_handle_eratt = lpfc_handle_eratt_s3; 4739 phba->lpfc_stop_port = lpfc_stop_port_s3; 4740 break; 4741 case LPFC_PCI_DEV_OC: 4742 phba->lpfc_hba_down_post = lpfc_hba_down_post_s4; 4743 phba->lpfc_handle_eratt = lpfc_handle_eratt_s4; 4744 phba->lpfc_stop_port = lpfc_stop_port_s4; 4745 break; 4746 default: 4747 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 4748 "1431 Invalid HBA PCI-device group: 0x%x\n", 4749 dev_grp); 4750 return -ENODEV; 4751 break; 4752 } 4753 return 0; 4754 } 4755 4756 /** 4757 * lpfc_setup_driver_resource_phase1 - Phase1 etup driver internal resources. 4758 * @phba: pointer to lpfc hba data structure. 4759 * 4760 * This routine is invoked to set up the driver internal resources before the 4761 * device specific resource setup to support the HBA device it attached to. 4762 * 4763 * Return codes 4764 * 0 - successful 4765 * other values - error 4766 **/ 4767 static int 4768 lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba) 4769 { 4770 /* 4771 * Driver resources common to all SLI revisions 4772 */ 4773 atomic_set(&phba->fast_event_count, 0); 4774 spin_lock_init(&phba->hbalock); 4775 4776 /* Initialize ndlp management spinlock */ 4777 spin_lock_init(&phba->ndlp_lock); 4778 4779 INIT_LIST_HEAD(&phba->port_list); 4780 INIT_LIST_HEAD(&phba->work_list); 4781 init_waitqueue_head(&phba->wait_4_mlo_m_q); 4782 4783 /* Initialize the wait queue head for the kernel thread */ 4784 init_waitqueue_head(&phba->work_waitq); 4785 4786 /* Initialize the scsi buffer list used by driver for scsi IO */ 4787 spin_lock_init(&phba->scsi_buf_list_lock); 4788 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list); 4789 4790 /* Initialize the fabric iocb list */ 4791 INIT_LIST_HEAD(&phba->fabric_iocb_list); 4792 4793 /* Initialize list to save ELS buffers */ 4794 INIT_LIST_HEAD(&phba->elsbuf); 4795 4796 /* Initialize FCF connection rec list */ 4797 INIT_LIST_HEAD(&phba->fcf_conn_rec_list); 4798 4799 return 0; 4800 } 4801 4802 /** 4803 * lpfc_setup_driver_resource_phase2 - Phase2 setup driver internal resources. 4804 * @phba: pointer to lpfc hba data structure. 4805 * 4806 * This routine is invoked to set up the driver internal resources after the 4807 * device specific resource setup to support the HBA device it attached to. 4808 * 4809 * Return codes 4810 * 0 - successful 4811 * other values - error 4812 **/ 4813 static int 4814 lpfc_setup_driver_resource_phase2(struct lpfc_hba *phba) 4815 { 4816 int error; 4817 4818 /* Startup the kernel thread for this host adapter. */ 4819 phba->worker_thread = kthread_run(lpfc_do_work, phba, 4820 "lpfc_worker_%d", phba->brd_no); 4821 if (IS_ERR(phba->worker_thread)) { 4822 error = PTR_ERR(phba->worker_thread); 4823 return error; 4824 } 4825 4826 return 0; 4827 } 4828 4829 /** 4830 * lpfc_unset_driver_resource_phase2 - Phase2 unset driver internal resources. 4831 * @phba: pointer to lpfc hba data structure. 4832 * 4833 * This routine is invoked to unset the driver internal resources set up after 4834 * the device specific resource setup for supporting the HBA device it 4835 * attached to. 4836 **/ 4837 static void 4838 lpfc_unset_driver_resource_phase2(struct lpfc_hba *phba) 4839 { 4840 /* Stop kernel worker thread */ 4841 kthread_stop(phba->worker_thread); 4842 } 4843 4844 /** 4845 * lpfc_free_iocb_list - Free iocb list. 4846 * @phba: pointer to lpfc hba data structure. 4847 * 4848 * This routine is invoked to free the driver's IOCB list and memory. 4849 **/ 4850 static void 4851 lpfc_free_iocb_list(struct lpfc_hba *phba) 4852 { 4853 struct lpfc_iocbq *iocbq_entry = NULL, *iocbq_next = NULL; 4854 4855 spin_lock_irq(&phba->hbalock); 4856 list_for_each_entry_safe(iocbq_entry, iocbq_next, 4857 &phba->lpfc_iocb_list, list) { 4858 list_del(&iocbq_entry->list); 4859 kfree(iocbq_entry); 4860 phba->total_iocbq_bufs--; 4861 } 4862 spin_unlock_irq(&phba->hbalock); 4863 4864 return; 4865 } 4866 4867 /** 4868 * lpfc_init_iocb_list - Allocate and initialize iocb list. 4869 * @phba: pointer to lpfc hba data structure. 4870 * 4871 * This routine is invoked to allocate and initizlize the driver's IOCB 4872 * list and set up the IOCB tag array accordingly. 4873 * 4874 * Return codes 4875 * 0 - successful 4876 * other values - error 4877 **/ 4878 static int 4879 lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count) 4880 { 4881 struct lpfc_iocbq *iocbq_entry = NULL; 4882 uint16_t iotag; 4883 int i; 4884 4885 /* Initialize and populate the iocb list per host. */ 4886 INIT_LIST_HEAD(&phba->lpfc_iocb_list); 4887 for (i = 0; i < iocb_count; i++) { 4888 iocbq_entry = kzalloc(sizeof(struct lpfc_iocbq), GFP_KERNEL); 4889 if (iocbq_entry == NULL) { 4890 printk(KERN_ERR "%s: only allocated %d iocbs of " 4891 "expected %d count. Unloading driver.\n", 4892 __func__, i, LPFC_IOCB_LIST_CNT); 4893 goto out_free_iocbq; 4894 } 4895 4896 iotag = lpfc_sli_next_iotag(phba, iocbq_entry); 4897 if (iotag == 0) { 4898 kfree(iocbq_entry); 4899 printk(KERN_ERR "%s: failed to allocate IOTAG. " 4900 "Unloading driver.\n", __func__); 4901 goto out_free_iocbq; 4902 } 4903 iocbq_entry->sli4_lxritag = NO_XRI; 4904 iocbq_entry->sli4_xritag = NO_XRI; 4905 4906 spin_lock_irq(&phba->hbalock); 4907 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list); 4908 phba->total_iocbq_bufs++; 4909 spin_unlock_irq(&phba->hbalock); 4910 } 4911 4912 return 0; 4913 4914 out_free_iocbq: 4915 lpfc_free_iocb_list(phba); 4916 4917 return -ENOMEM; 4918 } 4919 4920 /** 4921 * lpfc_free_sgl_list - Free sgl list. 4922 * @phba: pointer to lpfc hba data structure. 4923 * 4924 * This routine is invoked to free the driver's sgl list and memory. 4925 **/ 4926 static void 4927 lpfc_free_sgl_list(struct lpfc_hba *phba) 4928 { 4929 struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL; 4930 LIST_HEAD(sglq_list); 4931 4932 spin_lock_irq(&phba->hbalock); 4933 list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &sglq_list); 4934 spin_unlock_irq(&phba->hbalock); 4935 4936 list_for_each_entry_safe(sglq_entry, sglq_next, 4937 &sglq_list, list) { 4938 list_del(&sglq_entry->list); 4939 lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys); 4940 kfree(sglq_entry); 4941 phba->sli4_hba.total_sglq_bufs--; 4942 } 4943 kfree(phba->sli4_hba.lpfc_els_sgl_array); 4944 } 4945 4946 /** 4947 * lpfc_init_active_sgl_array - Allocate the buf to track active ELS XRIs. 4948 * @phba: pointer to lpfc hba data structure. 4949 * 4950 * This routine is invoked to allocate the driver's active sgl memory. 4951 * This array will hold the sglq_entry's for active IOs. 4952 **/ 4953 static int 4954 lpfc_init_active_sgl_array(struct lpfc_hba *phba) 4955 { 4956 int size; 4957 size = sizeof(struct lpfc_sglq *); 4958 size *= phba->sli4_hba.max_cfg_param.max_xri; 4959 4960 phba->sli4_hba.lpfc_sglq_active_list = 4961 kzalloc(size, GFP_KERNEL); 4962 if (!phba->sli4_hba.lpfc_sglq_active_list) 4963 return -ENOMEM; 4964 return 0; 4965 } 4966 4967 /** 4968 * lpfc_free_active_sgl - Free the buf that tracks active ELS XRIs. 4969 * @phba: pointer to lpfc hba data structure. 4970 * 4971 * This routine is invoked to walk through the array of active sglq entries 4972 * and free all of the resources. 4973 * This is just a place holder for now. 4974 **/ 4975 static void 4976 lpfc_free_active_sgl(struct lpfc_hba *phba) 4977 { 4978 kfree(phba->sli4_hba.lpfc_sglq_active_list); 4979 } 4980 4981 /** 4982 * lpfc_init_sgl_list - Allocate and initialize sgl list. 4983 * @phba: pointer to lpfc hba data structure. 4984 * 4985 * This routine is invoked to allocate and initizlize the driver's sgl 4986 * list and set up the sgl xritag tag array accordingly. 4987 * 4988 * Return codes 4989 * 0 - successful 4990 * other values - error 4991 **/ 4992 static int 4993 lpfc_init_sgl_list(struct lpfc_hba *phba) 4994 { 4995 struct lpfc_sglq *sglq_entry = NULL; 4996 int i; 4997 int els_xri_cnt; 4998 4999 els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba); 5000 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 5001 "2400 ELS XRI count %d.\n", 5002 els_xri_cnt); 5003 /* Initialize and populate the sglq list per host/VF. */ 5004 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list); 5005 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list); 5006 5007 /* Sanity check on XRI management */ 5008 if (phba->sli4_hba.max_cfg_param.max_xri <= els_xri_cnt) { 5009 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 5010 "2562 No room left for SCSI XRI allocation: " 5011 "max_xri=%d, els_xri=%d\n", 5012 phba->sli4_hba.max_cfg_param.max_xri, 5013 els_xri_cnt); 5014 return -ENOMEM; 5015 } 5016 5017 /* Allocate memory for the ELS XRI management array */ 5018 phba->sli4_hba.lpfc_els_sgl_array = 5019 kzalloc((sizeof(struct lpfc_sglq *) * els_xri_cnt), 5020 GFP_KERNEL); 5021 5022 if (!phba->sli4_hba.lpfc_els_sgl_array) { 5023 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 5024 "2401 Failed to allocate memory for ELS " 5025 "XRI management array of size %d.\n", 5026 els_xri_cnt); 5027 return -ENOMEM; 5028 } 5029 5030 /* Keep the SCSI XRI into the XRI management array */ 5031 phba->sli4_hba.scsi_xri_max = 5032 phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt; 5033 phba->sli4_hba.scsi_xri_cnt = 0; 5034 phba->sli4_hba.lpfc_scsi_psb_array = 5035 kzalloc((sizeof(struct lpfc_scsi_buf *) * 5036 phba->sli4_hba.scsi_xri_max), GFP_KERNEL); 5037 5038 if (!phba->sli4_hba.lpfc_scsi_psb_array) { 5039 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 5040 "2563 Failed to allocate memory for SCSI " 5041 "XRI management array of size %d.\n", 5042 phba->sli4_hba.scsi_xri_max); 5043 kfree(phba->sli4_hba.lpfc_els_sgl_array); 5044 return -ENOMEM; 5045 } 5046 5047 for (i = 0; i < els_xri_cnt; i++) { 5048 sglq_entry = kzalloc(sizeof(struct lpfc_sglq), GFP_KERNEL); 5049 if (sglq_entry == NULL) { 5050 printk(KERN_ERR "%s: only allocated %d sgls of " 5051 "expected %d count. Unloading driver.\n", 5052 __func__, i, els_xri_cnt); 5053 goto out_free_mem; 5054 } 5055 5056 sglq_entry->buff_type = GEN_BUFF_TYPE; 5057 sglq_entry->virt = lpfc_mbuf_alloc(phba, 0, &sglq_entry->phys); 5058 if (sglq_entry->virt == NULL) { 5059 kfree(sglq_entry); 5060 printk(KERN_ERR "%s: failed to allocate mbuf.\n" 5061 "Unloading driver.\n", __func__); 5062 goto out_free_mem; 5063 } 5064 sglq_entry->sgl = sglq_entry->virt; 5065 memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE); 5066 5067 /* The list order is used by later block SGL registraton */ 5068 spin_lock_irq(&phba->hbalock); 5069 sglq_entry->state = SGL_FREED; 5070 list_add_tail(&sglq_entry->list, &phba->sli4_hba.lpfc_sgl_list); 5071 phba->sli4_hba.lpfc_els_sgl_array[i] = sglq_entry; 5072 phba->sli4_hba.total_sglq_bufs++; 5073 spin_unlock_irq(&phba->hbalock); 5074 } 5075 return 0; 5076 5077 out_free_mem: 5078 kfree(phba->sli4_hba.lpfc_scsi_psb_array); 5079 lpfc_free_sgl_list(phba); 5080 return -ENOMEM; 5081 } 5082 5083 /** 5084 * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port 5085 * @phba: pointer to lpfc hba data structure. 5086 * 5087 * This routine is invoked to post rpi header templates to the 5088 * port for those SLI4 ports that do not support extents. This routine 5089 * posts a PAGE_SIZE memory region to the port to hold up to 5090 * PAGE_SIZE modulo 64 rpi context headers. This is an initialization routine 5091 * and should be called only when interrupts are disabled. 5092 * 5093 * Return codes 5094 * 0 - successful 5095 * -ERROR - otherwise. 5096 **/ 5097 int 5098 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba) 5099 { 5100 int rc = 0; 5101 struct lpfc_rpi_hdr *rpi_hdr; 5102 5103 INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list); 5104 if (!phba->sli4_hba.rpi_hdrs_in_use) 5105 return rc; 5106 if (phba->sli4_hba.extents_in_use) 5107 return -EIO; 5108 5109 rpi_hdr = lpfc_sli4_create_rpi_hdr(phba); 5110 if (!rpi_hdr) { 5111 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI, 5112 "0391 Error during rpi post operation\n"); 5113 lpfc_sli4_remove_rpis(phba); 5114 rc = -ENODEV; 5115 } 5116 5117 return rc; 5118 } 5119 5120 /** 5121 * lpfc_sli4_create_rpi_hdr - Allocate an rpi header memory region 5122 * @phba: pointer to lpfc hba data structure. 5123 * 5124 * This routine is invoked to allocate a single 4KB memory region to 5125 * support rpis and stores them in the phba. This single region 5126 * provides support for up to 64 rpis. The region is used globally 5127 * by the device. 5128 * 5129 * Returns: 5130 * A valid rpi hdr on success. 5131 * A NULL pointer on any failure. 5132 **/ 5133 struct lpfc_rpi_hdr * 5134 lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba) 5135 { 5136 uint16_t rpi_limit, curr_rpi_range; 5137 struct lpfc_dmabuf *dmabuf; 5138 struct lpfc_rpi_hdr *rpi_hdr; 5139 uint32_t rpi_count; 5140 5141 /* 5142 * If the SLI4 port supports extents, posting the rpi header isn't 5143 * required. Set the expected maximum count and let the actual value 5144 * get set when extents are fully allocated. 5145 */ 5146 if (!phba->sli4_hba.rpi_hdrs_in_use) 5147 return NULL; 5148 if (phba->sli4_hba.extents_in_use) 5149 return NULL; 5150 5151 /* The limit on the logical index is just the max_rpi count. */ 5152 rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base + 5153 phba->sli4_hba.max_cfg_param.max_rpi - 1; 5154 5155 spin_lock_irq(&phba->hbalock); 5156 /* 5157 * Establish the starting RPI in this header block. The starting 5158 * rpi is normalized to a zero base because the physical rpi is 5159 * port based. 5160 */ 5161 curr_rpi_range = phba->sli4_hba.next_rpi - 5162 phba->sli4_hba.max_cfg_param.rpi_base; 5163 spin_unlock_irq(&phba->hbalock); 5164 5165 /* 5166 * The port has a limited number of rpis. The increment here 5167 * is LPFC_RPI_HDR_COUNT - 1 to account for the starting value 5168 * and to allow the full max_rpi range per port. 5169 */ 5170 if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit) 5171 rpi_count = rpi_limit - curr_rpi_range; 5172 else 5173 rpi_count = LPFC_RPI_HDR_COUNT; 5174 5175 if (!rpi_count) 5176 return NULL; 5177 /* 5178 * First allocate the protocol header region for the port. The 5179 * port expects a 4KB DMA-mapped memory region that is 4K aligned. 5180 */ 5181 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 5182 if (!dmabuf) 5183 return NULL; 5184 5185 dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, 5186 LPFC_HDR_TEMPLATE_SIZE, 5187 &dmabuf->phys, 5188 GFP_KERNEL); 5189 if (!dmabuf->virt) { 5190 rpi_hdr = NULL; 5191 goto err_free_dmabuf; 5192 } 5193 5194 memset(dmabuf->virt, 0, LPFC_HDR_TEMPLATE_SIZE); 5195 if (!IS_ALIGNED(dmabuf->phys, LPFC_HDR_TEMPLATE_SIZE)) { 5196 rpi_hdr = NULL; 5197 goto err_free_coherent; 5198 } 5199 5200 /* Save the rpi header data for cleanup later. */ 5201 rpi_hdr = kzalloc(sizeof(struct lpfc_rpi_hdr), GFP_KERNEL); 5202 if (!rpi_hdr) 5203 goto err_free_coherent; 5204 5205 rpi_hdr->dmabuf = dmabuf; 5206 rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE; 5207 rpi_hdr->page_count = 1; 5208 spin_lock_irq(&phba->hbalock); 5209 5210 /* The rpi_hdr stores the logical index only. */ 5211 rpi_hdr->start_rpi = curr_rpi_range; 5212 list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list); 5213 5214 /* 5215 * The next_rpi stores the next logical module-64 rpi value used 5216 * to post physical rpis in subsequent rpi postings. 5217 */ 5218 phba->sli4_hba.next_rpi += rpi_count; 5219 spin_unlock_irq(&phba->hbalock); 5220 return rpi_hdr; 5221 5222 err_free_coherent: 5223 dma_free_coherent(&phba->pcidev->dev, LPFC_HDR_TEMPLATE_SIZE, 5224 dmabuf->virt, dmabuf->phys); 5225 err_free_dmabuf: 5226 kfree(dmabuf); 5227 return NULL; 5228 } 5229 5230 /** 5231 * lpfc_sli4_remove_rpi_hdrs - Remove all rpi header memory regions 5232 * @phba: pointer to lpfc hba data structure. 5233 * 5234 * This routine is invoked to remove all memory resources allocated 5235 * to support rpis for SLI4 ports not supporting extents. This routine 5236 * presumes the caller has released all rpis consumed by fabric or port 5237 * logins and is prepared to have the header pages removed. 5238 **/ 5239 void 5240 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba) 5241 { 5242 struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr; 5243 5244 if (!phba->sli4_hba.rpi_hdrs_in_use) 5245 goto exit; 5246 5247 list_for_each_entry_safe(rpi_hdr, next_rpi_hdr, 5248 &phba->sli4_hba.lpfc_rpi_hdr_list, list) { 5249 list_del(&rpi_hdr->list); 5250 dma_free_coherent(&phba->pcidev->dev, rpi_hdr->len, 5251 rpi_hdr->dmabuf->virt, rpi_hdr->dmabuf->phys); 5252 kfree(rpi_hdr->dmabuf); 5253 kfree(rpi_hdr); 5254 } 5255 exit: 5256 /* There are no rpis available to the port now. */ 5257 phba->sli4_hba.next_rpi = 0; 5258 } 5259 5260 /** 5261 * lpfc_hba_alloc - Allocate driver hba data structure for a device. 5262 * @pdev: pointer to pci device data structure. 5263 * 5264 * This routine is invoked to allocate the driver hba data structure for an 5265 * HBA device. If the allocation is successful, the phba reference to the 5266 * PCI device data structure is set. 5267 * 5268 * Return codes 5269 * pointer to @phba - successful 5270 * NULL - error 5271 **/ 5272 static struct lpfc_hba * 5273 lpfc_hba_alloc(struct pci_dev *pdev) 5274 { 5275 struct lpfc_hba *phba; 5276 5277 /* Allocate memory for HBA structure */ 5278 phba = kzalloc(sizeof(struct lpfc_hba), GFP_KERNEL); 5279 if (!phba) { 5280 dev_err(&pdev->dev, "failed to allocate hba struct\n"); 5281 return NULL; 5282 } 5283 5284 /* Set reference to PCI device in HBA structure */ 5285 phba->pcidev = pdev; 5286 5287 /* Assign an unused board number */ 5288 phba->brd_no = lpfc_get_instance(); 5289 if (phba->brd_no < 0) { 5290 kfree(phba); 5291 return NULL; 5292 } 5293 5294 spin_lock_init(&phba->ct_ev_lock); 5295 INIT_LIST_HEAD(&phba->ct_ev_waiters); 5296 5297 return phba; 5298 } 5299 5300 /** 5301 * lpfc_hba_free - Free driver hba data structure with a device. 5302 * @phba: pointer to lpfc hba data structure. 5303 * 5304 * This routine is invoked to free the driver hba data structure with an 5305 * HBA device. 5306 **/ 5307 static void 5308 lpfc_hba_free(struct lpfc_hba *phba) 5309 { 5310 /* Release the driver assigned board number */ 5311 idr_remove(&lpfc_hba_index, phba->brd_no); 5312 5313 kfree(phba); 5314 return; 5315 } 5316 5317 /** 5318 * lpfc_create_shost - Create hba physical port with associated scsi host. 5319 * @phba: pointer to lpfc hba data structure. 5320 * 5321 * This routine is invoked to create HBA physical port and associate a SCSI 5322 * host with it. 5323 * 5324 * Return codes 5325 * 0 - successful 5326 * other values - error 5327 **/ 5328 static int 5329 lpfc_create_shost(struct lpfc_hba *phba) 5330 { 5331 struct lpfc_vport *vport; 5332 struct Scsi_Host *shost; 5333 5334 /* Initialize HBA FC structure */ 5335 phba->fc_edtov = FF_DEF_EDTOV; 5336 phba->fc_ratov = FF_DEF_RATOV; 5337 phba->fc_altov = FF_DEF_ALTOV; 5338 phba->fc_arbtov = FF_DEF_ARBTOV; 5339 5340 atomic_set(&phba->sdev_cnt, 0); 5341 vport = lpfc_create_port(phba, phba->brd_no, &phba->pcidev->dev); 5342 if (!vport) 5343 return -ENODEV; 5344 5345 shost = lpfc_shost_from_vport(vport); 5346 phba->pport = vport; 5347 lpfc_debugfs_initialize(vport); 5348 /* Put reference to SCSI host to driver's device private data */ 5349 pci_set_drvdata(phba->pcidev, shost); 5350 5351 return 0; 5352 } 5353 5354 /** 5355 * lpfc_destroy_shost - Destroy hba physical port with associated scsi host. 5356 * @phba: pointer to lpfc hba data structure. 5357 * 5358 * This routine is invoked to destroy HBA physical port and the associated 5359 * SCSI host. 5360 **/ 5361 static void 5362 lpfc_destroy_shost(struct lpfc_hba *phba) 5363 { 5364 struct lpfc_vport *vport = phba->pport; 5365 5366 /* Destroy physical port that associated with the SCSI host */ 5367 destroy_port(vport); 5368 5369 return; 5370 } 5371 5372 /** 5373 * lpfc_setup_bg - Setup Block guard structures and debug areas. 5374 * @phba: pointer to lpfc hba data structure. 5375 * @shost: the shost to be used to detect Block guard settings. 5376 * 5377 * This routine sets up the local Block guard protocol settings for @shost. 5378 * This routine also allocates memory for debugging bg buffers. 5379 **/ 5380 static void 5381 lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost) 5382 { 5383 int pagecnt = 10; 5384 if (lpfc_prot_mask && lpfc_prot_guard) { 5385 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 5386 "1478 Registering BlockGuard with the " 5387 "SCSI layer\n"); 5388 scsi_host_set_prot(shost, lpfc_prot_mask); 5389 scsi_host_set_guard(shost, lpfc_prot_guard); 5390 } 5391 if (!_dump_buf_data) { 5392 while (pagecnt) { 5393 spin_lock_init(&_dump_buf_lock); 5394 _dump_buf_data = 5395 (char *) __get_free_pages(GFP_KERNEL, pagecnt); 5396 if (_dump_buf_data) { 5397 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5398 "9043 BLKGRD: allocated %d pages for " 5399 "_dump_buf_data at 0x%p\n", 5400 (1 << pagecnt), _dump_buf_data); 5401 _dump_buf_data_order = pagecnt; 5402 memset(_dump_buf_data, 0, 5403 ((1 << PAGE_SHIFT) << pagecnt)); 5404 break; 5405 } else 5406 --pagecnt; 5407 } 5408 if (!_dump_buf_data_order) 5409 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5410 "9044 BLKGRD: ERROR unable to allocate " 5411 "memory for hexdump\n"); 5412 } else 5413 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5414 "9045 BLKGRD: already allocated _dump_buf_data=0x%p" 5415 "\n", _dump_buf_data); 5416 if (!_dump_buf_dif) { 5417 while (pagecnt) { 5418 _dump_buf_dif = 5419 (char *) __get_free_pages(GFP_KERNEL, pagecnt); 5420 if (_dump_buf_dif) { 5421 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5422 "9046 BLKGRD: allocated %d pages for " 5423 "_dump_buf_dif at 0x%p\n", 5424 (1 << pagecnt), _dump_buf_dif); 5425 _dump_buf_dif_order = pagecnt; 5426 memset(_dump_buf_dif, 0, 5427 ((1 << PAGE_SHIFT) << pagecnt)); 5428 break; 5429 } else 5430 --pagecnt; 5431 } 5432 if (!_dump_buf_dif_order) 5433 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5434 "9047 BLKGRD: ERROR unable to allocate " 5435 "memory for hexdump\n"); 5436 } else 5437 lpfc_printf_log(phba, KERN_ERR, LOG_BG, 5438 "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n", 5439 _dump_buf_dif); 5440 } 5441 5442 /** 5443 * lpfc_post_init_setup - Perform necessary device post initialization setup. 5444 * @phba: pointer to lpfc hba data structure. 5445 * 5446 * This routine is invoked to perform all the necessary post initialization 5447 * setup for the device. 5448 **/ 5449 static void 5450 lpfc_post_init_setup(struct lpfc_hba *phba) 5451 { 5452 struct Scsi_Host *shost; 5453 struct lpfc_adapter_event_header adapter_event; 5454 5455 /* Get the default values for Model Name and Description */ 5456 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc); 5457 5458 /* 5459 * hba setup may have changed the hba_queue_depth so we need to 5460 * adjust the value of can_queue. 5461 */ 5462 shost = pci_get_drvdata(phba->pcidev); 5463 shost->can_queue = phba->cfg_hba_queue_depth - 10; 5464 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED) 5465 lpfc_setup_bg(phba, shost); 5466 5467 lpfc_host_attrib_init(shost); 5468 5469 if (phba->cfg_poll & DISABLE_FCP_RING_INT) { 5470 spin_lock_irq(shost->host_lock); 5471 lpfc_poll_start_timer(phba); 5472 spin_unlock_irq(shost->host_lock); 5473 } 5474 5475 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 5476 "0428 Perform SCSI scan\n"); 5477 /* Send board arrival event to upper layer */ 5478 adapter_event.event_type = FC_REG_ADAPTER_EVENT; 5479 adapter_event.subcategory = LPFC_EVENT_ARRIVAL; 5480 fc_host_post_vendor_event(shost, fc_get_event_number(), 5481 sizeof(adapter_event), 5482 (char *) &adapter_event, 5483 LPFC_NL_VENDOR_ID); 5484 return; 5485 } 5486 5487 /** 5488 * lpfc_sli_pci_mem_setup - Setup SLI3 HBA PCI memory space. 5489 * @phba: pointer to lpfc hba data structure. 5490 * 5491 * This routine is invoked to set up the PCI device memory space for device 5492 * with SLI-3 interface spec. 5493 * 5494 * Return codes 5495 * 0 - successful 5496 * other values - error 5497 **/ 5498 static int 5499 lpfc_sli_pci_mem_setup(struct lpfc_hba *phba) 5500 { 5501 struct pci_dev *pdev; 5502 unsigned long bar0map_len, bar2map_len; 5503 int i, hbq_count; 5504 void *ptr; 5505 int error = -ENODEV; 5506 5507 /* Obtain PCI device reference */ 5508 if (!phba->pcidev) 5509 return error; 5510 else 5511 pdev = phba->pcidev; 5512 5513 /* Set the device DMA mask size */ 5514 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0 5515 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) { 5516 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0 5517 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) { 5518 return error; 5519 } 5520 } 5521 5522 /* Get the bus address of Bar0 and Bar2 and the number of bytes 5523 * required by each mapping. 5524 */ 5525 phba->pci_bar0_map = pci_resource_start(pdev, 0); 5526 bar0map_len = pci_resource_len(pdev, 0); 5527 5528 phba->pci_bar2_map = pci_resource_start(pdev, 2); 5529 bar2map_len = pci_resource_len(pdev, 2); 5530 5531 /* Map HBA SLIM to a kernel virtual address. */ 5532 phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len); 5533 if (!phba->slim_memmap_p) { 5534 dev_printk(KERN_ERR, &pdev->dev, 5535 "ioremap failed for SLIM memory.\n"); 5536 goto out; 5537 } 5538 5539 /* Map HBA Control Registers to a kernel virtual address. */ 5540 phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len); 5541 if (!phba->ctrl_regs_memmap_p) { 5542 dev_printk(KERN_ERR, &pdev->dev, 5543 "ioremap failed for HBA control registers.\n"); 5544 goto out_iounmap_slim; 5545 } 5546 5547 /* Allocate memory for SLI-2 structures */ 5548 phba->slim2p.virt = dma_alloc_coherent(&pdev->dev, 5549 SLI2_SLIM_SIZE, 5550 &phba->slim2p.phys, 5551 GFP_KERNEL); 5552 if (!phba->slim2p.virt) 5553 goto out_iounmap; 5554 5555 memset(phba->slim2p.virt, 0, SLI2_SLIM_SIZE); 5556 phba->mbox = phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, mbx); 5557 phba->mbox_ext = (phba->slim2p.virt + 5558 offsetof(struct lpfc_sli2_slim, mbx_ext_words)); 5559 phba->pcb = (phba->slim2p.virt + offsetof(struct lpfc_sli2_slim, pcb)); 5560 phba->IOCBs = (phba->slim2p.virt + 5561 offsetof(struct lpfc_sli2_slim, IOCBs)); 5562 5563 phba->hbqslimp.virt = dma_alloc_coherent(&pdev->dev, 5564 lpfc_sli_hbq_size(), 5565 &phba->hbqslimp.phys, 5566 GFP_KERNEL); 5567 if (!phba->hbqslimp.virt) 5568 goto out_free_slim; 5569 5570 hbq_count = lpfc_sli_hbq_count(); 5571 ptr = phba->hbqslimp.virt; 5572 for (i = 0; i < hbq_count; ++i) { 5573 phba->hbqs[i].hbq_virt = ptr; 5574 INIT_LIST_HEAD(&phba->hbqs[i].hbq_buffer_list); 5575 ptr += (lpfc_hbq_defs[i]->entry_count * 5576 sizeof(struct lpfc_hbq_entry)); 5577 } 5578 phba->hbqs[LPFC_ELS_HBQ].hbq_alloc_buffer = lpfc_els_hbq_alloc; 5579 phba->hbqs[LPFC_ELS_HBQ].hbq_free_buffer = lpfc_els_hbq_free; 5580 5581 memset(phba->hbqslimp.virt, 0, lpfc_sli_hbq_size()); 5582 5583 INIT_LIST_HEAD(&phba->rb_pend_list); 5584 5585 phba->MBslimaddr = phba->slim_memmap_p; 5586 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET; 5587 phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET; 5588 phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET; 5589 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET; 5590 5591 return 0; 5592 5593 out_free_slim: 5594 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE, 5595 phba->slim2p.virt, phba->slim2p.phys); 5596 out_iounmap: 5597 iounmap(phba->ctrl_regs_memmap_p); 5598 out_iounmap_slim: 5599 iounmap(phba->slim_memmap_p); 5600 out: 5601 return error; 5602 } 5603 5604 /** 5605 * lpfc_sli_pci_mem_unset - Unset SLI3 HBA PCI memory space. 5606 * @phba: pointer to lpfc hba data structure. 5607 * 5608 * This routine is invoked to unset the PCI device memory space for device 5609 * with SLI-3 interface spec. 5610 **/ 5611 static void 5612 lpfc_sli_pci_mem_unset(struct lpfc_hba *phba) 5613 { 5614 struct pci_dev *pdev; 5615 5616 /* Obtain PCI device reference */ 5617 if (!phba->pcidev) 5618 return; 5619 else 5620 pdev = phba->pcidev; 5621 5622 /* Free coherent DMA memory allocated */ 5623 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(), 5624 phba->hbqslimp.virt, phba->hbqslimp.phys); 5625 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE, 5626 phba->slim2p.virt, phba->slim2p.phys); 5627 5628 /* I/O memory unmap */ 5629 iounmap(phba->ctrl_regs_memmap_p); 5630 iounmap(phba->slim_memmap_p); 5631 5632 return; 5633 } 5634 5635 /** 5636 * lpfc_sli4_post_status_check - Wait for SLI4 POST done and check status 5637 * @phba: pointer to lpfc hba data structure. 5638 * 5639 * This routine is invoked to wait for SLI4 device Power On Self Test (POST) 5640 * done and check status. 5641 * 5642 * Return 0 if successful, otherwise -ENODEV. 5643 **/ 5644 int 5645 lpfc_sli4_post_status_check(struct lpfc_hba *phba) 5646 { 5647 struct lpfc_register portsmphr_reg, uerrlo_reg, uerrhi_reg; 5648 struct lpfc_register reg_data; 5649 int i, port_error = 0; 5650 uint32_t if_type; 5651 5652 memset(&portsmphr_reg, 0, sizeof(portsmphr_reg)); 5653 memset(®_data, 0, sizeof(reg_data)); 5654 if (!phba->sli4_hba.PSMPHRregaddr) 5655 return -ENODEV; 5656 5657 /* Wait up to 30 seconds for the SLI Port POST done and ready */ 5658 for (i = 0; i < 3000; i++) { 5659 if (lpfc_readl(phba->sli4_hba.PSMPHRregaddr, 5660 &portsmphr_reg.word0) || 5661 (bf_get(lpfc_port_smphr_perr, &portsmphr_reg))) { 5662 /* Port has a fatal POST error, break out */ 5663 port_error = -ENODEV; 5664 break; 5665 } 5666 if (LPFC_POST_STAGE_PORT_READY == 5667 bf_get(lpfc_port_smphr_port_status, &portsmphr_reg)) 5668 break; 5669 msleep(10); 5670 } 5671 5672 /* 5673 * If there was a port error during POST, then don't proceed with 5674 * other register reads as the data may not be valid. Just exit. 5675 */ 5676 if (port_error) { 5677 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 5678 "1408 Port Failed POST - portsmphr=0x%x, " 5679 "perr=x%x, sfi=x%x, nip=x%x, ipc=x%x, scr1=x%x, " 5680 "scr2=x%x, hscratch=x%x, pstatus=x%x\n", 5681 portsmphr_reg.word0, 5682 bf_get(lpfc_port_smphr_perr, &portsmphr_reg), 5683 bf_get(lpfc_port_smphr_sfi, &portsmphr_reg), 5684 bf_get(lpfc_port_smphr_nip, &portsmphr_reg), 5685 bf_get(lpfc_port_smphr_ipc, &portsmphr_reg), 5686 bf_get(lpfc_port_smphr_scr1, &portsmphr_reg), 5687 bf_get(lpfc_port_smphr_scr2, &portsmphr_reg), 5688 bf_get(lpfc_port_smphr_host_scratch, &portsmphr_reg), 5689 bf_get(lpfc_port_smphr_port_status, &portsmphr_reg)); 5690 } else { 5691 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 5692 "2534 Device Info: SLIFamily=0x%x, " 5693 "SLIRev=0x%x, IFType=0x%x, SLIHint_1=0x%x, " 5694 "SLIHint_2=0x%x, FT=0x%x\n", 5695 bf_get(lpfc_sli_intf_sli_family, 5696 &phba->sli4_hba.sli_intf), 5697 bf_get(lpfc_sli_intf_slirev, 5698 &phba->sli4_hba.sli_intf), 5699 bf_get(lpfc_sli_intf_if_type, 5700 &phba->sli4_hba.sli_intf), 5701 bf_get(lpfc_sli_intf_sli_hint1, 5702 &phba->sli4_hba.sli_intf), 5703 bf_get(lpfc_sli_intf_sli_hint2, 5704 &phba->sli4_hba.sli_intf), 5705 bf_get(lpfc_sli_intf_func_type, 5706 &phba->sli4_hba.sli_intf)); 5707 /* 5708 * Check for other Port errors during the initialization 5709 * process. Fail the load if the port did not come up 5710 * correctly. 5711 */ 5712 if_type = bf_get(lpfc_sli_intf_if_type, 5713 &phba->sli4_hba.sli_intf); 5714 switch (if_type) { 5715 case LPFC_SLI_INTF_IF_TYPE_0: 5716 phba->sli4_hba.ue_mask_lo = 5717 readl(phba->sli4_hba.u.if_type0.UEMASKLOregaddr); 5718 phba->sli4_hba.ue_mask_hi = 5719 readl(phba->sli4_hba.u.if_type0.UEMASKHIregaddr); 5720 uerrlo_reg.word0 = 5721 readl(phba->sli4_hba.u.if_type0.UERRLOregaddr); 5722 uerrhi_reg.word0 = 5723 readl(phba->sli4_hba.u.if_type0.UERRHIregaddr); 5724 if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) || 5725 (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) { 5726 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 5727 "1422 Unrecoverable Error " 5728 "Detected during POST " 5729 "uerr_lo_reg=0x%x, " 5730 "uerr_hi_reg=0x%x, " 5731 "ue_mask_lo_reg=0x%x, " 5732 "ue_mask_hi_reg=0x%x\n", 5733 uerrlo_reg.word0, 5734 uerrhi_reg.word0, 5735 phba->sli4_hba.ue_mask_lo, 5736 phba->sli4_hba.ue_mask_hi); 5737 port_error = -ENODEV; 5738 } 5739 break; 5740 case LPFC_SLI_INTF_IF_TYPE_2: 5741 /* Final checks. The port status should be clean. */ 5742 if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr, 5743 ®_data.word0) || 5744 (bf_get(lpfc_sliport_status_err, ®_data) && 5745 !bf_get(lpfc_sliport_status_rn, ®_data))) { 5746 phba->work_status[0] = 5747 readl(phba->sli4_hba.u.if_type2. 5748 ERR1regaddr); 5749 phba->work_status[1] = 5750 readl(phba->sli4_hba.u.if_type2. 5751 ERR2regaddr); 5752 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 5753 "2888 Port Error Detected " 5754 "during POST: " 5755 "port status reg 0x%x, " 5756 "port_smphr reg 0x%x, " 5757 "error 1=0x%x, error 2=0x%x\n", 5758 reg_data.word0, 5759 portsmphr_reg.word0, 5760 phba->work_status[0], 5761 phba->work_status[1]); 5762 port_error = -ENODEV; 5763 } 5764 break; 5765 case LPFC_SLI_INTF_IF_TYPE_1: 5766 default: 5767 break; 5768 } 5769 } 5770 return port_error; 5771 } 5772 5773 /** 5774 * lpfc_sli4_bar0_register_memmap - Set up SLI4 BAR0 register memory map. 5775 * @phba: pointer to lpfc hba data structure. 5776 * @if_type: The SLI4 interface type getting configured. 5777 * 5778 * This routine is invoked to set up SLI4 BAR0 PCI config space register 5779 * memory map. 5780 **/ 5781 static void 5782 lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba, uint32_t if_type) 5783 { 5784 switch (if_type) { 5785 case LPFC_SLI_INTF_IF_TYPE_0: 5786 phba->sli4_hba.u.if_type0.UERRLOregaddr = 5787 phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_LO; 5788 phba->sli4_hba.u.if_type0.UERRHIregaddr = 5789 phba->sli4_hba.conf_regs_memmap_p + LPFC_UERR_STATUS_HI; 5790 phba->sli4_hba.u.if_type0.UEMASKLOregaddr = 5791 phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_LO; 5792 phba->sli4_hba.u.if_type0.UEMASKHIregaddr = 5793 phba->sli4_hba.conf_regs_memmap_p + LPFC_UE_MASK_HI; 5794 phba->sli4_hba.SLIINTFregaddr = 5795 phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF; 5796 break; 5797 case LPFC_SLI_INTF_IF_TYPE_2: 5798 phba->sli4_hba.u.if_type2.ERR1regaddr = 5799 phba->sli4_hba.conf_regs_memmap_p + 5800 LPFC_CTL_PORT_ER1_OFFSET; 5801 phba->sli4_hba.u.if_type2.ERR2regaddr = 5802 phba->sli4_hba.conf_regs_memmap_p + 5803 LPFC_CTL_PORT_ER2_OFFSET; 5804 phba->sli4_hba.u.if_type2.CTRLregaddr = 5805 phba->sli4_hba.conf_regs_memmap_p + 5806 LPFC_CTL_PORT_CTL_OFFSET; 5807 phba->sli4_hba.u.if_type2.STATUSregaddr = 5808 phba->sli4_hba.conf_regs_memmap_p + 5809 LPFC_CTL_PORT_STA_OFFSET; 5810 phba->sli4_hba.SLIINTFregaddr = 5811 phba->sli4_hba.conf_regs_memmap_p + LPFC_SLI_INTF; 5812 phba->sli4_hba.PSMPHRregaddr = 5813 phba->sli4_hba.conf_regs_memmap_p + 5814 LPFC_CTL_PORT_SEM_OFFSET; 5815 phba->sli4_hba.RQDBregaddr = 5816 phba->sli4_hba.conf_regs_memmap_p + LPFC_RQ_DOORBELL; 5817 phba->sli4_hba.WQDBregaddr = 5818 phba->sli4_hba.conf_regs_memmap_p + LPFC_WQ_DOORBELL; 5819 phba->sli4_hba.EQCQDBregaddr = 5820 phba->sli4_hba.conf_regs_memmap_p + LPFC_EQCQ_DOORBELL; 5821 phba->sli4_hba.MQDBregaddr = 5822 phba->sli4_hba.conf_regs_memmap_p + LPFC_MQ_DOORBELL; 5823 phba->sli4_hba.BMBXregaddr = 5824 phba->sli4_hba.conf_regs_memmap_p + LPFC_BMBX; 5825 break; 5826 case LPFC_SLI_INTF_IF_TYPE_1: 5827 default: 5828 dev_printk(KERN_ERR, &phba->pcidev->dev, 5829 "FATAL - unsupported SLI4 interface type - %d\n", 5830 if_type); 5831 break; 5832 } 5833 } 5834 5835 /** 5836 * lpfc_sli4_bar1_register_memmap - Set up SLI4 BAR1 register memory map. 5837 * @phba: pointer to lpfc hba data structure. 5838 * 5839 * This routine is invoked to set up SLI4 BAR1 control status register (CSR) 5840 * memory map. 5841 **/ 5842 static void 5843 lpfc_sli4_bar1_register_memmap(struct lpfc_hba *phba) 5844 { 5845 phba->sli4_hba.PSMPHRregaddr = phba->sli4_hba.ctrl_regs_memmap_p + 5846 LPFC_SLIPORT_IF0_SMPHR; 5847 phba->sli4_hba.ISRregaddr = phba->sli4_hba.ctrl_regs_memmap_p + 5848 LPFC_HST_ISR0; 5849 phba->sli4_hba.IMRregaddr = phba->sli4_hba.ctrl_regs_memmap_p + 5850 LPFC_HST_IMR0; 5851 phba->sli4_hba.ISCRregaddr = phba->sli4_hba.ctrl_regs_memmap_p + 5852 LPFC_HST_ISCR0; 5853 } 5854 5855 /** 5856 * lpfc_sli4_bar2_register_memmap - Set up SLI4 BAR2 register memory map. 5857 * @phba: pointer to lpfc hba data structure. 5858 * @vf: virtual function number 5859 * 5860 * This routine is invoked to set up SLI4 BAR2 doorbell register memory map 5861 * based on the given viftual function number, @vf. 5862 * 5863 * Return 0 if successful, otherwise -ENODEV. 5864 **/ 5865 static int 5866 lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf) 5867 { 5868 if (vf > LPFC_VIR_FUNC_MAX) 5869 return -ENODEV; 5870 5871 phba->sli4_hba.RQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p + 5872 vf * LPFC_VFR_PAGE_SIZE + LPFC_RQ_DOORBELL); 5873 phba->sli4_hba.WQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p + 5874 vf * LPFC_VFR_PAGE_SIZE + LPFC_WQ_DOORBELL); 5875 phba->sli4_hba.EQCQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p + 5876 vf * LPFC_VFR_PAGE_SIZE + LPFC_EQCQ_DOORBELL); 5877 phba->sli4_hba.MQDBregaddr = (phba->sli4_hba.drbl_regs_memmap_p + 5878 vf * LPFC_VFR_PAGE_SIZE + LPFC_MQ_DOORBELL); 5879 phba->sli4_hba.BMBXregaddr = (phba->sli4_hba.drbl_regs_memmap_p + 5880 vf * LPFC_VFR_PAGE_SIZE + LPFC_BMBX); 5881 return 0; 5882 } 5883 5884 /** 5885 * lpfc_create_bootstrap_mbox - Create the bootstrap mailbox 5886 * @phba: pointer to lpfc hba data structure. 5887 * 5888 * This routine is invoked to create the bootstrap mailbox 5889 * region consistent with the SLI-4 interface spec. This 5890 * routine allocates all memory necessary to communicate 5891 * mailbox commands to the port and sets up all alignment 5892 * needs. No locks are expected to be held when calling 5893 * this routine. 5894 * 5895 * Return codes 5896 * 0 - successful 5897 * -ENOMEM - could not allocated memory. 5898 **/ 5899 static int 5900 lpfc_create_bootstrap_mbox(struct lpfc_hba *phba) 5901 { 5902 uint32_t bmbx_size; 5903 struct lpfc_dmabuf *dmabuf; 5904 struct dma_address *dma_address; 5905 uint32_t pa_addr; 5906 uint64_t phys_addr; 5907 5908 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL); 5909 if (!dmabuf) 5910 return -ENOMEM; 5911 5912 /* 5913 * The bootstrap mailbox region is comprised of 2 parts 5914 * plus an alignment restriction of 16 bytes. 5915 */ 5916 bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1); 5917 dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, 5918 bmbx_size, 5919 &dmabuf->phys, 5920 GFP_KERNEL); 5921 if (!dmabuf->virt) { 5922 kfree(dmabuf); 5923 return -ENOMEM; 5924 } 5925 memset(dmabuf->virt, 0, bmbx_size); 5926 5927 /* 5928 * Initialize the bootstrap mailbox pointers now so that the register 5929 * operations are simple later. The mailbox dma address is required 5930 * to be 16-byte aligned. Also align the virtual memory as each 5931 * maibox is copied into the bmbx mailbox region before issuing the 5932 * command to the port. 5933 */ 5934 phba->sli4_hba.bmbx.dmabuf = dmabuf; 5935 phba->sli4_hba.bmbx.bmbx_size = bmbx_size; 5936 5937 phba->sli4_hba.bmbx.avirt = PTR_ALIGN(dmabuf->virt, 5938 LPFC_ALIGN_16_BYTE); 5939 phba->sli4_hba.bmbx.aphys = ALIGN(dmabuf->phys, 5940 LPFC_ALIGN_16_BYTE); 5941 5942 /* 5943 * Set the high and low physical addresses now. The SLI4 alignment 5944 * requirement is 16 bytes and the mailbox is posted to the port 5945 * as two 30-bit addresses. The other data is a bit marking whether 5946 * the 30-bit address is the high or low address. 5947 * Upcast bmbx aphys to 64bits so shift instruction compiles 5948 * clean on 32 bit machines. 5949 */ 5950 dma_address = &phba->sli4_hba.bmbx.dma_address; 5951 phys_addr = (uint64_t)phba->sli4_hba.bmbx.aphys; 5952 pa_addr = (uint32_t) ((phys_addr >> 34) & 0x3fffffff); 5953 dma_address->addr_hi = (uint32_t) ((pa_addr << 2) | 5954 LPFC_BMBX_BIT1_ADDR_HI); 5955 5956 pa_addr = (uint32_t) ((phba->sli4_hba.bmbx.aphys >> 4) & 0x3fffffff); 5957 dma_address->addr_lo = (uint32_t) ((pa_addr << 2) | 5958 LPFC_BMBX_BIT1_ADDR_LO); 5959 return 0; 5960 } 5961 5962 /** 5963 * lpfc_destroy_bootstrap_mbox - Destroy all bootstrap mailbox resources 5964 * @phba: pointer to lpfc hba data structure. 5965 * 5966 * This routine is invoked to teardown the bootstrap mailbox 5967 * region and release all host resources. This routine requires 5968 * the caller to ensure all mailbox commands recovered, no 5969 * additional mailbox comands are sent, and interrupts are disabled 5970 * before calling this routine. 5971 * 5972 **/ 5973 static void 5974 lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba) 5975 { 5976 dma_free_coherent(&phba->pcidev->dev, 5977 phba->sli4_hba.bmbx.bmbx_size, 5978 phba->sli4_hba.bmbx.dmabuf->virt, 5979 phba->sli4_hba.bmbx.dmabuf->phys); 5980 5981 kfree(phba->sli4_hba.bmbx.dmabuf); 5982 memset(&phba->sli4_hba.bmbx, 0, sizeof(struct lpfc_bmbx)); 5983 } 5984 5985 /** 5986 * lpfc_sli4_read_config - Get the config parameters. 5987 * @phba: pointer to lpfc hba data structure. 5988 * 5989 * This routine is invoked to read the configuration parameters from the HBA. 5990 * The configuration parameters are used to set the base and maximum values 5991 * for RPI's XRI's VPI's VFI's and FCFIs. These values also affect the resource 5992 * allocation for the port. 5993 * 5994 * Return codes 5995 * 0 - successful 5996 * -ENOMEM - No available memory 5997 * -EIO - The mailbox failed to complete successfully. 5998 **/ 5999 int 6000 lpfc_sli4_read_config(struct lpfc_hba *phba) 6001 { 6002 LPFC_MBOXQ_t *pmb; 6003 struct lpfc_mbx_read_config *rd_config; 6004 union lpfc_sli4_cfg_shdr *shdr; 6005 uint32_t shdr_status, shdr_add_status; 6006 struct lpfc_mbx_get_func_cfg *get_func_cfg; 6007 struct lpfc_rsrc_desc_fcfcoe *desc; 6008 uint32_t desc_count; 6009 int length, i, rc = 0; 6010 6011 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 6012 if (!pmb) { 6013 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 6014 "2011 Unable to allocate memory for issuing " 6015 "SLI_CONFIG_SPECIAL mailbox command\n"); 6016 return -ENOMEM; 6017 } 6018 6019 lpfc_read_config(phba, pmb); 6020 6021 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 6022 if (rc != MBX_SUCCESS) { 6023 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 6024 "2012 Mailbox failed , mbxCmd x%x " 6025 "READ_CONFIG, mbxStatus x%x\n", 6026 bf_get(lpfc_mqe_command, &pmb->u.mqe), 6027 bf_get(lpfc_mqe_status, &pmb->u.mqe)); 6028 rc = -EIO; 6029 } else { 6030 rd_config = &pmb->u.mqe.un.rd_config; 6031 if (bf_get(lpfc_mbx_rd_conf_lnk_ldv, rd_config)) { 6032 phba->sli4_hba.lnk_info.lnk_dv = LPFC_LNK_DAT_VAL; 6033 phba->sli4_hba.lnk_info.lnk_tp = 6034 bf_get(lpfc_mbx_rd_conf_lnk_type, rd_config); 6035 phba->sli4_hba.lnk_info.lnk_no = 6036 bf_get(lpfc_mbx_rd_conf_lnk_numb, rd_config); 6037 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 6038 "3081 lnk_type:%d, lnk_numb:%d\n", 6039 phba->sli4_hba.lnk_info.lnk_tp, 6040 phba->sli4_hba.lnk_info.lnk_no); 6041 } else 6042 lpfc_printf_log(phba, KERN_WARNING, LOG_SLI, 6043 "3082 Mailbox (x%x) returned ldv:x0\n", 6044 bf_get(lpfc_mqe_command, &pmb->u.mqe)); 6045 phba->sli4_hba.extents_in_use = 6046 bf_get(lpfc_mbx_rd_conf_extnts_inuse, rd_config); 6047 phba->sli4_hba.max_cfg_param.max_xri = 6048 bf_get(lpfc_mbx_rd_conf_xri_count, rd_config); 6049 phba->sli4_hba.max_cfg_param.xri_base = 6050 bf_get(lpfc_mbx_rd_conf_xri_base, rd_config); 6051 phba->sli4_hba.max_cfg_param.max_vpi = 6052 bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config); 6053 phba->sli4_hba.max_cfg_param.vpi_base = 6054 bf_get(lpfc_mbx_rd_conf_vpi_base, rd_config); 6055 phba->sli4_hba.max_cfg_param.max_rpi = 6056 bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config); 6057 phba->sli4_hba.max_cfg_param.rpi_base = 6058 bf_get(lpfc_mbx_rd_conf_rpi_base, rd_config); 6059 phba->sli4_hba.max_cfg_param.max_vfi = 6060 bf_get(lpfc_mbx_rd_conf_vfi_count, rd_config); 6061 phba->sli4_hba.max_cfg_param.vfi_base = 6062 bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config); 6063 phba->sli4_hba.max_cfg_param.max_fcfi = 6064 bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config); 6065 phba->sli4_hba.max_cfg_param.max_eq = 6066 bf_get(lpfc_mbx_rd_conf_eq_count, rd_config); 6067 phba->sli4_hba.max_cfg_param.max_rq = 6068 bf_get(lpfc_mbx_rd_conf_rq_count, rd_config); 6069 phba->sli4_hba.max_cfg_param.max_wq = 6070 bf_get(lpfc_mbx_rd_conf_wq_count, rd_config); 6071 phba->sli4_hba.max_cfg_param.max_cq = 6072 bf_get(lpfc_mbx_rd_conf_cq_count, rd_config); 6073 phba->lmt = bf_get(lpfc_mbx_rd_conf_lmt, rd_config); 6074 phba->sli4_hba.next_xri = phba->sli4_hba.max_cfg_param.xri_base; 6075 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base; 6076 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base; 6077 phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base; 6078 phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ? 6079 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0; 6080 phba->max_vports = phba->max_vpi; 6081 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 6082 "2003 cfg params Extents? %d " 6083 "XRI(B:%d M:%d), " 6084 "VPI(B:%d M:%d) " 6085 "VFI(B:%d M:%d) " 6086 "RPI(B:%d M:%d) " 6087 "FCFI(Count:%d)\n", 6088 phba->sli4_hba.extents_in_use, 6089 phba->sli4_hba.max_cfg_param.xri_base, 6090 phba->sli4_hba.max_cfg_param.max_xri, 6091 phba->sli4_hba.max_cfg_param.vpi_base, 6092 phba->sli4_hba.max_cfg_param.max_vpi, 6093 phba->sli4_hba.max_cfg_param.vfi_base, 6094 phba->sli4_hba.max_cfg_param.max_vfi, 6095 phba->sli4_hba.max_cfg_param.rpi_base, 6096 phba->sli4_hba.max_cfg_param.max_rpi, 6097 phba->sli4_hba.max_cfg_param.max_fcfi); 6098 } 6099 6100 if (rc) 6101 goto read_cfg_out; 6102 6103 /* Reset the DFT_HBA_Q_DEPTH to the max xri */ 6104 if (phba->cfg_hba_queue_depth > 6105 (phba->sli4_hba.max_cfg_param.max_xri - 6106 lpfc_sli4_get_els_iocb_cnt(phba))) 6107 phba->cfg_hba_queue_depth = 6108 phba->sli4_hba.max_cfg_param.max_xri - 6109 lpfc_sli4_get_els_iocb_cnt(phba); 6110 6111 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) != 6112 LPFC_SLI_INTF_IF_TYPE_2) 6113 goto read_cfg_out; 6114 6115 /* get the pf# and vf# for SLI4 if_type 2 port */ 6116 length = (sizeof(struct lpfc_mbx_get_func_cfg) - 6117 sizeof(struct lpfc_sli4_cfg_mhdr)); 6118 lpfc_sli4_config(phba, pmb, LPFC_MBOX_SUBSYSTEM_COMMON, 6119 LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG, 6120 length, LPFC_SLI4_MBX_EMBED); 6121 6122 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 6123 shdr = (union lpfc_sli4_cfg_shdr *) 6124 &pmb->u.mqe.un.sli4_config.header.cfg_shdr; 6125 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); 6126 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response); 6127 if (rc || shdr_status || shdr_add_status) { 6128 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 6129 "3026 Mailbox failed , mbxCmd x%x " 6130 "GET_FUNCTION_CONFIG, mbxStatus x%x\n", 6131 bf_get(lpfc_mqe_command, &pmb->u.mqe), 6132 bf_get(lpfc_mqe_status, &pmb->u.mqe)); 6133 rc = -EIO; 6134 goto read_cfg_out; 6135 } 6136 6137 /* search for fc_fcoe resrouce descriptor */ 6138 get_func_cfg = &pmb->u.mqe.un.get_func_cfg; 6139 desc_count = get_func_cfg->func_cfg.rsrc_desc_count; 6140 6141 for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) { 6142 desc = (struct lpfc_rsrc_desc_fcfcoe *) 6143 &get_func_cfg->func_cfg.desc[i]; 6144 if (LPFC_RSRC_DESC_TYPE_FCFCOE == 6145 bf_get(lpfc_rsrc_desc_pcie_type, desc)) { 6146 phba->sli4_hba.iov.pf_number = 6147 bf_get(lpfc_rsrc_desc_fcfcoe_pfnum, desc); 6148 phba->sli4_hba.iov.vf_number = 6149 bf_get(lpfc_rsrc_desc_fcfcoe_vfnum, desc); 6150 break; 6151 } 6152 } 6153 6154 if (i < LPFC_RSRC_DESC_MAX_NUM) 6155 lpfc_printf_log(phba, KERN_INFO, LOG_SLI, 6156 "3027 GET_FUNCTION_CONFIG: pf_number:%d, " 6157 "vf_number:%d\n", phba->sli4_hba.iov.pf_number, 6158 phba->sli4_hba.iov.vf_number); 6159 else { 6160 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, 6161 "3028 GET_FUNCTION_CONFIG: failed to find " 6162 "Resrouce Descriptor:x%x\n", 6163 LPFC_RSRC_DESC_TYPE_FCFCOE); 6164 rc = -EIO; 6165 } 6166 6167 read_cfg_out: 6168 mempool_free(pmb, phba->mbox_mem_pool); 6169 return rc; 6170 } 6171 6172 /** 6173 * lpfc_setup_endian_order - Write endian order to an SLI4 if_type 0 port. 6174 * @phba: pointer to lpfc hba data structure. 6175 * 6176 * This routine is invoked to setup the port-side endian order when 6177 * the port if_type is 0. This routine has no function for other 6178 * if_types. 6179 * 6180 * Return codes 6181 * 0 - successful 6182 * -ENOMEM - No available memory 6183 * -EIO - The mailbox failed to complete successfully. 6184 **/ 6185 static int 6186 lpfc_setup_endian_order(struct lpfc_hba *phba) 6187 { 6188 LPFC_MBOXQ_t *mboxq; 6189 uint32_t if_type, rc = 0; 6190 uint32_t endian_mb_data[2] = {HOST_ENDIAN_LOW_WORD0, 6191 HOST_ENDIAN_HIGH_WORD1}; 6192 6193 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 6194 switch (if_type) { 6195 case LPFC_SLI_INTF_IF_TYPE_0: 6196 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, 6197 GFP_KERNEL); 6198 if (!mboxq) { 6199 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6200 "0492 Unable to allocate memory for " 6201 "issuing SLI_CONFIG_SPECIAL mailbox " 6202 "command\n"); 6203 return -ENOMEM; 6204 } 6205 6206 /* 6207 * The SLI4_CONFIG_SPECIAL mailbox command requires the first 6208 * two words to contain special data values and no other data. 6209 */ 6210 memset(mboxq, 0, sizeof(LPFC_MBOXQ_t)); 6211 memcpy(&mboxq->u.mqe, &endian_mb_data, sizeof(endian_mb_data)); 6212 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 6213 if (rc != MBX_SUCCESS) { 6214 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6215 "0493 SLI_CONFIG_SPECIAL mailbox " 6216 "failed with status x%x\n", 6217 rc); 6218 rc = -EIO; 6219 } 6220 mempool_free(mboxq, phba->mbox_mem_pool); 6221 break; 6222 case LPFC_SLI_INTF_IF_TYPE_2: 6223 case LPFC_SLI_INTF_IF_TYPE_1: 6224 default: 6225 break; 6226 } 6227 return rc; 6228 } 6229 6230 /** 6231 * lpfc_sli4_queue_verify - Verify and update EQ and CQ counts 6232 * @phba: pointer to lpfc hba data structure. 6233 * 6234 * This routine is invoked to check the user settable queue counts for EQs and 6235 * CQs. after this routine is called the counts will be set to valid values that 6236 * adhere to the constraints of the system's interrupt vectors and the port's 6237 * queue resources. 6238 * 6239 * Return codes 6240 * 0 - successful 6241 * -ENOMEM - No available memory 6242 **/ 6243 static int 6244 lpfc_sli4_queue_verify(struct lpfc_hba *phba) 6245 { 6246 int cfg_fcp_wq_count; 6247 int cfg_fcp_eq_count; 6248 6249 /* 6250 * Sanity check for confiugred queue parameters against the run-time 6251 * device parameters 6252 */ 6253 6254 /* Sanity check on FCP fast-path WQ parameters */ 6255 cfg_fcp_wq_count = phba->cfg_fcp_wq_count; 6256 if (cfg_fcp_wq_count > 6257 (phba->sli4_hba.max_cfg_param.max_wq - LPFC_SP_WQN_DEF)) { 6258 cfg_fcp_wq_count = phba->sli4_hba.max_cfg_param.max_wq - 6259 LPFC_SP_WQN_DEF; 6260 if (cfg_fcp_wq_count < LPFC_FP_WQN_MIN) { 6261 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6262 "2581 Not enough WQs (%d) from " 6263 "the pci function for supporting " 6264 "FCP WQs (%d)\n", 6265 phba->sli4_hba.max_cfg_param.max_wq, 6266 phba->cfg_fcp_wq_count); 6267 goto out_error; 6268 } 6269 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 6270 "2582 Not enough WQs (%d) from the pci " 6271 "function for supporting the requested " 6272 "FCP WQs (%d), the actual FCP WQs can " 6273 "be supported: %d\n", 6274 phba->sli4_hba.max_cfg_param.max_wq, 6275 phba->cfg_fcp_wq_count, cfg_fcp_wq_count); 6276 } 6277 /* The actual number of FCP work queues adopted */ 6278 phba->cfg_fcp_wq_count = cfg_fcp_wq_count; 6279 6280 /* Sanity check on FCP fast-path EQ parameters */ 6281 cfg_fcp_eq_count = phba->cfg_fcp_eq_count; 6282 if (cfg_fcp_eq_count > 6283 (phba->sli4_hba.max_cfg_param.max_eq - LPFC_SP_EQN_DEF)) { 6284 cfg_fcp_eq_count = phba->sli4_hba.max_cfg_param.max_eq - 6285 LPFC_SP_EQN_DEF; 6286 if (cfg_fcp_eq_count < LPFC_FP_EQN_MIN) { 6287 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6288 "2574 Not enough EQs (%d) from the " 6289 "pci function for supporting FCP " 6290 "EQs (%d)\n", 6291 phba->sli4_hba.max_cfg_param.max_eq, 6292 phba->cfg_fcp_eq_count); 6293 goto out_error; 6294 } 6295 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 6296 "2575 Not enough EQs (%d) from the pci " 6297 "function for supporting the requested " 6298 "FCP EQs (%d), the actual FCP EQs can " 6299 "be supported: %d\n", 6300 phba->sli4_hba.max_cfg_param.max_eq, 6301 phba->cfg_fcp_eq_count, cfg_fcp_eq_count); 6302 } 6303 /* It does not make sense to have more EQs than WQs */ 6304 if (cfg_fcp_eq_count > phba->cfg_fcp_wq_count) { 6305 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 6306 "2593 The FCP EQ count(%d) cannot be greater " 6307 "than the FCP WQ count(%d), limiting the " 6308 "FCP EQ count to %d\n", cfg_fcp_eq_count, 6309 phba->cfg_fcp_wq_count, 6310 phba->cfg_fcp_wq_count); 6311 cfg_fcp_eq_count = phba->cfg_fcp_wq_count; 6312 } 6313 /* The actual number of FCP event queues adopted */ 6314 phba->cfg_fcp_eq_count = cfg_fcp_eq_count; 6315 /* The overall number of event queues used */ 6316 phba->sli4_hba.cfg_eqn = phba->cfg_fcp_eq_count + LPFC_SP_EQN_DEF; 6317 6318 /* Get EQ depth from module parameter, fake the default for now */ 6319 phba->sli4_hba.eq_esize = LPFC_EQE_SIZE_4B; 6320 phba->sli4_hba.eq_ecount = LPFC_EQE_DEF_COUNT; 6321 6322 /* Get CQ depth from module parameter, fake the default for now */ 6323 phba->sli4_hba.cq_esize = LPFC_CQE_SIZE; 6324 phba->sli4_hba.cq_ecount = LPFC_CQE_DEF_COUNT; 6325 6326 return 0; 6327 out_error: 6328 return -ENOMEM; 6329 } 6330 6331 /** 6332 * lpfc_sli4_queue_create - Create all the SLI4 queues 6333 * @phba: pointer to lpfc hba data structure. 6334 * 6335 * This routine is invoked to allocate all the SLI4 queues for the FCoE HBA 6336 * operation. For each SLI4 queue type, the parameters such as queue entry 6337 * count (queue depth) shall be taken from the module parameter. For now, 6338 * we just use some constant number as place holder. 6339 * 6340 * Return codes 6341 * 0 - sucessful 6342 * -ENOMEM - No availble memory 6343 * -EIO - The mailbox failed to complete successfully. 6344 **/ 6345 int 6346 lpfc_sli4_queue_create(struct lpfc_hba *phba) 6347 { 6348 struct lpfc_queue *qdesc; 6349 int fcp_eqidx, fcp_cqidx, fcp_wqidx; 6350 6351 /* 6352 * Create Event Queues (EQs) 6353 */ 6354 6355 /* Create slow path event queue */ 6356 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize, 6357 phba->sli4_hba.eq_ecount); 6358 if (!qdesc) { 6359 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6360 "0496 Failed allocate slow-path EQ\n"); 6361 goto out_error; 6362 } 6363 phba->sli4_hba.sp_eq = qdesc; 6364 6365 /* 6366 * Create fast-path FCP Event Queue(s). The cfg_fcp_eq_count can be 6367 * zero whenever there is exactly one interrupt vector. This is not 6368 * an error. 6369 */ 6370 if (phba->cfg_fcp_eq_count) { 6371 phba->sli4_hba.fp_eq = kzalloc((sizeof(struct lpfc_queue *) * 6372 phba->cfg_fcp_eq_count), GFP_KERNEL); 6373 if (!phba->sli4_hba.fp_eq) { 6374 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6375 "2576 Failed allocate memory for " 6376 "fast-path EQ record array\n"); 6377 goto out_free_sp_eq; 6378 } 6379 } 6380 for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) { 6381 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize, 6382 phba->sli4_hba.eq_ecount); 6383 if (!qdesc) { 6384 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6385 "0497 Failed allocate fast-path EQ\n"); 6386 goto out_free_fp_eq; 6387 } 6388 phba->sli4_hba.fp_eq[fcp_eqidx] = qdesc; 6389 } 6390 6391 /* 6392 * Create Complete Queues (CQs) 6393 */ 6394 6395 /* Create slow-path Mailbox Command Complete Queue */ 6396 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize, 6397 phba->sli4_hba.cq_ecount); 6398 if (!qdesc) { 6399 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6400 "0500 Failed allocate slow-path mailbox CQ\n"); 6401 goto out_free_fp_eq; 6402 } 6403 phba->sli4_hba.mbx_cq = qdesc; 6404 6405 /* Create slow-path ELS Complete Queue */ 6406 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize, 6407 phba->sli4_hba.cq_ecount); 6408 if (!qdesc) { 6409 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6410 "0501 Failed allocate slow-path ELS CQ\n"); 6411 goto out_free_mbx_cq; 6412 } 6413 phba->sli4_hba.els_cq = qdesc; 6414 6415 6416 /* 6417 * Create fast-path FCP Completion Queue(s), one-to-one with FCP EQs. 6418 * If there are no FCP EQs then create exactly one FCP CQ. 6419 */ 6420 if (phba->cfg_fcp_eq_count) 6421 phba->sli4_hba.fcp_cq = kzalloc((sizeof(struct lpfc_queue *) * 6422 phba->cfg_fcp_eq_count), 6423 GFP_KERNEL); 6424 else 6425 phba->sli4_hba.fcp_cq = kzalloc(sizeof(struct lpfc_queue *), 6426 GFP_KERNEL); 6427 if (!phba->sli4_hba.fcp_cq) { 6428 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6429 "2577 Failed allocate memory for fast-path " 6430 "CQ record array\n"); 6431 goto out_free_els_cq; 6432 } 6433 fcp_cqidx = 0; 6434 do { 6435 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize, 6436 phba->sli4_hba.cq_ecount); 6437 if (!qdesc) { 6438 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6439 "0499 Failed allocate fast-path FCP " 6440 "CQ (%d)\n", fcp_cqidx); 6441 goto out_free_fcp_cq; 6442 } 6443 phba->sli4_hba.fcp_cq[fcp_cqidx] = qdesc; 6444 } while (++fcp_cqidx < phba->cfg_fcp_eq_count); 6445 6446 /* Create Mailbox Command Queue */ 6447 phba->sli4_hba.mq_esize = LPFC_MQE_SIZE; 6448 phba->sli4_hba.mq_ecount = LPFC_MQE_DEF_COUNT; 6449 6450 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize, 6451 phba->sli4_hba.mq_ecount); 6452 if (!qdesc) { 6453 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6454 "0505 Failed allocate slow-path MQ\n"); 6455 goto out_free_fcp_cq; 6456 } 6457 phba->sli4_hba.mbx_wq = qdesc; 6458 6459 /* 6460 * Create all the Work Queues (WQs) 6461 */ 6462 phba->sli4_hba.wq_esize = LPFC_WQE_SIZE; 6463 phba->sli4_hba.wq_ecount = LPFC_WQE_DEF_COUNT; 6464 6465 /* Create slow-path ELS Work Queue */ 6466 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize, 6467 phba->sli4_hba.wq_ecount); 6468 if (!qdesc) { 6469 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6470 "0504 Failed allocate slow-path ELS WQ\n"); 6471 goto out_free_mbx_wq; 6472 } 6473 phba->sli4_hba.els_wq = qdesc; 6474 6475 /* Create fast-path FCP Work Queue(s) */ 6476 phba->sli4_hba.fcp_wq = kzalloc((sizeof(struct lpfc_queue *) * 6477 phba->cfg_fcp_wq_count), GFP_KERNEL); 6478 if (!phba->sli4_hba.fcp_wq) { 6479 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6480 "2578 Failed allocate memory for fast-path " 6481 "WQ record array\n"); 6482 goto out_free_els_wq; 6483 } 6484 for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) { 6485 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize, 6486 phba->sli4_hba.wq_ecount); 6487 if (!qdesc) { 6488 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6489 "0503 Failed allocate fast-path FCP " 6490 "WQ (%d)\n", fcp_wqidx); 6491 goto out_free_fcp_wq; 6492 } 6493 phba->sli4_hba.fcp_wq[fcp_wqidx] = qdesc; 6494 } 6495 6496 /* 6497 * Create Receive Queue (RQ) 6498 */ 6499 phba->sli4_hba.rq_esize = LPFC_RQE_SIZE; 6500 phba->sli4_hba.rq_ecount = LPFC_RQE_DEF_COUNT; 6501 6502 /* Create Receive Queue for header */ 6503 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize, 6504 phba->sli4_hba.rq_ecount); 6505 if (!qdesc) { 6506 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6507 "0506 Failed allocate receive HRQ\n"); 6508 goto out_free_fcp_wq; 6509 } 6510 phba->sli4_hba.hdr_rq = qdesc; 6511 6512 /* Create Receive Queue for data */ 6513 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize, 6514 phba->sli4_hba.rq_ecount); 6515 if (!qdesc) { 6516 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6517 "0507 Failed allocate receive DRQ\n"); 6518 goto out_free_hdr_rq; 6519 } 6520 phba->sli4_hba.dat_rq = qdesc; 6521 6522 return 0; 6523 6524 out_free_hdr_rq: 6525 lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq); 6526 phba->sli4_hba.hdr_rq = NULL; 6527 out_free_fcp_wq: 6528 for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--) { 6529 lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_wqidx]); 6530 phba->sli4_hba.fcp_wq[fcp_wqidx] = NULL; 6531 } 6532 kfree(phba->sli4_hba.fcp_wq); 6533 phba->sli4_hba.fcp_wq = NULL; 6534 out_free_els_wq: 6535 lpfc_sli4_queue_free(phba->sli4_hba.els_wq); 6536 phba->sli4_hba.els_wq = NULL; 6537 out_free_mbx_wq: 6538 lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq); 6539 phba->sli4_hba.mbx_wq = NULL; 6540 out_free_fcp_cq: 6541 for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--) { 6542 lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_cqidx]); 6543 phba->sli4_hba.fcp_cq[fcp_cqidx] = NULL; 6544 } 6545 kfree(phba->sli4_hba.fcp_cq); 6546 phba->sli4_hba.fcp_cq = NULL; 6547 out_free_els_cq: 6548 lpfc_sli4_queue_free(phba->sli4_hba.els_cq); 6549 phba->sli4_hba.els_cq = NULL; 6550 out_free_mbx_cq: 6551 lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq); 6552 phba->sli4_hba.mbx_cq = NULL; 6553 out_free_fp_eq: 6554 for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--) { 6555 lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_eqidx]); 6556 phba->sli4_hba.fp_eq[fcp_eqidx] = NULL; 6557 } 6558 kfree(phba->sli4_hba.fp_eq); 6559 phba->sli4_hba.fp_eq = NULL; 6560 out_free_sp_eq: 6561 lpfc_sli4_queue_free(phba->sli4_hba.sp_eq); 6562 phba->sli4_hba.sp_eq = NULL; 6563 out_error: 6564 return -ENOMEM; 6565 } 6566 6567 /** 6568 * lpfc_sli4_queue_destroy - Destroy all the SLI4 queues 6569 * @phba: pointer to lpfc hba data structure. 6570 * 6571 * This routine is invoked to release all the SLI4 queues with the FCoE HBA 6572 * operation. 6573 * 6574 * Return codes 6575 * 0 - successful 6576 * -ENOMEM - No available memory 6577 * -EIO - The mailbox failed to complete successfully. 6578 **/ 6579 void 6580 lpfc_sli4_queue_destroy(struct lpfc_hba *phba) 6581 { 6582 int fcp_qidx; 6583 6584 /* Release mailbox command work queue */ 6585 lpfc_sli4_queue_free(phba->sli4_hba.mbx_wq); 6586 phba->sli4_hba.mbx_wq = NULL; 6587 6588 /* Release ELS work queue */ 6589 lpfc_sli4_queue_free(phba->sli4_hba.els_wq); 6590 phba->sli4_hba.els_wq = NULL; 6591 6592 /* Release FCP work queue */ 6593 if (phba->sli4_hba.fcp_wq != NULL) 6594 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; 6595 fcp_qidx++) 6596 lpfc_sli4_queue_free(phba->sli4_hba.fcp_wq[fcp_qidx]); 6597 kfree(phba->sli4_hba.fcp_wq); 6598 phba->sli4_hba.fcp_wq = NULL; 6599 6600 /* Release unsolicited receive queue */ 6601 lpfc_sli4_queue_free(phba->sli4_hba.hdr_rq); 6602 phba->sli4_hba.hdr_rq = NULL; 6603 lpfc_sli4_queue_free(phba->sli4_hba.dat_rq); 6604 phba->sli4_hba.dat_rq = NULL; 6605 6606 /* Release ELS complete queue */ 6607 lpfc_sli4_queue_free(phba->sli4_hba.els_cq); 6608 phba->sli4_hba.els_cq = NULL; 6609 6610 /* Release mailbox command complete queue */ 6611 lpfc_sli4_queue_free(phba->sli4_hba.mbx_cq); 6612 phba->sli4_hba.mbx_cq = NULL; 6613 6614 /* Release FCP response complete queue */ 6615 fcp_qidx = 0; 6616 if (phba->sli4_hba.fcp_cq != NULL) 6617 do 6618 lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_qidx]); 6619 while (++fcp_qidx < phba->cfg_fcp_eq_count); 6620 kfree(phba->sli4_hba.fcp_cq); 6621 phba->sli4_hba.fcp_cq = NULL; 6622 6623 /* Release fast-path event queue */ 6624 if (phba->sli4_hba.fp_eq != NULL) 6625 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; 6626 fcp_qidx++) 6627 lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_qidx]); 6628 kfree(phba->sli4_hba.fp_eq); 6629 phba->sli4_hba.fp_eq = NULL; 6630 6631 /* Release slow-path event queue */ 6632 lpfc_sli4_queue_free(phba->sli4_hba.sp_eq); 6633 phba->sli4_hba.sp_eq = NULL; 6634 6635 return; 6636 } 6637 6638 /** 6639 * lpfc_sli4_queue_setup - Set up all the SLI4 queues 6640 * @phba: pointer to lpfc hba data structure. 6641 * 6642 * This routine is invoked to set up all the SLI4 queues for the FCoE HBA 6643 * operation. 6644 * 6645 * Return codes 6646 * 0 - successful 6647 * -ENOMEM - No available memory 6648 * -EIO - The mailbox failed to complete successfully. 6649 **/ 6650 int 6651 lpfc_sli4_queue_setup(struct lpfc_hba *phba) 6652 { 6653 int rc = -ENOMEM; 6654 int fcp_eqidx, fcp_cqidx, fcp_wqidx; 6655 int fcp_cq_index = 0; 6656 6657 /* 6658 * Set up Event Queues (EQs) 6659 */ 6660 6661 /* Set up slow-path event queue */ 6662 if (!phba->sli4_hba.sp_eq) { 6663 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6664 "0520 Slow-path EQ not allocated\n"); 6665 goto out_error; 6666 } 6667 rc = lpfc_eq_create(phba, phba->sli4_hba.sp_eq, 6668 LPFC_SP_DEF_IMAX); 6669 if (rc) { 6670 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6671 "0521 Failed setup of slow-path EQ: " 6672 "rc = 0x%x\n", rc); 6673 goto out_error; 6674 } 6675 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6676 "2583 Slow-path EQ setup: queue-id=%d\n", 6677 phba->sli4_hba.sp_eq->queue_id); 6678 6679 /* Set up fast-path event queue */ 6680 if (phba->cfg_fcp_eq_count && !phba->sli4_hba.fp_eq) { 6681 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6682 "3147 Fast-path EQs not allocated\n"); 6683 rc = -ENOMEM; 6684 goto out_destroy_sp_eq; 6685 } 6686 for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++) { 6687 if (!phba->sli4_hba.fp_eq[fcp_eqidx]) { 6688 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6689 "0522 Fast-path EQ (%d) not " 6690 "allocated\n", fcp_eqidx); 6691 rc = -ENOMEM; 6692 goto out_destroy_fp_eq; 6693 } 6694 rc = lpfc_eq_create(phba, phba->sli4_hba.fp_eq[fcp_eqidx], 6695 phba->cfg_fcp_imax); 6696 if (rc) { 6697 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6698 "0523 Failed setup of fast-path EQ " 6699 "(%d), rc = 0x%x\n", fcp_eqidx, rc); 6700 goto out_destroy_fp_eq; 6701 } 6702 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6703 "2584 Fast-path EQ setup: " 6704 "queue[%d]-id=%d\n", fcp_eqidx, 6705 phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id); 6706 } 6707 6708 /* 6709 * Set up Complete Queues (CQs) 6710 */ 6711 6712 /* Set up slow-path MBOX Complete Queue as the first CQ */ 6713 if (!phba->sli4_hba.mbx_cq) { 6714 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6715 "0528 Mailbox CQ not allocated\n"); 6716 rc = -ENOMEM; 6717 goto out_destroy_fp_eq; 6718 } 6719 rc = lpfc_cq_create(phba, phba->sli4_hba.mbx_cq, phba->sli4_hba.sp_eq, 6720 LPFC_MCQ, LPFC_MBOX); 6721 if (rc) { 6722 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6723 "0529 Failed setup of slow-path mailbox CQ: " 6724 "rc = 0x%x\n", rc); 6725 goto out_destroy_fp_eq; 6726 } 6727 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6728 "2585 MBX CQ setup: cq-id=%d, parent eq-id=%d\n", 6729 phba->sli4_hba.mbx_cq->queue_id, 6730 phba->sli4_hba.sp_eq->queue_id); 6731 6732 /* Set up slow-path ELS Complete Queue */ 6733 if (!phba->sli4_hba.els_cq) { 6734 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6735 "0530 ELS CQ not allocated\n"); 6736 rc = -ENOMEM; 6737 goto out_destroy_mbx_cq; 6738 } 6739 rc = lpfc_cq_create(phba, phba->sli4_hba.els_cq, phba->sli4_hba.sp_eq, 6740 LPFC_WCQ, LPFC_ELS); 6741 if (rc) { 6742 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6743 "0531 Failed setup of slow-path ELS CQ: " 6744 "rc = 0x%x\n", rc); 6745 goto out_destroy_mbx_cq; 6746 } 6747 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6748 "2586 ELS CQ setup: cq-id=%d, parent eq-id=%d\n", 6749 phba->sli4_hba.els_cq->queue_id, 6750 phba->sli4_hba.sp_eq->queue_id); 6751 6752 /* Set up fast-path FCP Response Complete Queue */ 6753 if (!phba->sli4_hba.fcp_cq) { 6754 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6755 "3148 Fast-path FCP CQ array not " 6756 "allocated\n"); 6757 rc = -ENOMEM; 6758 goto out_destroy_els_cq; 6759 } 6760 fcp_cqidx = 0; 6761 do { 6762 if (!phba->sli4_hba.fcp_cq[fcp_cqidx]) { 6763 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6764 "0526 Fast-path FCP CQ (%d) not " 6765 "allocated\n", fcp_cqidx); 6766 rc = -ENOMEM; 6767 goto out_destroy_fcp_cq; 6768 } 6769 if (phba->cfg_fcp_eq_count) 6770 rc = lpfc_cq_create(phba, 6771 phba->sli4_hba.fcp_cq[fcp_cqidx], 6772 phba->sli4_hba.fp_eq[fcp_cqidx], 6773 LPFC_WCQ, LPFC_FCP); 6774 else 6775 rc = lpfc_cq_create(phba, 6776 phba->sli4_hba.fcp_cq[fcp_cqidx], 6777 phba->sli4_hba.sp_eq, 6778 LPFC_WCQ, LPFC_FCP); 6779 if (rc) { 6780 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6781 "0527 Failed setup of fast-path FCP " 6782 "CQ (%d), rc = 0x%x\n", fcp_cqidx, rc); 6783 goto out_destroy_fcp_cq; 6784 } 6785 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6786 "2588 FCP CQ setup: cq[%d]-id=%d, " 6787 "parent %seq[%d]-id=%d\n", 6788 fcp_cqidx, 6789 phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id, 6790 (phba->cfg_fcp_eq_count) ? "" : "sp_", 6791 fcp_cqidx, 6792 (phba->cfg_fcp_eq_count) ? 6793 phba->sli4_hba.fp_eq[fcp_cqidx]->queue_id : 6794 phba->sli4_hba.sp_eq->queue_id); 6795 } while (++fcp_cqidx < phba->cfg_fcp_eq_count); 6796 6797 /* 6798 * Set up all the Work Queues (WQs) 6799 */ 6800 6801 /* Set up Mailbox Command Queue */ 6802 if (!phba->sli4_hba.mbx_wq) { 6803 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6804 "0538 Slow-path MQ not allocated\n"); 6805 rc = -ENOMEM; 6806 goto out_destroy_fcp_cq; 6807 } 6808 rc = lpfc_mq_create(phba, phba->sli4_hba.mbx_wq, 6809 phba->sli4_hba.mbx_cq, LPFC_MBOX); 6810 if (rc) { 6811 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6812 "0539 Failed setup of slow-path MQ: " 6813 "rc = 0x%x\n", rc); 6814 goto out_destroy_fcp_cq; 6815 } 6816 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6817 "2589 MBX MQ setup: wq-id=%d, parent cq-id=%d\n", 6818 phba->sli4_hba.mbx_wq->queue_id, 6819 phba->sli4_hba.mbx_cq->queue_id); 6820 6821 /* Set up slow-path ELS Work Queue */ 6822 if (!phba->sli4_hba.els_wq) { 6823 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6824 "0536 Slow-path ELS WQ not allocated\n"); 6825 rc = -ENOMEM; 6826 goto out_destroy_mbx_wq; 6827 } 6828 rc = lpfc_wq_create(phba, phba->sli4_hba.els_wq, 6829 phba->sli4_hba.els_cq, LPFC_ELS); 6830 if (rc) { 6831 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6832 "0537 Failed setup of slow-path ELS WQ: " 6833 "rc = 0x%x\n", rc); 6834 goto out_destroy_mbx_wq; 6835 } 6836 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6837 "2590 ELS WQ setup: wq-id=%d, parent cq-id=%d\n", 6838 phba->sli4_hba.els_wq->queue_id, 6839 phba->sli4_hba.els_cq->queue_id); 6840 6841 /* Set up fast-path FCP Work Queue */ 6842 if (!phba->sli4_hba.fcp_wq) { 6843 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6844 "3149 Fast-path FCP WQ array not " 6845 "allocated\n"); 6846 rc = -ENOMEM; 6847 goto out_destroy_els_wq; 6848 } 6849 for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++) { 6850 if (!phba->sli4_hba.fcp_wq[fcp_wqidx]) { 6851 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6852 "0534 Fast-path FCP WQ (%d) not " 6853 "allocated\n", fcp_wqidx); 6854 rc = -ENOMEM; 6855 goto out_destroy_fcp_wq; 6856 } 6857 rc = lpfc_wq_create(phba, phba->sli4_hba.fcp_wq[fcp_wqidx], 6858 phba->sli4_hba.fcp_cq[fcp_cq_index], 6859 LPFC_FCP); 6860 if (rc) { 6861 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6862 "0535 Failed setup of fast-path FCP " 6863 "WQ (%d), rc = 0x%x\n", fcp_wqidx, rc); 6864 goto out_destroy_fcp_wq; 6865 } 6866 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6867 "2591 FCP WQ setup: wq[%d]-id=%d, " 6868 "parent cq[%d]-id=%d\n", 6869 fcp_wqidx, 6870 phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id, 6871 fcp_cq_index, 6872 phba->sli4_hba.fcp_cq[fcp_cq_index]->queue_id); 6873 /* Round robin FCP Work Queue's Completion Queue assignment */ 6874 if (phba->cfg_fcp_eq_count) 6875 fcp_cq_index = ((fcp_cq_index + 1) % 6876 phba->cfg_fcp_eq_count); 6877 } 6878 6879 /* 6880 * Create Receive Queue (RQ) 6881 */ 6882 if (!phba->sli4_hba.hdr_rq || !phba->sli4_hba.dat_rq) { 6883 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6884 "0540 Receive Queue not allocated\n"); 6885 rc = -ENOMEM; 6886 goto out_destroy_fcp_wq; 6887 } 6888 6889 lpfc_rq_adjust_repost(phba, phba->sli4_hba.hdr_rq, LPFC_ELS_HBQ); 6890 lpfc_rq_adjust_repost(phba, phba->sli4_hba.dat_rq, LPFC_ELS_HBQ); 6891 6892 rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq, 6893 phba->sli4_hba.els_cq, LPFC_USOL); 6894 if (rc) { 6895 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 6896 "0541 Failed setup of Receive Queue: " 6897 "rc = 0x%x\n", rc); 6898 goto out_destroy_fcp_wq; 6899 } 6900 6901 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 6902 "2592 USL RQ setup: hdr-rq-id=%d, dat-rq-id=%d " 6903 "parent cq-id=%d\n", 6904 phba->sli4_hba.hdr_rq->queue_id, 6905 phba->sli4_hba.dat_rq->queue_id, 6906 phba->sli4_hba.els_cq->queue_id); 6907 return 0; 6908 6909 out_destroy_fcp_wq: 6910 for (--fcp_wqidx; fcp_wqidx >= 0; fcp_wqidx--) 6911 lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_wqidx]); 6912 out_destroy_els_wq: 6913 lpfc_wq_destroy(phba, phba->sli4_hba.els_wq); 6914 out_destroy_mbx_wq: 6915 lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq); 6916 out_destroy_fcp_cq: 6917 for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--) 6918 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_cqidx]); 6919 out_destroy_els_cq: 6920 lpfc_cq_destroy(phba, phba->sli4_hba.els_cq); 6921 out_destroy_mbx_cq: 6922 lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq); 6923 out_destroy_fp_eq: 6924 for (--fcp_eqidx; fcp_eqidx >= 0; fcp_eqidx--) 6925 lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_eqidx]); 6926 out_destroy_sp_eq: 6927 lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq); 6928 out_error: 6929 return rc; 6930 } 6931 6932 /** 6933 * lpfc_sli4_queue_unset - Unset all the SLI4 queues 6934 * @phba: pointer to lpfc hba data structure. 6935 * 6936 * This routine is invoked to unset all the SLI4 queues with the FCoE HBA 6937 * operation. 6938 * 6939 * Return codes 6940 * 0 - successful 6941 * -ENOMEM - No available memory 6942 * -EIO - The mailbox failed to complete successfully. 6943 **/ 6944 void 6945 lpfc_sli4_queue_unset(struct lpfc_hba *phba) 6946 { 6947 int fcp_qidx; 6948 6949 /* Unset mailbox command work queue */ 6950 lpfc_mq_destroy(phba, phba->sli4_hba.mbx_wq); 6951 /* Unset ELS work queue */ 6952 lpfc_wq_destroy(phba, phba->sli4_hba.els_wq); 6953 /* Unset unsolicited receive queue */ 6954 lpfc_rq_destroy(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq); 6955 /* Unset FCP work queue */ 6956 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++) 6957 lpfc_wq_destroy(phba, phba->sli4_hba.fcp_wq[fcp_qidx]); 6958 /* Unset mailbox command complete queue */ 6959 lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq); 6960 /* Unset ELS complete queue */ 6961 lpfc_cq_destroy(phba, phba->sli4_hba.els_cq); 6962 /* Unset FCP response complete queue */ 6963 if (phba->sli4_hba.fcp_cq) { 6964 fcp_qidx = 0; 6965 do { 6966 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_qidx]); 6967 } while (++fcp_qidx < phba->cfg_fcp_eq_count); 6968 } 6969 /* Unset fast-path event queue */ 6970 if (phba->sli4_hba.fp_eq) { 6971 for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; 6972 fcp_qidx++) 6973 lpfc_eq_destroy(phba, phba->sli4_hba.fp_eq[fcp_qidx]); 6974 } 6975 /* Unset slow-path event queue */ 6976 lpfc_eq_destroy(phba, phba->sli4_hba.sp_eq); 6977 } 6978 6979 /** 6980 * lpfc_sli4_cq_event_pool_create - Create completion-queue event free pool 6981 * @phba: pointer to lpfc hba data structure. 6982 * 6983 * This routine is invoked to allocate and set up a pool of completion queue 6984 * events. The body of the completion queue event is a completion queue entry 6985 * CQE. For now, this pool is used for the interrupt service routine to queue 6986 * the following HBA completion queue events for the worker thread to process: 6987 * - Mailbox asynchronous events 6988 * - Receive queue completion unsolicited events 6989 * Later, this can be used for all the slow-path events. 6990 * 6991 * Return codes 6992 * 0 - successful 6993 * -ENOMEM - No available memory 6994 **/ 6995 static int 6996 lpfc_sli4_cq_event_pool_create(struct lpfc_hba *phba) 6997 { 6998 struct lpfc_cq_event *cq_event; 6999 int i; 7000 7001 for (i = 0; i < (4 * phba->sli4_hba.cq_ecount); i++) { 7002 cq_event = kmalloc(sizeof(struct lpfc_cq_event), GFP_KERNEL); 7003 if (!cq_event) 7004 goto out_pool_create_fail; 7005 list_add_tail(&cq_event->list, 7006 &phba->sli4_hba.sp_cqe_event_pool); 7007 } 7008 return 0; 7009 7010 out_pool_create_fail: 7011 lpfc_sli4_cq_event_pool_destroy(phba); 7012 return -ENOMEM; 7013 } 7014 7015 /** 7016 * lpfc_sli4_cq_event_pool_destroy - Free completion-queue event free pool 7017 * @phba: pointer to lpfc hba data structure. 7018 * 7019 * This routine is invoked to free the pool of completion queue events at 7020 * driver unload time. Note that, it is the responsibility of the driver 7021 * cleanup routine to free all the outstanding completion-queue events 7022 * allocated from this pool back into the pool before invoking this routine 7023 * to destroy the pool. 7024 **/ 7025 static void 7026 lpfc_sli4_cq_event_pool_destroy(struct lpfc_hba *phba) 7027 { 7028 struct lpfc_cq_event *cq_event, *next_cq_event; 7029 7030 list_for_each_entry_safe(cq_event, next_cq_event, 7031 &phba->sli4_hba.sp_cqe_event_pool, list) { 7032 list_del(&cq_event->list); 7033 kfree(cq_event); 7034 } 7035 } 7036 7037 /** 7038 * __lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool 7039 * @phba: pointer to lpfc hba data structure. 7040 * 7041 * This routine is the lock free version of the API invoked to allocate a 7042 * completion-queue event from the free pool. 7043 * 7044 * Return: Pointer to the newly allocated completion-queue event if successful 7045 * NULL otherwise. 7046 **/ 7047 struct lpfc_cq_event * 7048 __lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba) 7049 { 7050 struct lpfc_cq_event *cq_event = NULL; 7051 7052 list_remove_head(&phba->sli4_hba.sp_cqe_event_pool, cq_event, 7053 struct lpfc_cq_event, list); 7054 return cq_event; 7055 } 7056 7057 /** 7058 * lpfc_sli4_cq_event_alloc - Allocate a completion-queue event from free pool 7059 * @phba: pointer to lpfc hba data structure. 7060 * 7061 * This routine is the lock version of the API invoked to allocate a 7062 * completion-queue event from the free pool. 7063 * 7064 * Return: Pointer to the newly allocated completion-queue event if successful 7065 * NULL otherwise. 7066 **/ 7067 struct lpfc_cq_event * 7068 lpfc_sli4_cq_event_alloc(struct lpfc_hba *phba) 7069 { 7070 struct lpfc_cq_event *cq_event; 7071 unsigned long iflags; 7072 7073 spin_lock_irqsave(&phba->hbalock, iflags); 7074 cq_event = __lpfc_sli4_cq_event_alloc(phba); 7075 spin_unlock_irqrestore(&phba->hbalock, iflags); 7076 return cq_event; 7077 } 7078 7079 /** 7080 * __lpfc_sli4_cq_event_release - Release a completion-queue event to free pool 7081 * @phba: pointer to lpfc hba data structure. 7082 * @cq_event: pointer to the completion queue event to be freed. 7083 * 7084 * This routine is the lock free version of the API invoked to release a 7085 * completion-queue event back into the free pool. 7086 **/ 7087 void 7088 __lpfc_sli4_cq_event_release(struct lpfc_hba *phba, 7089 struct lpfc_cq_event *cq_event) 7090 { 7091 list_add_tail(&cq_event->list, &phba->sli4_hba.sp_cqe_event_pool); 7092 } 7093 7094 /** 7095 * lpfc_sli4_cq_event_release - Release a completion-queue event to free pool 7096 * @phba: pointer to lpfc hba data structure. 7097 * @cq_event: pointer to the completion queue event to be freed. 7098 * 7099 * This routine is the lock version of the API invoked to release a 7100 * completion-queue event back into the free pool. 7101 **/ 7102 void 7103 lpfc_sli4_cq_event_release(struct lpfc_hba *phba, 7104 struct lpfc_cq_event *cq_event) 7105 { 7106 unsigned long iflags; 7107 spin_lock_irqsave(&phba->hbalock, iflags); 7108 __lpfc_sli4_cq_event_release(phba, cq_event); 7109 spin_unlock_irqrestore(&phba->hbalock, iflags); 7110 } 7111 7112 /** 7113 * lpfc_sli4_cq_event_release_all - Release all cq events to the free pool 7114 * @phba: pointer to lpfc hba data structure. 7115 * 7116 * This routine is to free all the pending completion-queue events to the 7117 * back into the free pool for device reset. 7118 **/ 7119 static void 7120 lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba) 7121 { 7122 LIST_HEAD(cqelist); 7123 struct lpfc_cq_event *cqe; 7124 unsigned long iflags; 7125 7126 /* Retrieve all the pending WCQEs from pending WCQE lists */ 7127 spin_lock_irqsave(&phba->hbalock, iflags); 7128 /* Pending FCP XRI abort events */ 7129 list_splice_init(&phba->sli4_hba.sp_fcp_xri_aborted_work_queue, 7130 &cqelist); 7131 /* Pending ELS XRI abort events */ 7132 list_splice_init(&phba->sli4_hba.sp_els_xri_aborted_work_queue, 7133 &cqelist); 7134 /* Pending asynnc events */ 7135 list_splice_init(&phba->sli4_hba.sp_asynce_work_queue, 7136 &cqelist); 7137 spin_unlock_irqrestore(&phba->hbalock, iflags); 7138 7139 while (!list_empty(&cqelist)) { 7140 list_remove_head(&cqelist, cqe, struct lpfc_cq_event, list); 7141 lpfc_sli4_cq_event_release(phba, cqe); 7142 } 7143 } 7144 7145 /** 7146 * lpfc_pci_function_reset - Reset pci function. 7147 * @phba: pointer to lpfc hba data structure. 7148 * 7149 * This routine is invoked to request a PCI function reset. It will destroys 7150 * all resources assigned to the PCI function which originates this request. 7151 * 7152 * Return codes 7153 * 0 - successful 7154 * -ENOMEM - No available memory 7155 * -EIO - The mailbox failed to complete successfully. 7156 **/ 7157 int 7158 lpfc_pci_function_reset(struct lpfc_hba *phba) 7159 { 7160 LPFC_MBOXQ_t *mboxq; 7161 uint32_t rc = 0, if_type; 7162 uint32_t shdr_status, shdr_add_status; 7163 uint32_t rdy_chk, num_resets = 0, reset_again = 0; 7164 union lpfc_sli4_cfg_shdr *shdr; 7165 struct lpfc_register reg_data; 7166 7167 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 7168 switch (if_type) { 7169 case LPFC_SLI_INTF_IF_TYPE_0: 7170 mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, 7171 GFP_KERNEL); 7172 if (!mboxq) { 7173 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7174 "0494 Unable to allocate memory for " 7175 "issuing SLI_FUNCTION_RESET mailbox " 7176 "command\n"); 7177 return -ENOMEM; 7178 } 7179 7180 /* Setup PCI function reset mailbox-ioctl command */ 7181 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON, 7182 LPFC_MBOX_OPCODE_FUNCTION_RESET, 0, 7183 LPFC_SLI4_MBX_EMBED); 7184 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 7185 shdr = (union lpfc_sli4_cfg_shdr *) 7186 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr; 7187 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); 7188 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, 7189 &shdr->response); 7190 if (rc != MBX_TIMEOUT) 7191 mempool_free(mboxq, phba->mbox_mem_pool); 7192 if (shdr_status || shdr_add_status || rc) { 7193 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7194 "0495 SLI_FUNCTION_RESET mailbox " 7195 "failed with status x%x add_status x%x," 7196 " mbx status x%x\n", 7197 shdr_status, shdr_add_status, rc); 7198 rc = -ENXIO; 7199 } 7200 break; 7201 case LPFC_SLI_INTF_IF_TYPE_2: 7202 for (num_resets = 0; 7203 num_resets < MAX_IF_TYPE_2_RESETS; 7204 num_resets++) { 7205 reg_data.word0 = 0; 7206 bf_set(lpfc_sliport_ctrl_end, ®_data, 7207 LPFC_SLIPORT_LITTLE_ENDIAN); 7208 bf_set(lpfc_sliport_ctrl_ip, ®_data, 7209 LPFC_SLIPORT_INIT_PORT); 7210 writel(reg_data.word0, phba->sli4_hba.u.if_type2. 7211 CTRLregaddr); 7212 7213 /* 7214 * Poll the Port Status Register and wait for RDY for 7215 * up to 10 seconds. If the port doesn't respond, treat 7216 * it as an error. If the port responds with RN, start 7217 * the loop again. 7218 */ 7219 for (rdy_chk = 0; rdy_chk < 1000; rdy_chk++) { 7220 msleep(10); 7221 if (lpfc_readl(phba->sli4_hba.u.if_type2. 7222 STATUSregaddr, ®_data.word0)) { 7223 rc = -ENODEV; 7224 goto out; 7225 } 7226 if (bf_get(lpfc_sliport_status_rdy, ®_data)) 7227 break; 7228 if (bf_get(lpfc_sliport_status_rn, ®_data)) { 7229 reset_again++; 7230 break; 7231 } 7232 } 7233 7234 /* 7235 * If the port responds to the init request with 7236 * reset needed, delay for a bit and restart the loop. 7237 */ 7238 if (reset_again) { 7239 msleep(10); 7240 reset_again = 0; 7241 continue; 7242 } 7243 7244 /* Detect any port errors. */ 7245 if ((bf_get(lpfc_sliport_status_err, ®_data)) || 7246 (rdy_chk >= 1000)) { 7247 phba->work_status[0] = readl( 7248 phba->sli4_hba.u.if_type2.ERR1regaddr); 7249 phba->work_status[1] = readl( 7250 phba->sli4_hba.u.if_type2.ERR2regaddr); 7251 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7252 "2890 Port Error Detected " 7253 "during Port Reset: " 7254 "port status reg 0x%x, " 7255 "error 1=0x%x, error 2=0x%x\n", 7256 reg_data.word0, 7257 phba->work_status[0], 7258 phba->work_status[1]); 7259 rc = -ENODEV; 7260 } 7261 7262 /* 7263 * Terminate the outer loop provided the Port indicated 7264 * ready within 10 seconds. 7265 */ 7266 if (rdy_chk < 1000) 7267 break; 7268 } 7269 /* delay driver action following IF_TYPE_2 function reset */ 7270 msleep(100); 7271 break; 7272 case LPFC_SLI_INTF_IF_TYPE_1: 7273 default: 7274 break; 7275 } 7276 7277 out: 7278 /* Catch the not-ready port failure after a port reset. */ 7279 if (num_resets >= MAX_IF_TYPE_2_RESETS) 7280 rc = -ENODEV; 7281 7282 return rc; 7283 } 7284 7285 /** 7286 * lpfc_sli4_send_nop_mbox_cmds - Send sli-4 nop mailbox commands 7287 * @phba: pointer to lpfc hba data structure. 7288 * @cnt: number of nop mailbox commands to send. 7289 * 7290 * This routine is invoked to send a number @cnt of NOP mailbox command and 7291 * wait for each command to complete. 7292 * 7293 * Return: the number of NOP mailbox command completed. 7294 **/ 7295 static int 7296 lpfc_sli4_send_nop_mbox_cmds(struct lpfc_hba *phba, uint32_t cnt) 7297 { 7298 LPFC_MBOXQ_t *mboxq; 7299 int length, cmdsent; 7300 uint32_t mbox_tmo; 7301 uint32_t rc = 0; 7302 uint32_t shdr_status, shdr_add_status; 7303 union lpfc_sli4_cfg_shdr *shdr; 7304 7305 if (cnt == 0) { 7306 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7307 "2518 Requested to send 0 NOP mailbox cmd\n"); 7308 return cnt; 7309 } 7310 7311 mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 7312 if (!mboxq) { 7313 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7314 "2519 Unable to allocate memory for issuing " 7315 "NOP mailbox command\n"); 7316 return 0; 7317 } 7318 7319 /* Set up NOP SLI4_CONFIG mailbox-ioctl command */ 7320 length = (sizeof(struct lpfc_mbx_nop) - 7321 sizeof(struct lpfc_sli4_cfg_mhdr)); 7322 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON, 7323 LPFC_MBOX_OPCODE_NOP, length, LPFC_SLI4_MBX_EMBED); 7324 7325 for (cmdsent = 0; cmdsent < cnt; cmdsent++) { 7326 if (!phba->sli4_hba.intr_enable) 7327 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 7328 else { 7329 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq); 7330 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo); 7331 } 7332 if (rc == MBX_TIMEOUT) 7333 break; 7334 /* Check return status */ 7335 shdr = (union lpfc_sli4_cfg_shdr *) 7336 &mboxq->u.mqe.un.sli4_config.header.cfg_shdr; 7337 shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response); 7338 shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, 7339 &shdr->response); 7340 if (shdr_status || shdr_add_status || rc) { 7341 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7342 "2520 NOP mailbox command failed " 7343 "status x%x add_status x%x mbx " 7344 "status x%x\n", shdr_status, 7345 shdr_add_status, rc); 7346 break; 7347 } 7348 } 7349 7350 if (rc != MBX_TIMEOUT) 7351 mempool_free(mboxq, phba->mbox_mem_pool); 7352 7353 return cmdsent; 7354 } 7355 7356 /** 7357 * lpfc_sli4_pci_mem_setup - Setup SLI4 HBA PCI memory space. 7358 * @phba: pointer to lpfc hba data structure. 7359 * 7360 * This routine is invoked to set up the PCI device memory space for device 7361 * with SLI-4 interface spec. 7362 * 7363 * Return codes 7364 * 0 - successful 7365 * other values - error 7366 **/ 7367 static int 7368 lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba) 7369 { 7370 struct pci_dev *pdev; 7371 unsigned long bar0map_len, bar1map_len, bar2map_len; 7372 int error = -ENODEV; 7373 uint32_t if_type; 7374 7375 /* Obtain PCI device reference */ 7376 if (!phba->pcidev) 7377 return error; 7378 else 7379 pdev = phba->pcidev; 7380 7381 /* Set the device DMA mask size */ 7382 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0 7383 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) { 7384 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0 7385 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) { 7386 return error; 7387 } 7388 } 7389 7390 /* 7391 * The BARs and register set definitions and offset locations are 7392 * dependent on the if_type. 7393 */ 7394 if (pci_read_config_dword(pdev, LPFC_SLI_INTF, 7395 &phba->sli4_hba.sli_intf.word0)) { 7396 return error; 7397 } 7398 7399 /* There is no SLI3 failback for SLI4 devices. */ 7400 if (bf_get(lpfc_sli_intf_valid, &phba->sli4_hba.sli_intf) != 7401 LPFC_SLI_INTF_VALID) { 7402 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7403 "2894 SLI_INTF reg contents invalid " 7404 "sli_intf reg 0x%x\n", 7405 phba->sli4_hba.sli_intf.word0); 7406 return error; 7407 } 7408 7409 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 7410 /* 7411 * Get the bus address of SLI4 device Bar regions and the 7412 * number of bytes required by each mapping. The mapping of the 7413 * particular PCI BARs regions is dependent on the type of 7414 * SLI4 device. 7415 */ 7416 if (pci_resource_start(pdev, 0)) { 7417 phba->pci_bar0_map = pci_resource_start(pdev, 0); 7418 bar0map_len = pci_resource_len(pdev, 0); 7419 7420 /* 7421 * Map SLI4 PCI Config Space Register base to a kernel virtual 7422 * addr 7423 */ 7424 phba->sli4_hba.conf_regs_memmap_p = 7425 ioremap(phba->pci_bar0_map, bar0map_len); 7426 if (!phba->sli4_hba.conf_regs_memmap_p) { 7427 dev_printk(KERN_ERR, &pdev->dev, 7428 "ioremap failed for SLI4 PCI config " 7429 "registers.\n"); 7430 goto out; 7431 } 7432 /* Set up BAR0 PCI config space register memory map */ 7433 lpfc_sli4_bar0_register_memmap(phba, if_type); 7434 } else { 7435 phba->pci_bar0_map = pci_resource_start(pdev, 1); 7436 bar0map_len = pci_resource_len(pdev, 1); 7437 if (if_type == LPFC_SLI_INTF_IF_TYPE_2) { 7438 dev_printk(KERN_ERR, &pdev->dev, 7439 "FATAL - No BAR0 mapping for SLI4, if_type 2\n"); 7440 goto out; 7441 } 7442 phba->sli4_hba.conf_regs_memmap_p = 7443 ioremap(phba->pci_bar0_map, bar0map_len); 7444 if (!phba->sli4_hba.conf_regs_memmap_p) { 7445 dev_printk(KERN_ERR, &pdev->dev, 7446 "ioremap failed for SLI4 PCI config " 7447 "registers.\n"); 7448 goto out; 7449 } 7450 lpfc_sli4_bar0_register_memmap(phba, if_type); 7451 } 7452 7453 if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) && 7454 (pci_resource_start(pdev, 2))) { 7455 /* 7456 * Map SLI4 if type 0 HBA Control Register base to a kernel 7457 * virtual address and setup the registers. 7458 */ 7459 phba->pci_bar1_map = pci_resource_start(pdev, 2); 7460 bar1map_len = pci_resource_len(pdev, 2); 7461 phba->sli4_hba.ctrl_regs_memmap_p = 7462 ioremap(phba->pci_bar1_map, bar1map_len); 7463 if (!phba->sli4_hba.ctrl_regs_memmap_p) { 7464 dev_printk(KERN_ERR, &pdev->dev, 7465 "ioremap failed for SLI4 HBA control registers.\n"); 7466 goto out_iounmap_conf; 7467 } 7468 lpfc_sli4_bar1_register_memmap(phba); 7469 } 7470 7471 if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) && 7472 (pci_resource_start(pdev, 4))) { 7473 /* 7474 * Map SLI4 if type 0 HBA Doorbell Register base to a kernel 7475 * virtual address and setup the registers. 7476 */ 7477 phba->pci_bar2_map = pci_resource_start(pdev, 4); 7478 bar2map_len = pci_resource_len(pdev, 4); 7479 phba->sli4_hba.drbl_regs_memmap_p = 7480 ioremap(phba->pci_bar2_map, bar2map_len); 7481 if (!phba->sli4_hba.drbl_regs_memmap_p) { 7482 dev_printk(KERN_ERR, &pdev->dev, 7483 "ioremap failed for SLI4 HBA doorbell registers.\n"); 7484 goto out_iounmap_ctrl; 7485 } 7486 error = lpfc_sli4_bar2_register_memmap(phba, LPFC_VF0); 7487 if (error) 7488 goto out_iounmap_all; 7489 } 7490 7491 return 0; 7492 7493 out_iounmap_all: 7494 iounmap(phba->sli4_hba.drbl_regs_memmap_p); 7495 out_iounmap_ctrl: 7496 iounmap(phba->sli4_hba.ctrl_regs_memmap_p); 7497 out_iounmap_conf: 7498 iounmap(phba->sli4_hba.conf_regs_memmap_p); 7499 out: 7500 return error; 7501 } 7502 7503 /** 7504 * lpfc_sli4_pci_mem_unset - Unset SLI4 HBA PCI memory space. 7505 * @phba: pointer to lpfc hba data structure. 7506 * 7507 * This routine is invoked to unset the PCI device memory space for device 7508 * with SLI-4 interface spec. 7509 **/ 7510 static void 7511 lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba) 7512 { 7513 uint32_t if_type; 7514 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf); 7515 7516 switch (if_type) { 7517 case LPFC_SLI_INTF_IF_TYPE_0: 7518 iounmap(phba->sli4_hba.drbl_regs_memmap_p); 7519 iounmap(phba->sli4_hba.ctrl_regs_memmap_p); 7520 iounmap(phba->sli4_hba.conf_regs_memmap_p); 7521 break; 7522 case LPFC_SLI_INTF_IF_TYPE_2: 7523 iounmap(phba->sli4_hba.conf_regs_memmap_p); 7524 break; 7525 case LPFC_SLI_INTF_IF_TYPE_1: 7526 default: 7527 dev_printk(KERN_ERR, &phba->pcidev->dev, 7528 "FATAL - unsupported SLI4 interface type - %d\n", 7529 if_type); 7530 break; 7531 } 7532 } 7533 7534 /** 7535 * lpfc_sli_enable_msix - Enable MSI-X interrupt mode on SLI-3 device 7536 * @phba: pointer to lpfc hba data structure. 7537 * 7538 * This routine is invoked to enable the MSI-X interrupt vectors to device 7539 * with SLI-3 interface specs. The kernel function pci_enable_msix() is 7540 * called to enable the MSI-X vectors. Note that pci_enable_msix(), once 7541 * invoked, enables either all or nothing, depending on the current 7542 * availability of PCI vector resources. The device driver is responsible 7543 * for calling the individual request_irq() to register each MSI-X vector 7544 * with a interrupt handler, which is done in this function. Note that 7545 * later when device is unloading, the driver should always call free_irq() 7546 * on all MSI-X vectors it has done request_irq() on before calling 7547 * pci_disable_msix(). Failure to do so results in a BUG_ON() and a device 7548 * will be left with MSI-X enabled and leaks its vectors. 7549 * 7550 * Return codes 7551 * 0 - successful 7552 * other values - error 7553 **/ 7554 static int 7555 lpfc_sli_enable_msix(struct lpfc_hba *phba) 7556 { 7557 int rc, i; 7558 LPFC_MBOXQ_t *pmb; 7559 7560 /* Set up MSI-X multi-message vectors */ 7561 for (i = 0; i < LPFC_MSIX_VECTORS; i++) 7562 phba->msix_entries[i].entry = i; 7563 7564 /* Configure MSI-X capability structure */ 7565 rc = pci_enable_msix(phba->pcidev, phba->msix_entries, 7566 ARRAY_SIZE(phba->msix_entries)); 7567 if (rc) { 7568 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7569 "0420 PCI enable MSI-X failed (%d)\n", rc); 7570 goto msi_fail_out; 7571 } 7572 for (i = 0; i < LPFC_MSIX_VECTORS; i++) 7573 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7574 "0477 MSI-X entry[%d]: vector=x%x " 7575 "message=%d\n", i, 7576 phba->msix_entries[i].vector, 7577 phba->msix_entries[i].entry); 7578 /* 7579 * Assign MSI-X vectors to interrupt handlers 7580 */ 7581 7582 /* vector-0 is associated to slow-path handler */ 7583 rc = request_irq(phba->msix_entries[0].vector, 7584 &lpfc_sli_sp_intr_handler, IRQF_SHARED, 7585 LPFC_SP_DRIVER_HANDLER_NAME, phba); 7586 if (rc) { 7587 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7588 "0421 MSI-X slow-path request_irq failed " 7589 "(%d)\n", rc); 7590 goto msi_fail_out; 7591 } 7592 7593 /* vector-1 is associated to fast-path handler */ 7594 rc = request_irq(phba->msix_entries[1].vector, 7595 &lpfc_sli_fp_intr_handler, IRQF_SHARED, 7596 LPFC_FP_DRIVER_HANDLER_NAME, phba); 7597 7598 if (rc) { 7599 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7600 "0429 MSI-X fast-path request_irq failed " 7601 "(%d)\n", rc); 7602 goto irq_fail_out; 7603 } 7604 7605 /* 7606 * Configure HBA MSI-X attention conditions to messages 7607 */ 7608 pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 7609 7610 if (!pmb) { 7611 rc = -ENOMEM; 7612 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 7613 "0474 Unable to allocate memory for issuing " 7614 "MBOX_CONFIG_MSI command\n"); 7615 goto mem_fail_out; 7616 } 7617 rc = lpfc_config_msi(phba, pmb); 7618 if (rc) 7619 goto mbx_fail_out; 7620 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); 7621 if (rc != MBX_SUCCESS) { 7622 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX, 7623 "0351 Config MSI mailbox command failed, " 7624 "mbxCmd x%x, mbxStatus x%x\n", 7625 pmb->u.mb.mbxCommand, pmb->u.mb.mbxStatus); 7626 goto mbx_fail_out; 7627 } 7628 7629 /* Free memory allocated for mailbox command */ 7630 mempool_free(pmb, phba->mbox_mem_pool); 7631 return rc; 7632 7633 mbx_fail_out: 7634 /* Free memory allocated for mailbox command */ 7635 mempool_free(pmb, phba->mbox_mem_pool); 7636 7637 mem_fail_out: 7638 /* free the irq already requested */ 7639 free_irq(phba->msix_entries[1].vector, phba); 7640 7641 irq_fail_out: 7642 /* free the irq already requested */ 7643 free_irq(phba->msix_entries[0].vector, phba); 7644 7645 msi_fail_out: 7646 /* Unconfigure MSI-X capability structure */ 7647 pci_disable_msix(phba->pcidev); 7648 return rc; 7649 } 7650 7651 /** 7652 * lpfc_sli_disable_msix - Disable MSI-X interrupt mode on SLI-3 device. 7653 * @phba: pointer to lpfc hba data structure. 7654 * 7655 * This routine is invoked to release the MSI-X vectors and then disable the 7656 * MSI-X interrupt mode to device with SLI-3 interface spec. 7657 **/ 7658 static void 7659 lpfc_sli_disable_msix(struct lpfc_hba *phba) 7660 { 7661 int i; 7662 7663 /* Free up MSI-X multi-message vectors */ 7664 for (i = 0; i < LPFC_MSIX_VECTORS; i++) 7665 free_irq(phba->msix_entries[i].vector, phba); 7666 /* Disable MSI-X */ 7667 pci_disable_msix(phba->pcidev); 7668 7669 return; 7670 } 7671 7672 /** 7673 * lpfc_sli_enable_msi - Enable MSI interrupt mode on SLI-3 device. 7674 * @phba: pointer to lpfc hba data structure. 7675 * 7676 * This routine is invoked to enable the MSI interrupt mode to device with 7677 * SLI-3 interface spec. The kernel function pci_enable_msi() is called to 7678 * enable the MSI vector. The device driver is responsible for calling the 7679 * request_irq() to register MSI vector with a interrupt the handler, which 7680 * is done in this function. 7681 * 7682 * Return codes 7683 * 0 - successful 7684 * other values - error 7685 */ 7686 static int 7687 lpfc_sli_enable_msi(struct lpfc_hba *phba) 7688 { 7689 int rc; 7690 7691 rc = pci_enable_msi(phba->pcidev); 7692 if (!rc) 7693 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7694 "0462 PCI enable MSI mode success.\n"); 7695 else { 7696 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7697 "0471 PCI enable MSI mode failed (%d)\n", rc); 7698 return rc; 7699 } 7700 7701 rc = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler, 7702 IRQF_SHARED, LPFC_DRIVER_NAME, phba); 7703 if (rc) { 7704 pci_disable_msi(phba->pcidev); 7705 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7706 "0478 MSI request_irq failed (%d)\n", rc); 7707 } 7708 return rc; 7709 } 7710 7711 /** 7712 * lpfc_sli_disable_msi - Disable MSI interrupt mode to SLI-3 device. 7713 * @phba: pointer to lpfc hba data structure. 7714 * 7715 * This routine is invoked to disable the MSI interrupt mode to device with 7716 * SLI-3 interface spec. The driver calls free_irq() on MSI vector it has 7717 * done request_irq() on before calling pci_disable_msi(). Failure to do so 7718 * results in a BUG_ON() and a device will be left with MSI enabled and leaks 7719 * its vector. 7720 */ 7721 static void 7722 lpfc_sli_disable_msi(struct lpfc_hba *phba) 7723 { 7724 free_irq(phba->pcidev->irq, phba); 7725 pci_disable_msi(phba->pcidev); 7726 return; 7727 } 7728 7729 /** 7730 * lpfc_sli_enable_intr - Enable device interrupt to SLI-3 device. 7731 * @phba: pointer to lpfc hba data structure. 7732 * 7733 * This routine is invoked to enable device interrupt and associate driver's 7734 * interrupt handler(s) to interrupt vector(s) to device with SLI-3 interface 7735 * spec. Depends on the interrupt mode configured to the driver, the driver 7736 * will try to fallback from the configured interrupt mode to an interrupt 7737 * mode which is supported by the platform, kernel, and device in the order 7738 * of: 7739 * MSI-X -> MSI -> IRQ. 7740 * 7741 * Return codes 7742 * 0 - successful 7743 * other values - error 7744 **/ 7745 static uint32_t 7746 lpfc_sli_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode) 7747 { 7748 uint32_t intr_mode = LPFC_INTR_ERROR; 7749 int retval; 7750 7751 if (cfg_mode == 2) { 7752 /* Need to issue conf_port mbox cmd before conf_msi mbox cmd */ 7753 retval = lpfc_sli_config_port(phba, LPFC_SLI_REV3); 7754 if (!retval) { 7755 /* Now, try to enable MSI-X interrupt mode */ 7756 retval = lpfc_sli_enable_msix(phba); 7757 if (!retval) { 7758 /* Indicate initialization to MSI-X mode */ 7759 phba->intr_type = MSIX; 7760 intr_mode = 2; 7761 } 7762 } 7763 } 7764 7765 /* Fallback to MSI if MSI-X initialization failed */ 7766 if (cfg_mode >= 1 && phba->intr_type == NONE) { 7767 retval = lpfc_sli_enable_msi(phba); 7768 if (!retval) { 7769 /* Indicate initialization to MSI mode */ 7770 phba->intr_type = MSI; 7771 intr_mode = 1; 7772 } 7773 } 7774 7775 /* Fallback to INTx if both MSI-X/MSI initalization failed */ 7776 if (phba->intr_type == NONE) { 7777 retval = request_irq(phba->pcidev->irq, lpfc_sli_intr_handler, 7778 IRQF_SHARED, LPFC_DRIVER_NAME, phba); 7779 if (!retval) { 7780 /* Indicate initialization to INTx mode */ 7781 phba->intr_type = INTx; 7782 intr_mode = 0; 7783 } 7784 } 7785 return intr_mode; 7786 } 7787 7788 /** 7789 * lpfc_sli_disable_intr - Disable device interrupt to SLI-3 device. 7790 * @phba: pointer to lpfc hba data structure. 7791 * 7792 * This routine is invoked to disable device interrupt and disassociate the 7793 * driver's interrupt handler(s) from interrupt vector(s) to device with 7794 * SLI-3 interface spec. Depending on the interrupt mode, the driver will 7795 * release the interrupt vector(s) for the message signaled interrupt. 7796 **/ 7797 static void 7798 lpfc_sli_disable_intr(struct lpfc_hba *phba) 7799 { 7800 /* Disable the currently initialized interrupt mode */ 7801 if (phba->intr_type == MSIX) 7802 lpfc_sli_disable_msix(phba); 7803 else if (phba->intr_type == MSI) 7804 lpfc_sli_disable_msi(phba); 7805 else if (phba->intr_type == INTx) 7806 free_irq(phba->pcidev->irq, phba); 7807 7808 /* Reset interrupt management states */ 7809 phba->intr_type = NONE; 7810 phba->sli.slistat.sli_intr = 0; 7811 7812 return; 7813 } 7814 7815 /** 7816 * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device 7817 * @phba: pointer to lpfc hba data structure. 7818 * 7819 * This routine is invoked to enable the MSI-X interrupt vectors to device 7820 * with SLI-4 interface spec. The kernel function pci_enable_msix() is called 7821 * to enable the MSI-X vectors. Note that pci_enable_msix(), once invoked, 7822 * enables either all or nothing, depending on the current availability of 7823 * PCI vector resources. The device driver is responsible for calling the 7824 * individual request_irq() to register each MSI-X vector with a interrupt 7825 * handler, which is done in this function. Note that later when device is 7826 * unloading, the driver should always call free_irq() on all MSI-X vectors 7827 * it has done request_irq() on before calling pci_disable_msix(). Failure 7828 * to do so results in a BUG_ON() and a device will be left with MSI-X 7829 * enabled and leaks its vectors. 7830 * 7831 * Return codes 7832 * 0 - successful 7833 * other values - error 7834 **/ 7835 static int 7836 lpfc_sli4_enable_msix(struct lpfc_hba *phba) 7837 { 7838 int vectors, rc, index; 7839 7840 /* Set up MSI-X multi-message vectors */ 7841 for (index = 0; index < phba->sli4_hba.cfg_eqn; index++) 7842 phba->sli4_hba.msix_entries[index].entry = index; 7843 7844 /* Configure MSI-X capability structure */ 7845 vectors = phba->sli4_hba.cfg_eqn; 7846 enable_msix_vectors: 7847 rc = pci_enable_msix(phba->pcidev, phba->sli4_hba.msix_entries, 7848 vectors); 7849 if (rc > 1) { 7850 vectors = rc; 7851 goto enable_msix_vectors; 7852 } else if (rc) { 7853 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7854 "0484 PCI enable MSI-X failed (%d)\n", rc); 7855 goto msi_fail_out; 7856 } 7857 7858 /* Log MSI-X vector assignment */ 7859 for (index = 0; index < vectors; index++) 7860 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7861 "0489 MSI-X entry[%d]: vector=x%x " 7862 "message=%d\n", index, 7863 phba->sli4_hba.msix_entries[index].vector, 7864 phba->sli4_hba.msix_entries[index].entry); 7865 /* 7866 * Assign MSI-X vectors to interrupt handlers 7867 */ 7868 if (vectors > 1) 7869 rc = request_irq(phba->sli4_hba.msix_entries[0].vector, 7870 &lpfc_sli4_sp_intr_handler, IRQF_SHARED, 7871 LPFC_SP_DRIVER_HANDLER_NAME, phba); 7872 else 7873 /* All Interrupts need to be handled by one EQ */ 7874 rc = request_irq(phba->sli4_hba.msix_entries[0].vector, 7875 &lpfc_sli4_intr_handler, IRQF_SHARED, 7876 LPFC_DRIVER_NAME, phba); 7877 if (rc) { 7878 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7879 "0485 MSI-X slow-path request_irq failed " 7880 "(%d)\n", rc); 7881 goto msi_fail_out; 7882 } 7883 7884 /* The rest of the vector(s) are associated to fast-path handler(s) */ 7885 for (index = 1; index < vectors; index++) { 7886 phba->sli4_hba.fcp_eq_hdl[index - 1].idx = index - 1; 7887 phba->sli4_hba.fcp_eq_hdl[index - 1].phba = phba; 7888 rc = request_irq(phba->sli4_hba.msix_entries[index].vector, 7889 &lpfc_sli4_fp_intr_handler, IRQF_SHARED, 7890 LPFC_FP_DRIVER_HANDLER_NAME, 7891 &phba->sli4_hba.fcp_eq_hdl[index - 1]); 7892 if (rc) { 7893 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7894 "0486 MSI-X fast-path (%d) " 7895 "request_irq failed (%d)\n", index, rc); 7896 goto cfg_fail_out; 7897 } 7898 } 7899 phba->sli4_hba.msix_vec_nr = vectors; 7900 7901 return rc; 7902 7903 cfg_fail_out: 7904 /* free the irq already requested */ 7905 for (--index; index >= 1; index--) 7906 free_irq(phba->sli4_hba.msix_entries[index - 1].vector, 7907 &phba->sli4_hba.fcp_eq_hdl[index - 1]); 7908 7909 /* free the irq already requested */ 7910 free_irq(phba->sli4_hba.msix_entries[0].vector, phba); 7911 7912 msi_fail_out: 7913 /* Unconfigure MSI-X capability structure */ 7914 pci_disable_msix(phba->pcidev); 7915 return rc; 7916 } 7917 7918 /** 7919 * lpfc_sli4_disable_msix - Disable MSI-X interrupt mode to SLI-4 device 7920 * @phba: pointer to lpfc hba data structure. 7921 * 7922 * This routine is invoked to release the MSI-X vectors and then disable the 7923 * MSI-X interrupt mode to device with SLI-4 interface spec. 7924 **/ 7925 static void 7926 lpfc_sli4_disable_msix(struct lpfc_hba *phba) 7927 { 7928 int index; 7929 7930 /* Free up MSI-X multi-message vectors */ 7931 free_irq(phba->sli4_hba.msix_entries[0].vector, phba); 7932 7933 for (index = 1; index < phba->sli4_hba.msix_vec_nr; index++) 7934 free_irq(phba->sli4_hba.msix_entries[index].vector, 7935 &phba->sli4_hba.fcp_eq_hdl[index - 1]); 7936 7937 /* Disable MSI-X */ 7938 pci_disable_msix(phba->pcidev); 7939 7940 return; 7941 } 7942 7943 /** 7944 * lpfc_sli4_enable_msi - Enable MSI interrupt mode to SLI-4 device 7945 * @phba: pointer to lpfc hba data structure. 7946 * 7947 * This routine is invoked to enable the MSI interrupt mode to device with 7948 * SLI-4 interface spec. The kernel function pci_enable_msi() is called 7949 * to enable the MSI vector. The device driver is responsible for calling 7950 * the request_irq() to register MSI vector with a interrupt the handler, 7951 * which is done in this function. 7952 * 7953 * Return codes 7954 * 0 - successful 7955 * other values - error 7956 **/ 7957 static int 7958 lpfc_sli4_enable_msi(struct lpfc_hba *phba) 7959 { 7960 int rc, index; 7961 7962 rc = pci_enable_msi(phba->pcidev); 7963 if (!rc) 7964 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7965 "0487 PCI enable MSI mode success.\n"); 7966 else { 7967 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 7968 "0488 PCI enable MSI mode failed (%d)\n", rc); 7969 return rc; 7970 } 7971 7972 rc = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler, 7973 IRQF_SHARED, LPFC_DRIVER_NAME, phba); 7974 if (rc) { 7975 pci_disable_msi(phba->pcidev); 7976 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT, 7977 "0490 MSI request_irq failed (%d)\n", rc); 7978 return rc; 7979 } 7980 7981 for (index = 0; index < phba->cfg_fcp_eq_count; index++) { 7982 phba->sli4_hba.fcp_eq_hdl[index].idx = index; 7983 phba->sli4_hba.fcp_eq_hdl[index].phba = phba; 7984 } 7985 7986 return 0; 7987 } 7988 7989 /** 7990 * lpfc_sli4_disable_msi - Disable MSI interrupt mode to SLI-4 device 7991 * @phba: pointer to lpfc hba data structure. 7992 * 7993 * This routine is invoked to disable the MSI interrupt mode to device with 7994 * SLI-4 interface spec. The driver calls free_irq() on MSI vector it has 7995 * done request_irq() on before calling pci_disable_msi(). Failure to do so 7996 * results in a BUG_ON() and a device will be left with MSI enabled and leaks 7997 * its vector. 7998 **/ 7999 static void 8000 lpfc_sli4_disable_msi(struct lpfc_hba *phba) 8001 { 8002 free_irq(phba->pcidev->irq, phba); 8003 pci_disable_msi(phba->pcidev); 8004 return; 8005 } 8006 8007 /** 8008 * lpfc_sli4_enable_intr - Enable device interrupt to SLI-4 device 8009 * @phba: pointer to lpfc hba data structure. 8010 * 8011 * This routine is invoked to enable device interrupt and associate driver's 8012 * interrupt handler(s) to interrupt vector(s) to device with SLI-4 8013 * interface spec. Depends on the interrupt mode configured to the driver, 8014 * the driver will try to fallback from the configured interrupt mode to an 8015 * interrupt mode which is supported by the platform, kernel, and device in 8016 * the order of: 8017 * MSI-X -> MSI -> IRQ. 8018 * 8019 * Return codes 8020 * 0 - successful 8021 * other values - error 8022 **/ 8023 static uint32_t 8024 lpfc_sli4_enable_intr(struct lpfc_hba *phba, uint32_t cfg_mode) 8025 { 8026 uint32_t intr_mode = LPFC_INTR_ERROR; 8027 int retval, index; 8028 8029 if (cfg_mode == 2) { 8030 /* Preparation before conf_msi mbox cmd */ 8031 retval = 0; 8032 if (!retval) { 8033 /* Now, try to enable MSI-X interrupt mode */ 8034 retval = lpfc_sli4_enable_msix(phba); 8035 if (!retval) { 8036 /* Indicate initialization to MSI-X mode */ 8037 phba->intr_type = MSIX; 8038 intr_mode = 2; 8039 } 8040 } 8041 } 8042 8043 /* Fallback to MSI if MSI-X initialization failed */ 8044 if (cfg_mode >= 1 && phba->intr_type == NONE) { 8045 retval = lpfc_sli4_enable_msi(phba); 8046 if (!retval) { 8047 /* Indicate initialization to MSI mode */ 8048 phba->intr_type = MSI; 8049 intr_mode = 1; 8050 } 8051 } 8052 8053 /* Fallback to INTx if both MSI-X/MSI initalization failed */ 8054 if (phba->intr_type == NONE) { 8055 retval = request_irq(phba->pcidev->irq, lpfc_sli4_intr_handler, 8056 IRQF_SHARED, LPFC_DRIVER_NAME, phba); 8057 if (!retval) { 8058 /* Indicate initialization to INTx mode */ 8059 phba->intr_type = INTx; 8060 intr_mode = 0; 8061 for (index = 0; index < phba->cfg_fcp_eq_count; 8062 index++) { 8063 phba->sli4_hba.fcp_eq_hdl[index].idx = index; 8064 phba->sli4_hba.fcp_eq_hdl[index].phba = phba; 8065 } 8066 } 8067 } 8068 return intr_mode; 8069 } 8070 8071 /** 8072 * lpfc_sli4_disable_intr - Disable device interrupt to SLI-4 device 8073 * @phba: pointer to lpfc hba data structure. 8074 * 8075 * This routine is invoked to disable device interrupt and disassociate 8076 * the driver's interrupt handler(s) from interrupt vector(s) to device 8077 * with SLI-4 interface spec. Depending on the interrupt mode, the driver 8078 * will release the interrupt vector(s) for the message signaled interrupt. 8079 **/ 8080 static void 8081 lpfc_sli4_disable_intr(struct lpfc_hba *phba) 8082 { 8083 /* Disable the currently initialized interrupt mode */ 8084 if (phba->intr_type == MSIX) 8085 lpfc_sli4_disable_msix(phba); 8086 else if (phba->intr_type == MSI) 8087 lpfc_sli4_disable_msi(phba); 8088 else if (phba->intr_type == INTx) 8089 free_irq(phba->pcidev->irq, phba); 8090 8091 /* Reset interrupt management states */ 8092 phba->intr_type = NONE; 8093 phba->sli.slistat.sli_intr = 0; 8094 8095 return; 8096 } 8097 8098 /** 8099 * lpfc_unset_hba - Unset SLI3 hba device initialization 8100 * @phba: pointer to lpfc hba data structure. 8101 * 8102 * This routine is invoked to unset the HBA device initialization steps to 8103 * a device with SLI-3 interface spec. 8104 **/ 8105 static void 8106 lpfc_unset_hba(struct lpfc_hba *phba) 8107 { 8108 struct lpfc_vport *vport = phba->pport; 8109 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 8110 8111 spin_lock_irq(shost->host_lock); 8112 vport->load_flag |= FC_UNLOADING; 8113 spin_unlock_irq(shost->host_lock); 8114 8115 lpfc_stop_hba_timers(phba); 8116 8117 phba->pport->work_port_events = 0; 8118 8119 lpfc_sli_hba_down(phba); 8120 8121 lpfc_sli_brdrestart(phba); 8122 8123 lpfc_sli_disable_intr(phba); 8124 8125 return; 8126 } 8127 8128 /** 8129 * lpfc_sli4_unset_hba - Unset SLI4 hba device initialization. 8130 * @phba: pointer to lpfc hba data structure. 8131 * 8132 * This routine is invoked to unset the HBA device initialization steps to 8133 * a device with SLI-4 interface spec. 8134 **/ 8135 static void 8136 lpfc_sli4_unset_hba(struct lpfc_hba *phba) 8137 { 8138 struct lpfc_vport *vport = phba->pport; 8139 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 8140 8141 spin_lock_irq(shost->host_lock); 8142 vport->load_flag |= FC_UNLOADING; 8143 spin_unlock_irq(shost->host_lock); 8144 8145 phba->pport->work_port_events = 0; 8146 8147 /* Stop the SLI4 device port */ 8148 lpfc_stop_port(phba); 8149 8150 lpfc_sli4_disable_intr(phba); 8151 8152 /* Reset SLI4 HBA FCoE function */ 8153 lpfc_pci_function_reset(phba); 8154 lpfc_sli4_queue_destroy(phba); 8155 8156 return; 8157 } 8158 8159 /** 8160 * lpfc_sli4_xri_exchange_busy_wait - Wait for device XRI exchange busy 8161 * @phba: Pointer to HBA context object. 8162 * 8163 * This function is called in the SLI4 code path to wait for completion 8164 * of device's XRIs exchange busy. It will check the XRI exchange busy 8165 * on outstanding FCP and ELS I/Os every 10ms for up to 10 seconds; after 8166 * that, it will check the XRI exchange busy on outstanding FCP and ELS 8167 * I/Os every 30 seconds, log error message, and wait forever. Only when 8168 * all XRI exchange busy complete, the driver unload shall proceed with 8169 * invoking the function reset ioctl mailbox command to the CNA and the 8170 * the rest of the driver unload resource release. 8171 **/ 8172 static void 8173 lpfc_sli4_xri_exchange_busy_wait(struct lpfc_hba *phba) 8174 { 8175 int wait_time = 0; 8176 int fcp_xri_cmpl = list_empty(&phba->sli4_hba.lpfc_abts_scsi_buf_list); 8177 int els_xri_cmpl = list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list); 8178 8179 while (!fcp_xri_cmpl || !els_xri_cmpl) { 8180 if (wait_time > LPFC_XRI_EXCH_BUSY_WAIT_TMO) { 8181 if (!fcp_xri_cmpl) 8182 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8183 "2877 FCP XRI exchange busy " 8184 "wait time: %d seconds.\n", 8185 wait_time/1000); 8186 if (!els_xri_cmpl) 8187 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8188 "2878 ELS XRI exchange busy " 8189 "wait time: %d seconds.\n", 8190 wait_time/1000); 8191 msleep(LPFC_XRI_EXCH_BUSY_WAIT_T2); 8192 wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T2; 8193 } else { 8194 msleep(LPFC_XRI_EXCH_BUSY_WAIT_T1); 8195 wait_time += LPFC_XRI_EXCH_BUSY_WAIT_T1; 8196 } 8197 fcp_xri_cmpl = 8198 list_empty(&phba->sli4_hba.lpfc_abts_scsi_buf_list); 8199 els_xri_cmpl = 8200 list_empty(&phba->sli4_hba.lpfc_abts_els_sgl_list); 8201 } 8202 } 8203 8204 /** 8205 * lpfc_sli4_hba_unset - Unset the fcoe hba 8206 * @phba: Pointer to HBA context object. 8207 * 8208 * This function is called in the SLI4 code path to reset the HBA's FCoE 8209 * function. The caller is not required to hold any lock. This routine 8210 * issues PCI function reset mailbox command to reset the FCoE function. 8211 * At the end of the function, it calls lpfc_hba_down_post function to 8212 * free any pending commands. 8213 **/ 8214 static void 8215 lpfc_sli4_hba_unset(struct lpfc_hba *phba) 8216 { 8217 int wait_cnt = 0; 8218 LPFC_MBOXQ_t *mboxq; 8219 struct pci_dev *pdev = phba->pcidev; 8220 8221 lpfc_stop_hba_timers(phba); 8222 phba->sli4_hba.intr_enable = 0; 8223 8224 /* 8225 * Gracefully wait out the potential current outstanding asynchronous 8226 * mailbox command. 8227 */ 8228 8229 /* First, block any pending async mailbox command from posted */ 8230 spin_lock_irq(&phba->hbalock); 8231 phba->sli.sli_flag |= LPFC_SLI_ASYNC_MBX_BLK; 8232 spin_unlock_irq(&phba->hbalock); 8233 /* Now, trying to wait it out if we can */ 8234 while (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) { 8235 msleep(10); 8236 if (++wait_cnt > LPFC_ACTIVE_MBOX_WAIT_CNT) 8237 break; 8238 } 8239 /* Forcefully release the outstanding mailbox command if timed out */ 8240 if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) { 8241 spin_lock_irq(&phba->hbalock); 8242 mboxq = phba->sli.mbox_active; 8243 mboxq->u.mb.mbxStatus = MBX_NOT_FINISHED; 8244 __lpfc_mbox_cmpl_put(phba, mboxq); 8245 phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE; 8246 phba->sli.mbox_active = NULL; 8247 spin_unlock_irq(&phba->hbalock); 8248 } 8249 8250 /* Abort all iocbs associated with the hba */ 8251 lpfc_sli_hba_iocb_abort(phba); 8252 8253 /* Wait for completion of device XRI exchange busy */ 8254 lpfc_sli4_xri_exchange_busy_wait(phba); 8255 8256 /* Disable PCI subsystem interrupt */ 8257 lpfc_sli4_disable_intr(phba); 8258 8259 /* Disable SR-IOV if enabled */ 8260 if (phba->cfg_sriov_nr_virtfn) 8261 pci_disable_sriov(pdev); 8262 8263 /* Stop kthread signal shall trigger work_done one more time */ 8264 kthread_stop(phba->worker_thread); 8265 8266 /* Reset SLI4 HBA FCoE function */ 8267 lpfc_pci_function_reset(phba); 8268 lpfc_sli4_queue_destroy(phba); 8269 8270 /* Stop the SLI4 device port */ 8271 phba->pport->work_port_events = 0; 8272 } 8273 8274 /** 8275 * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities. 8276 * @phba: Pointer to HBA context object. 8277 * @mboxq: Pointer to the mailboxq memory for the mailbox command response. 8278 * 8279 * This function is called in the SLI4 code path to read the port's 8280 * sli4 capabilities. 8281 * 8282 * This function may be be called from any context that can block-wait 8283 * for the completion. The expectation is that this routine is called 8284 * typically from probe_one or from the online routine. 8285 **/ 8286 int 8287 lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 8288 { 8289 int rc; 8290 struct lpfc_mqe *mqe; 8291 struct lpfc_pc_sli4_params *sli4_params; 8292 uint32_t mbox_tmo; 8293 8294 rc = 0; 8295 mqe = &mboxq->u.mqe; 8296 8297 /* Read the port's SLI4 Parameters port capabilities */ 8298 lpfc_pc_sli4_params(mboxq); 8299 if (!phba->sli4_hba.intr_enable) 8300 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 8301 else { 8302 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq); 8303 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo); 8304 } 8305 8306 if (unlikely(rc)) 8307 return 1; 8308 8309 sli4_params = &phba->sli4_hba.pc_sli4_params; 8310 sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params); 8311 sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params); 8312 sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params); 8313 sli4_params->featurelevel_1 = bf_get(featurelevel_1, 8314 &mqe->un.sli4_params); 8315 sli4_params->featurelevel_2 = bf_get(featurelevel_2, 8316 &mqe->un.sli4_params); 8317 sli4_params->proto_types = mqe->un.sli4_params.word3; 8318 sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len; 8319 sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params); 8320 sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params); 8321 sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params); 8322 sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params); 8323 sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params); 8324 sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params); 8325 sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params); 8326 sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params); 8327 sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params); 8328 sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params); 8329 sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params); 8330 sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params); 8331 sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params); 8332 sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params); 8333 sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params); 8334 sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params); 8335 sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params); 8336 sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params); 8337 sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params); 8338 8339 /* Make sure that sge_supp_len can be handled by the driver */ 8340 if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE) 8341 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE; 8342 8343 return rc; 8344 } 8345 8346 /** 8347 * lpfc_get_sli4_parameters - Get the SLI4 Config PARAMETERS. 8348 * @phba: Pointer to HBA context object. 8349 * @mboxq: Pointer to the mailboxq memory for the mailbox command response. 8350 * 8351 * This function is called in the SLI4 code path to read the port's 8352 * sli4 capabilities. 8353 * 8354 * This function may be be called from any context that can block-wait 8355 * for the completion. The expectation is that this routine is called 8356 * typically from probe_one or from the online routine. 8357 **/ 8358 int 8359 lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq) 8360 { 8361 int rc; 8362 struct lpfc_mqe *mqe = &mboxq->u.mqe; 8363 struct lpfc_pc_sli4_params *sli4_params; 8364 uint32_t mbox_tmo; 8365 int length; 8366 struct lpfc_sli4_parameters *mbx_sli4_parameters; 8367 8368 /* 8369 * By default, the driver assumes the SLI4 port requires RPI 8370 * header postings. The SLI4_PARAM response will correct this 8371 * assumption. 8372 */ 8373 phba->sli4_hba.rpi_hdrs_in_use = 1; 8374 8375 /* Read the port's SLI4 Config Parameters */ 8376 length = (sizeof(struct lpfc_mbx_get_sli4_parameters) - 8377 sizeof(struct lpfc_sli4_cfg_mhdr)); 8378 lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON, 8379 LPFC_MBOX_OPCODE_GET_SLI4_PARAMETERS, 8380 length, LPFC_SLI4_MBX_EMBED); 8381 if (!phba->sli4_hba.intr_enable) 8382 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL); 8383 else { 8384 mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq); 8385 rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo); 8386 } 8387 if (unlikely(rc)) 8388 return rc; 8389 sli4_params = &phba->sli4_hba.pc_sli4_params; 8390 mbx_sli4_parameters = &mqe->un.get_sli4_parameters.sli4_parameters; 8391 sli4_params->if_type = bf_get(cfg_if_type, mbx_sli4_parameters); 8392 sli4_params->sli_rev = bf_get(cfg_sli_rev, mbx_sli4_parameters); 8393 sli4_params->sli_family = bf_get(cfg_sli_family, mbx_sli4_parameters); 8394 sli4_params->featurelevel_1 = bf_get(cfg_sli_hint_1, 8395 mbx_sli4_parameters); 8396 sli4_params->featurelevel_2 = bf_get(cfg_sli_hint_2, 8397 mbx_sli4_parameters); 8398 if (bf_get(cfg_phwq, mbx_sli4_parameters)) 8399 phba->sli3_options |= LPFC_SLI4_PHWQ_ENABLED; 8400 else 8401 phba->sli3_options &= ~LPFC_SLI4_PHWQ_ENABLED; 8402 sli4_params->sge_supp_len = mbx_sli4_parameters->sge_supp_len; 8403 sli4_params->loopbk_scope = bf_get(loopbk_scope, mbx_sli4_parameters); 8404 sli4_params->cqv = bf_get(cfg_cqv, mbx_sli4_parameters); 8405 sli4_params->mqv = bf_get(cfg_mqv, mbx_sli4_parameters); 8406 sli4_params->wqv = bf_get(cfg_wqv, mbx_sli4_parameters); 8407 sli4_params->rqv = bf_get(cfg_rqv, mbx_sli4_parameters); 8408 sli4_params->sgl_pages_max = bf_get(cfg_sgl_page_cnt, 8409 mbx_sli4_parameters); 8410 sli4_params->sgl_pp_align = bf_get(cfg_sgl_pp_align, 8411 mbx_sli4_parameters); 8412 phba->sli4_hba.extents_in_use = bf_get(cfg_ext, mbx_sli4_parameters); 8413 phba->sli4_hba.rpi_hdrs_in_use = bf_get(cfg_hdrr, mbx_sli4_parameters); 8414 8415 /* Make sure that sge_supp_len can be handled by the driver */ 8416 if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE) 8417 sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE; 8418 8419 return 0; 8420 } 8421 8422 /** 8423 * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem. 8424 * @pdev: pointer to PCI device 8425 * @pid: pointer to PCI device identifier 8426 * 8427 * This routine is to be called to attach a device with SLI-3 interface spec 8428 * to the PCI subsystem. When an Emulex HBA with SLI-3 interface spec is 8429 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific 8430 * information of the device and driver to see if the driver state that it can 8431 * support this kind of device. If the match is successful, the driver core 8432 * invokes this routine. If this routine determines it can claim the HBA, it 8433 * does all the initialization that it needs to do to handle the HBA properly. 8434 * 8435 * Return code 8436 * 0 - driver can claim the device 8437 * negative value - driver can not claim the device 8438 **/ 8439 static int __devinit 8440 lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid) 8441 { 8442 struct lpfc_hba *phba; 8443 struct lpfc_vport *vport = NULL; 8444 struct Scsi_Host *shost = NULL; 8445 int error; 8446 uint32_t cfg_mode, intr_mode; 8447 8448 /* Allocate memory for HBA structure */ 8449 phba = lpfc_hba_alloc(pdev); 8450 if (!phba) 8451 return -ENOMEM; 8452 8453 /* Perform generic PCI device enabling operation */ 8454 error = lpfc_enable_pci_dev(phba); 8455 if (error) 8456 goto out_free_phba; 8457 8458 /* Set up SLI API function jump table for PCI-device group-0 HBAs */ 8459 error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_LP); 8460 if (error) 8461 goto out_disable_pci_dev; 8462 8463 /* Set up SLI-3 specific device PCI memory space */ 8464 error = lpfc_sli_pci_mem_setup(phba); 8465 if (error) { 8466 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8467 "1402 Failed to set up pci memory space.\n"); 8468 goto out_disable_pci_dev; 8469 } 8470 8471 /* Set up phase-1 common device driver resources */ 8472 error = lpfc_setup_driver_resource_phase1(phba); 8473 if (error) { 8474 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8475 "1403 Failed to set up driver resource.\n"); 8476 goto out_unset_pci_mem_s3; 8477 } 8478 8479 /* Set up SLI-3 specific device driver resources */ 8480 error = lpfc_sli_driver_resource_setup(phba); 8481 if (error) { 8482 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8483 "1404 Failed to set up driver resource.\n"); 8484 goto out_unset_pci_mem_s3; 8485 } 8486 8487 /* Initialize and populate the iocb list per host */ 8488 error = lpfc_init_iocb_list(phba, LPFC_IOCB_LIST_CNT); 8489 if (error) { 8490 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8491 "1405 Failed to initialize iocb list.\n"); 8492 goto out_unset_driver_resource_s3; 8493 } 8494 8495 /* Set up common device driver resources */ 8496 error = lpfc_setup_driver_resource_phase2(phba); 8497 if (error) { 8498 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8499 "1406 Failed to set up driver resource.\n"); 8500 goto out_free_iocb_list; 8501 } 8502 8503 /* Get the default values for Model Name and Description */ 8504 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc); 8505 8506 /* Create SCSI host to the physical port */ 8507 error = lpfc_create_shost(phba); 8508 if (error) { 8509 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8510 "1407 Failed to create scsi host.\n"); 8511 goto out_unset_driver_resource; 8512 } 8513 8514 /* Configure sysfs attributes */ 8515 vport = phba->pport; 8516 error = lpfc_alloc_sysfs_attr(vport); 8517 if (error) { 8518 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8519 "1476 Failed to allocate sysfs attr\n"); 8520 goto out_destroy_shost; 8521 } 8522 8523 shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */ 8524 /* Now, trying to enable interrupt and bring up the device */ 8525 cfg_mode = phba->cfg_use_msi; 8526 while (true) { 8527 /* Put device to a known state before enabling interrupt */ 8528 lpfc_stop_port(phba); 8529 /* Configure and enable interrupt */ 8530 intr_mode = lpfc_sli_enable_intr(phba, cfg_mode); 8531 if (intr_mode == LPFC_INTR_ERROR) { 8532 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8533 "0431 Failed to enable interrupt.\n"); 8534 error = -ENODEV; 8535 goto out_free_sysfs_attr; 8536 } 8537 /* SLI-3 HBA setup */ 8538 if (lpfc_sli_hba_setup(phba)) { 8539 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8540 "1477 Failed to set up hba\n"); 8541 error = -ENODEV; 8542 goto out_remove_device; 8543 } 8544 8545 /* Wait 50ms for the interrupts of previous mailbox commands */ 8546 msleep(50); 8547 /* Check active interrupts on message signaled interrupts */ 8548 if (intr_mode == 0 || 8549 phba->sli.slistat.sli_intr > LPFC_MSIX_VECTORS) { 8550 /* Log the current active interrupt mode */ 8551 phba->intr_mode = intr_mode; 8552 lpfc_log_intr_mode(phba, intr_mode); 8553 break; 8554 } else { 8555 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 8556 "0447 Configure interrupt mode (%d) " 8557 "failed active interrupt test.\n", 8558 intr_mode); 8559 /* Disable the current interrupt mode */ 8560 lpfc_sli_disable_intr(phba); 8561 /* Try next level of interrupt mode */ 8562 cfg_mode = --intr_mode; 8563 } 8564 } 8565 8566 /* Perform post initialization setup */ 8567 lpfc_post_init_setup(phba); 8568 8569 /* Check if there are static vports to be created. */ 8570 lpfc_create_static_vport(phba); 8571 8572 return 0; 8573 8574 out_remove_device: 8575 lpfc_unset_hba(phba); 8576 out_free_sysfs_attr: 8577 lpfc_free_sysfs_attr(vport); 8578 out_destroy_shost: 8579 lpfc_destroy_shost(phba); 8580 out_unset_driver_resource: 8581 lpfc_unset_driver_resource_phase2(phba); 8582 out_free_iocb_list: 8583 lpfc_free_iocb_list(phba); 8584 out_unset_driver_resource_s3: 8585 lpfc_sli_driver_resource_unset(phba); 8586 out_unset_pci_mem_s3: 8587 lpfc_sli_pci_mem_unset(phba); 8588 out_disable_pci_dev: 8589 lpfc_disable_pci_dev(phba); 8590 if (shost) 8591 scsi_host_put(shost); 8592 out_free_phba: 8593 lpfc_hba_free(phba); 8594 return error; 8595 } 8596 8597 /** 8598 * lpfc_pci_remove_one_s3 - PCI func to unreg SLI-3 device from PCI subsystem. 8599 * @pdev: pointer to PCI device 8600 * 8601 * This routine is to be called to disattach a device with SLI-3 interface 8602 * spec from PCI subsystem. When an Emulex HBA with SLI-3 interface spec is 8603 * removed from PCI bus, it performs all the necessary cleanup for the HBA 8604 * device to be removed from the PCI subsystem properly. 8605 **/ 8606 static void __devexit 8607 lpfc_pci_remove_one_s3(struct pci_dev *pdev) 8608 { 8609 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8610 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 8611 struct lpfc_vport **vports; 8612 struct lpfc_hba *phba = vport->phba; 8613 int i; 8614 int bars = pci_select_bars(pdev, IORESOURCE_MEM); 8615 8616 spin_lock_irq(&phba->hbalock); 8617 vport->load_flag |= FC_UNLOADING; 8618 spin_unlock_irq(&phba->hbalock); 8619 8620 lpfc_free_sysfs_attr(vport); 8621 8622 /* Release all the vports against this physical port */ 8623 vports = lpfc_create_vport_work_array(phba); 8624 if (vports != NULL) 8625 for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++) 8626 fc_vport_terminate(vports[i]->fc_vport); 8627 lpfc_destroy_vport_work_array(phba, vports); 8628 8629 /* Remove FC host and then SCSI host with the physical port */ 8630 fc_remove_host(shost); 8631 scsi_remove_host(shost); 8632 lpfc_cleanup(vport); 8633 8634 /* 8635 * Bring down the SLI Layer. This step disable all interrupts, 8636 * clears the rings, discards all mailbox commands, and resets 8637 * the HBA. 8638 */ 8639 8640 /* HBA interrupt will be disabled after this call */ 8641 lpfc_sli_hba_down(phba); 8642 /* Stop kthread signal shall trigger work_done one more time */ 8643 kthread_stop(phba->worker_thread); 8644 /* Final cleanup of txcmplq and reset the HBA */ 8645 lpfc_sli_brdrestart(phba); 8646 8647 lpfc_stop_hba_timers(phba); 8648 spin_lock_irq(&phba->hbalock); 8649 list_del_init(&vport->listentry); 8650 spin_unlock_irq(&phba->hbalock); 8651 8652 lpfc_debugfs_terminate(vport); 8653 8654 /* Disable SR-IOV if enabled */ 8655 if (phba->cfg_sriov_nr_virtfn) 8656 pci_disable_sriov(pdev); 8657 8658 /* Disable interrupt */ 8659 lpfc_sli_disable_intr(phba); 8660 8661 pci_set_drvdata(pdev, NULL); 8662 scsi_host_put(shost); 8663 8664 /* 8665 * Call scsi_free before mem_free since scsi bufs are released to their 8666 * corresponding pools here. 8667 */ 8668 lpfc_scsi_free(phba); 8669 lpfc_mem_free_all(phba); 8670 8671 dma_free_coherent(&pdev->dev, lpfc_sli_hbq_size(), 8672 phba->hbqslimp.virt, phba->hbqslimp.phys); 8673 8674 /* Free resources associated with SLI2 interface */ 8675 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE, 8676 phba->slim2p.virt, phba->slim2p.phys); 8677 8678 /* unmap adapter SLIM and Control Registers */ 8679 iounmap(phba->ctrl_regs_memmap_p); 8680 iounmap(phba->slim_memmap_p); 8681 8682 lpfc_hba_free(phba); 8683 8684 pci_release_selected_regions(pdev, bars); 8685 pci_disable_device(pdev); 8686 } 8687 8688 /** 8689 * lpfc_pci_suspend_one_s3 - PCI func to suspend SLI-3 device for power mgmnt 8690 * @pdev: pointer to PCI device 8691 * @msg: power management message 8692 * 8693 * This routine is to be called from the kernel's PCI subsystem to support 8694 * system Power Management (PM) to device with SLI-3 interface spec. When 8695 * PM invokes this method, it quiesces the device by stopping the driver's 8696 * worker thread for the device, turning off device's interrupt and DMA, 8697 * and bring the device offline. Note that as the driver implements the 8698 * minimum PM requirements to a power-aware driver's PM support for the 8699 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE) 8700 * to the suspend() method call will be treated as SUSPEND and the driver will 8701 * fully reinitialize its device during resume() method call, the driver will 8702 * set device to PCI_D3hot state in PCI config space instead of setting it 8703 * according to the @msg provided by the PM. 8704 * 8705 * Return code 8706 * 0 - driver suspended the device 8707 * Error otherwise 8708 **/ 8709 static int 8710 lpfc_pci_suspend_one_s3(struct pci_dev *pdev, pm_message_t msg) 8711 { 8712 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8713 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 8714 8715 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 8716 "0473 PCI device Power Management suspend.\n"); 8717 8718 /* Bring down the device */ 8719 lpfc_offline_prep(phba); 8720 lpfc_offline(phba); 8721 kthread_stop(phba->worker_thread); 8722 8723 /* Disable interrupt from device */ 8724 lpfc_sli_disable_intr(phba); 8725 8726 /* Save device state to PCI config space */ 8727 pci_save_state(pdev); 8728 pci_set_power_state(pdev, PCI_D3hot); 8729 8730 return 0; 8731 } 8732 8733 /** 8734 * lpfc_pci_resume_one_s3 - PCI func to resume SLI-3 device for power mgmnt 8735 * @pdev: pointer to PCI device 8736 * 8737 * This routine is to be called from the kernel's PCI subsystem to support 8738 * system Power Management (PM) to device with SLI-3 interface spec. When PM 8739 * invokes this method, it restores the device's PCI config space state and 8740 * fully reinitializes the device and brings it online. Note that as the 8741 * driver implements the minimum PM requirements to a power-aware driver's 8742 * PM for suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, 8743 * FREEZE) to the suspend() method call will be treated as SUSPEND and the 8744 * driver will fully reinitialize its device during resume() method call, 8745 * the device will be set to PCI_D0 directly in PCI config space before 8746 * restoring the state. 8747 * 8748 * Return code 8749 * 0 - driver suspended the device 8750 * Error otherwise 8751 **/ 8752 static int 8753 lpfc_pci_resume_one_s3(struct pci_dev *pdev) 8754 { 8755 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8756 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 8757 uint32_t intr_mode; 8758 int error; 8759 8760 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 8761 "0452 PCI device Power Management resume.\n"); 8762 8763 /* Restore device state from PCI config space */ 8764 pci_set_power_state(pdev, PCI_D0); 8765 pci_restore_state(pdev); 8766 8767 /* 8768 * As the new kernel behavior of pci_restore_state() API call clears 8769 * device saved_state flag, need to save the restored state again. 8770 */ 8771 pci_save_state(pdev); 8772 8773 if (pdev->is_busmaster) 8774 pci_set_master(pdev); 8775 8776 /* Startup the kernel thread for this host adapter. */ 8777 phba->worker_thread = kthread_run(lpfc_do_work, phba, 8778 "lpfc_worker_%d", phba->brd_no); 8779 if (IS_ERR(phba->worker_thread)) { 8780 error = PTR_ERR(phba->worker_thread); 8781 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8782 "0434 PM resume failed to start worker " 8783 "thread: error=x%x.\n", error); 8784 return error; 8785 } 8786 8787 /* Configure and enable interrupt */ 8788 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode); 8789 if (intr_mode == LPFC_INTR_ERROR) { 8790 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8791 "0430 PM resume Failed to enable interrupt\n"); 8792 return -EIO; 8793 } else 8794 phba->intr_mode = intr_mode; 8795 8796 /* Restart HBA and bring it online */ 8797 lpfc_sli_brdrestart(phba); 8798 lpfc_online(phba); 8799 8800 /* Log the current active interrupt mode */ 8801 lpfc_log_intr_mode(phba, phba->intr_mode); 8802 8803 return 0; 8804 } 8805 8806 /** 8807 * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover 8808 * @phba: pointer to lpfc hba data structure. 8809 * 8810 * This routine is called to prepare the SLI3 device for PCI slot recover. It 8811 * aborts all the outstanding SCSI I/Os to the pci device. 8812 **/ 8813 static void 8814 lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba) 8815 { 8816 struct lpfc_sli *psli = &phba->sli; 8817 struct lpfc_sli_ring *pring; 8818 8819 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8820 "2723 PCI channel I/O abort preparing for recovery\n"); 8821 8822 /* 8823 * There may be errored I/Os through HBA, abort all I/Os on txcmplq 8824 * and let the SCSI mid-layer to retry them to recover. 8825 */ 8826 pring = &psli->ring[psli->fcp_ring]; 8827 lpfc_sli_abort_iocb_ring(phba, pring); 8828 } 8829 8830 /** 8831 * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset 8832 * @phba: pointer to lpfc hba data structure. 8833 * 8834 * This routine is called to prepare the SLI3 device for PCI slot reset. It 8835 * disables the device interrupt and pci device, and aborts the internal FCP 8836 * pending I/Os. 8837 **/ 8838 static void 8839 lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba) 8840 { 8841 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8842 "2710 PCI channel disable preparing for reset\n"); 8843 8844 /* Block any management I/Os to the device */ 8845 lpfc_block_mgmt_io(phba); 8846 8847 /* Block all SCSI devices' I/Os on the host */ 8848 lpfc_scsi_dev_block(phba); 8849 8850 /* stop all timers */ 8851 lpfc_stop_hba_timers(phba); 8852 8853 /* Disable interrupt and pci device */ 8854 lpfc_sli_disable_intr(phba); 8855 pci_disable_device(phba->pcidev); 8856 8857 /* Flush all driver's outstanding SCSI I/Os as we are to reset */ 8858 lpfc_sli_flush_fcp_rings(phba); 8859 } 8860 8861 /** 8862 * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable 8863 * @phba: pointer to lpfc hba data structure. 8864 * 8865 * This routine is called to prepare the SLI3 device for PCI slot permanently 8866 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP 8867 * pending I/Os. 8868 **/ 8869 static void 8870 lpfc_sli_prep_dev_for_perm_failure(struct lpfc_hba *phba) 8871 { 8872 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8873 "2711 PCI channel permanent disable for failure\n"); 8874 /* Block all SCSI devices' I/Os on the host */ 8875 lpfc_scsi_dev_block(phba); 8876 8877 /* stop all timers */ 8878 lpfc_stop_hba_timers(phba); 8879 8880 /* Clean up all driver's outstanding SCSI I/Os */ 8881 lpfc_sli_flush_fcp_rings(phba); 8882 } 8883 8884 /** 8885 * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error 8886 * @pdev: pointer to PCI device. 8887 * @state: the current PCI connection state. 8888 * 8889 * This routine is called from the PCI subsystem for I/O error handling to 8890 * device with SLI-3 interface spec. This function is called by the PCI 8891 * subsystem after a PCI bus error affecting this device has been detected. 8892 * When this function is invoked, it will need to stop all the I/Os and 8893 * interrupt(s) to the device. Once that is done, it will return 8894 * PCI_ERS_RESULT_NEED_RESET for the PCI subsystem to perform proper recovery 8895 * as desired. 8896 * 8897 * Return codes 8898 * PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link 8899 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery 8900 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 8901 **/ 8902 static pci_ers_result_t 8903 lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state) 8904 { 8905 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8906 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 8907 8908 switch (state) { 8909 case pci_channel_io_normal: 8910 /* Non-fatal error, prepare for recovery */ 8911 lpfc_sli_prep_dev_for_recover(phba); 8912 return PCI_ERS_RESULT_CAN_RECOVER; 8913 case pci_channel_io_frozen: 8914 /* Fatal error, prepare for slot reset */ 8915 lpfc_sli_prep_dev_for_reset(phba); 8916 return PCI_ERS_RESULT_NEED_RESET; 8917 case pci_channel_io_perm_failure: 8918 /* Permanent failure, prepare for device down */ 8919 lpfc_sli_prep_dev_for_perm_failure(phba); 8920 return PCI_ERS_RESULT_DISCONNECT; 8921 default: 8922 /* Unknown state, prepare and request slot reset */ 8923 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8924 "0472 Unknown PCI error state: x%x\n", state); 8925 lpfc_sli_prep_dev_for_reset(phba); 8926 return PCI_ERS_RESULT_NEED_RESET; 8927 } 8928 } 8929 8930 /** 8931 * lpfc_io_slot_reset_s3 - Method for restarting PCI SLI-3 device from scratch. 8932 * @pdev: pointer to PCI device. 8933 * 8934 * This routine is called from the PCI subsystem for error handling to 8935 * device with SLI-3 interface spec. This is called after PCI bus has been 8936 * reset to restart the PCI card from scratch, as if from a cold-boot. 8937 * During the PCI subsystem error recovery, after driver returns 8938 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error 8939 * recovery and then call this routine before calling the .resume method 8940 * to recover the device. This function will initialize the HBA device, 8941 * enable the interrupt, but it will just put the HBA to offline state 8942 * without passing any I/O traffic. 8943 * 8944 * Return codes 8945 * PCI_ERS_RESULT_RECOVERED - the device has been recovered 8946 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 8947 */ 8948 static pci_ers_result_t 8949 lpfc_io_slot_reset_s3(struct pci_dev *pdev) 8950 { 8951 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8952 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 8953 struct lpfc_sli *psli = &phba->sli; 8954 uint32_t intr_mode; 8955 8956 dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n"); 8957 if (pci_enable_device_mem(pdev)) { 8958 printk(KERN_ERR "lpfc: Cannot re-enable " 8959 "PCI device after reset.\n"); 8960 return PCI_ERS_RESULT_DISCONNECT; 8961 } 8962 8963 pci_restore_state(pdev); 8964 8965 /* 8966 * As the new kernel behavior of pci_restore_state() API call clears 8967 * device saved_state flag, need to save the restored state again. 8968 */ 8969 pci_save_state(pdev); 8970 8971 if (pdev->is_busmaster) 8972 pci_set_master(pdev); 8973 8974 spin_lock_irq(&phba->hbalock); 8975 psli->sli_flag &= ~LPFC_SLI_ACTIVE; 8976 spin_unlock_irq(&phba->hbalock); 8977 8978 /* Configure and enable interrupt */ 8979 intr_mode = lpfc_sli_enable_intr(phba, phba->intr_mode); 8980 if (intr_mode == LPFC_INTR_ERROR) { 8981 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 8982 "0427 Cannot re-enable interrupt after " 8983 "slot reset.\n"); 8984 return PCI_ERS_RESULT_DISCONNECT; 8985 } else 8986 phba->intr_mode = intr_mode; 8987 8988 /* Take device offline, it will perform cleanup */ 8989 lpfc_offline_prep(phba); 8990 lpfc_offline(phba); 8991 lpfc_sli_brdrestart(phba); 8992 8993 /* Log the current active interrupt mode */ 8994 lpfc_log_intr_mode(phba, phba->intr_mode); 8995 8996 return PCI_ERS_RESULT_RECOVERED; 8997 } 8998 8999 /** 9000 * lpfc_io_resume_s3 - Method for resuming PCI I/O operation on SLI-3 device. 9001 * @pdev: pointer to PCI device 9002 * 9003 * This routine is called from the PCI subsystem for error handling to device 9004 * with SLI-3 interface spec. It is called when kernel error recovery tells 9005 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus 9006 * error recovery. After this call, traffic can start to flow from this device 9007 * again. 9008 */ 9009 static void 9010 lpfc_io_resume_s3(struct pci_dev *pdev) 9011 { 9012 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9013 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9014 9015 /* Bring device online, it will be no-op for non-fatal error resume */ 9016 lpfc_online(phba); 9017 9018 /* Clean up Advanced Error Reporting (AER) if needed */ 9019 if (phba->hba_flag & HBA_AER_ENABLED) 9020 pci_cleanup_aer_uncorrect_error_status(pdev); 9021 } 9022 9023 /** 9024 * lpfc_sli4_get_els_iocb_cnt - Calculate the # of ELS IOCBs to reserve 9025 * @phba: pointer to lpfc hba data structure. 9026 * 9027 * returns the number of ELS/CT IOCBs to reserve 9028 **/ 9029 int 9030 lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba) 9031 { 9032 int max_xri = phba->sli4_hba.max_cfg_param.max_xri; 9033 9034 if (phba->sli_rev == LPFC_SLI_REV4) { 9035 if (max_xri <= 100) 9036 return 10; 9037 else if (max_xri <= 256) 9038 return 25; 9039 else if (max_xri <= 512) 9040 return 50; 9041 else if (max_xri <= 1024) 9042 return 100; 9043 else 9044 return 150; 9045 } else 9046 return 0; 9047 } 9048 9049 /** 9050 * lpfc_write_firmware - attempt to write a firmware image to the port 9051 * @phba: pointer to lpfc hba data structure. 9052 * @fw: pointer to firmware image returned from request_firmware. 9053 * 9054 * returns the number of bytes written if write is successful. 9055 * returns a negative error value if there were errors. 9056 * returns 0 if firmware matches currently active firmware on port. 9057 **/ 9058 int 9059 lpfc_write_firmware(struct lpfc_hba *phba, const struct firmware *fw) 9060 { 9061 char fwrev[32]; 9062 struct lpfc_grp_hdr *image = (struct lpfc_grp_hdr *)fw->data; 9063 struct list_head dma_buffer_list; 9064 int i, rc = 0; 9065 struct lpfc_dmabuf *dmabuf, *next; 9066 uint32_t offset = 0, temp_offset = 0; 9067 9068 INIT_LIST_HEAD(&dma_buffer_list); 9069 if ((be32_to_cpu(image->magic_number) != LPFC_GROUP_OJECT_MAGIC_NUM) || 9070 (bf_get_be32(lpfc_grp_hdr_file_type, image) != 9071 LPFC_FILE_TYPE_GROUP) || 9072 (bf_get_be32(lpfc_grp_hdr_id, image) != LPFC_FILE_ID_GROUP) || 9073 (be32_to_cpu(image->size) != fw->size)) { 9074 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9075 "3022 Invalid FW image found. " 9076 "Magic:%x Type:%x ID:%x\n", 9077 be32_to_cpu(image->magic_number), 9078 bf_get_be32(lpfc_grp_hdr_file_type, image), 9079 bf_get_be32(lpfc_grp_hdr_id, image)); 9080 return -EINVAL; 9081 } 9082 lpfc_decode_firmware_rev(phba, fwrev, 1); 9083 if (strncmp(fwrev, image->revision, strnlen(image->revision, 16))) { 9084 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9085 "3023 Updating Firmware. Current Version:%s " 9086 "New Version:%s\n", 9087 fwrev, image->revision); 9088 for (i = 0; i < LPFC_MBX_WR_CONFIG_MAX_BDE; i++) { 9089 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), 9090 GFP_KERNEL); 9091 if (!dmabuf) { 9092 rc = -ENOMEM; 9093 goto out; 9094 } 9095 dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, 9096 SLI4_PAGE_SIZE, 9097 &dmabuf->phys, 9098 GFP_KERNEL); 9099 if (!dmabuf->virt) { 9100 kfree(dmabuf); 9101 rc = -ENOMEM; 9102 goto out; 9103 } 9104 list_add_tail(&dmabuf->list, &dma_buffer_list); 9105 } 9106 while (offset < fw->size) { 9107 temp_offset = offset; 9108 list_for_each_entry(dmabuf, &dma_buffer_list, list) { 9109 if (temp_offset + SLI4_PAGE_SIZE > fw->size) { 9110 memcpy(dmabuf->virt, 9111 fw->data + temp_offset, 9112 fw->size - temp_offset); 9113 temp_offset = fw->size; 9114 break; 9115 } 9116 memcpy(dmabuf->virt, fw->data + temp_offset, 9117 SLI4_PAGE_SIZE); 9118 temp_offset += SLI4_PAGE_SIZE; 9119 } 9120 rc = lpfc_wr_object(phba, &dma_buffer_list, 9121 (fw->size - offset), &offset); 9122 if (rc) { 9123 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9124 "3024 Firmware update failed. " 9125 "%d\n", rc); 9126 goto out; 9127 } 9128 } 9129 rc = offset; 9130 } 9131 out: 9132 list_for_each_entry_safe(dmabuf, next, &dma_buffer_list, list) { 9133 list_del(&dmabuf->list); 9134 dma_free_coherent(&phba->pcidev->dev, SLI4_PAGE_SIZE, 9135 dmabuf->virt, dmabuf->phys); 9136 kfree(dmabuf); 9137 } 9138 return rc; 9139 } 9140 9141 /** 9142 * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys 9143 * @pdev: pointer to PCI device 9144 * @pid: pointer to PCI device identifier 9145 * 9146 * This routine is called from the kernel's PCI subsystem to device with 9147 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is 9148 * presented on PCI bus, the kernel PCI subsystem looks at PCI device-specific 9149 * information of the device and driver to see if the driver state that it 9150 * can support this kind of device. If the match is successful, the driver 9151 * core invokes this routine. If this routine determines it can claim the HBA, 9152 * it does all the initialization that it needs to do to handle the HBA 9153 * properly. 9154 * 9155 * Return code 9156 * 0 - driver can claim the device 9157 * negative value - driver can not claim the device 9158 **/ 9159 static int __devinit 9160 lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid) 9161 { 9162 struct lpfc_hba *phba; 9163 struct lpfc_vport *vport = NULL; 9164 struct Scsi_Host *shost = NULL; 9165 int error; 9166 uint32_t cfg_mode, intr_mode; 9167 int mcnt; 9168 int adjusted_fcp_eq_count; 9169 const struct firmware *fw; 9170 uint8_t file_name[16]; 9171 9172 /* Allocate memory for HBA structure */ 9173 phba = lpfc_hba_alloc(pdev); 9174 if (!phba) 9175 return -ENOMEM; 9176 9177 /* Perform generic PCI device enabling operation */ 9178 error = lpfc_enable_pci_dev(phba); 9179 if (error) 9180 goto out_free_phba; 9181 9182 /* Set up SLI API function jump table for PCI-device group-1 HBAs */ 9183 error = lpfc_api_table_setup(phba, LPFC_PCI_DEV_OC); 9184 if (error) 9185 goto out_disable_pci_dev; 9186 9187 /* Set up SLI-4 specific device PCI memory space */ 9188 error = lpfc_sli4_pci_mem_setup(phba); 9189 if (error) { 9190 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9191 "1410 Failed to set up pci memory space.\n"); 9192 goto out_disable_pci_dev; 9193 } 9194 9195 /* Set up phase-1 common device driver resources */ 9196 error = lpfc_setup_driver_resource_phase1(phba); 9197 if (error) { 9198 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9199 "1411 Failed to set up driver resource.\n"); 9200 goto out_unset_pci_mem_s4; 9201 } 9202 9203 /* Set up SLI-4 Specific device driver resources */ 9204 error = lpfc_sli4_driver_resource_setup(phba); 9205 if (error) { 9206 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9207 "1412 Failed to set up driver resource.\n"); 9208 goto out_unset_pci_mem_s4; 9209 } 9210 9211 /* Initialize and populate the iocb list per host */ 9212 9213 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 9214 "2821 initialize iocb list %d.\n", 9215 phba->cfg_iocb_cnt*1024); 9216 error = lpfc_init_iocb_list(phba, phba->cfg_iocb_cnt*1024); 9217 9218 if (error) { 9219 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9220 "1413 Failed to initialize iocb list.\n"); 9221 goto out_unset_driver_resource_s4; 9222 } 9223 9224 INIT_LIST_HEAD(&phba->active_rrq_list); 9225 INIT_LIST_HEAD(&phba->fcf.fcf_pri_list); 9226 9227 /* Set up common device driver resources */ 9228 error = lpfc_setup_driver_resource_phase2(phba); 9229 if (error) { 9230 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9231 "1414 Failed to set up driver resource.\n"); 9232 goto out_free_iocb_list; 9233 } 9234 9235 /* Get the default values for Model Name and Description */ 9236 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc); 9237 9238 /* Create SCSI host to the physical port */ 9239 error = lpfc_create_shost(phba); 9240 if (error) { 9241 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9242 "1415 Failed to create scsi host.\n"); 9243 goto out_unset_driver_resource; 9244 } 9245 9246 /* Configure sysfs attributes */ 9247 vport = phba->pport; 9248 error = lpfc_alloc_sysfs_attr(vport); 9249 if (error) { 9250 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9251 "1416 Failed to allocate sysfs attr\n"); 9252 goto out_destroy_shost; 9253 } 9254 9255 shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */ 9256 /* Now, trying to enable interrupt and bring up the device */ 9257 cfg_mode = phba->cfg_use_msi; 9258 while (true) { 9259 /* Put device to a known state before enabling interrupt */ 9260 lpfc_stop_port(phba); 9261 /* Configure and enable interrupt */ 9262 intr_mode = lpfc_sli4_enable_intr(phba, cfg_mode); 9263 if (intr_mode == LPFC_INTR_ERROR) { 9264 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9265 "0426 Failed to enable interrupt.\n"); 9266 error = -ENODEV; 9267 goto out_free_sysfs_attr; 9268 } 9269 /* Default to single EQ for non-MSI-X */ 9270 if (phba->intr_type != MSIX) 9271 adjusted_fcp_eq_count = 0; 9272 else if (phba->sli4_hba.msix_vec_nr < 9273 phba->cfg_fcp_eq_count + 1) 9274 adjusted_fcp_eq_count = phba->sli4_hba.msix_vec_nr - 1; 9275 else 9276 adjusted_fcp_eq_count = phba->cfg_fcp_eq_count; 9277 phba->cfg_fcp_eq_count = adjusted_fcp_eq_count; 9278 /* Set up SLI-4 HBA */ 9279 if (lpfc_sli4_hba_setup(phba)) { 9280 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9281 "1421 Failed to set up hba\n"); 9282 error = -ENODEV; 9283 goto out_disable_intr; 9284 } 9285 9286 /* Send NOP mbx cmds for non-INTx mode active interrupt test */ 9287 if (intr_mode != 0) 9288 mcnt = lpfc_sli4_send_nop_mbox_cmds(phba, 9289 LPFC_ACT_INTR_CNT); 9290 9291 /* Check active interrupts received only for MSI/MSI-X */ 9292 if (intr_mode == 0 || 9293 phba->sli.slistat.sli_intr >= LPFC_ACT_INTR_CNT) { 9294 /* Log the current active interrupt mode */ 9295 phba->intr_mode = intr_mode; 9296 lpfc_log_intr_mode(phba, intr_mode); 9297 break; 9298 } 9299 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 9300 "0451 Configure interrupt mode (%d) " 9301 "failed active interrupt test.\n", 9302 intr_mode); 9303 /* Unset the previous SLI-4 HBA setup. */ 9304 /* 9305 * TODO: Is this operation compatible with IF TYPE 2 9306 * devices? All port state is deleted and cleared. 9307 */ 9308 lpfc_sli4_unset_hba(phba); 9309 /* Try next level of interrupt mode */ 9310 cfg_mode = --intr_mode; 9311 } 9312 9313 /* Perform post initialization setup */ 9314 lpfc_post_init_setup(phba); 9315 9316 /* check for firmware upgrade or downgrade (if_type 2 only) */ 9317 if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) == 9318 LPFC_SLI_INTF_IF_TYPE_2) { 9319 snprintf(file_name, 16, "%s.grp", phba->ModelName); 9320 error = request_firmware(&fw, file_name, &phba->pcidev->dev); 9321 if (!error) { 9322 lpfc_write_firmware(phba, fw); 9323 release_firmware(fw); 9324 } 9325 } 9326 9327 /* Check if there are static vports to be created. */ 9328 lpfc_create_static_vport(phba); 9329 return 0; 9330 9331 out_disable_intr: 9332 lpfc_sli4_disable_intr(phba); 9333 out_free_sysfs_attr: 9334 lpfc_free_sysfs_attr(vport); 9335 out_destroy_shost: 9336 lpfc_destroy_shost(phba); 9337 out_unset_driver_resource: 9338 lpfc_unset_driver_resource_phase2(phba); 9339 out_free_iocb_list: 9340 lpfc_free_iocb_list(phba); 9341 out_unset_driver_resource_s4: 9342 lpfc_sli4_driver_resource_unset(phba); 9343 out_unset_pci_mem_s4: 9344 lpfc_sli4_pci_mem_unset(phba); 9345 out_disable_pci_dev: 9346 lpfc_disable_pci_dev(phba); 9347 if (shost) 9348 scsi_host_put(shost); 9349 out_free_phba: 9350 lpfc_hba_free(phba); 9351 return error; 9352 } 9353 9354 /** 9355 * lpfc_pci_remove_one_s4 - PCI func to unreg SLI-4 device from PCI subsystem 9356 * @pdev: pointer to PCI device 9357 * 9358 * This routine is called from the kernel's PCI subsystem to device with 9359 * SLI-4 interface spec. When an Emulex HBA with SLI-4 interface spec is 9360 * removed from PCI bus, it performs all the necessary cleanup for the HBA 9361 * device to be removed from the PCI subsystem properly. 9362 **/ 9363 static void __devexit 9364 lpfc_pci_remove_one_s4(struct pci_dev *pdev) 9365 { 9366 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9367 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; 9368 struct lpfc_vport **vports; 9369 struct lpfc_hba *phba = vport->phba; 9370 int i; 9371 9372 /* Mark the device unloading flag */ 9373 spin_lock_irq(&phba->hbalock); 9374 vport->load_flag |= FC_UNLOADING; 9375 spin_unlock_irq(&phba->hbalock); 9376 9377 /* Free the HBA sysfs attributes */ 9378 lpfc_free_sysfs_attr(vport); 9379 9380 /* Release all the vports against this physical port */ 9381 vports = lpfc_create_vport_work_array(phba); 9382 if (vports != NULL) 9383 for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++) 9384 fc_vport_terminate(vports[i]->fc_vport); 9385 lpfc_destroy_vport_work_array(phba, vports); 9386 9387 /* Remove FC host and then SCSI host with the physical port */ 9388 fc_remove_host(shost); 9389 scsi_remove_host(shost); 9390 9391 /* Perform cleanup on the physical port */ 9392 lpfc_cleanup(vport); 9393 9394 /* 9395 * Bring down the SLI Layer. This step disables all interrupts, 9396 * clears the rings, discards all mailbox commands, and resets 9397 * the HBA FCoE function. 9398 */ 9399 lpfc_debugfs_terminate(vport); 9400 lpfc_sli4_hba_unset(phba); 9401 9402 spin_lock_irq(&phba->hbalock); 9403 list_del_init(&vport->listentry); 9404 spin_unlock_irq(&phba->hbalock); 9405 9406 /* Perform scsi free before driver resource_unset since scsi 9407 * buffers are released to their corresponding pools here. 9408 */ 9409 lpfc_scsi_free(phba); 9410 lpfc_sli4_driver_resource_unset(phba); 9411 9412 /* Unmap adapter Control and Doorbell registers */ 9413 lpfc_sli4_pci_mem_unset(phba); 9414 9415 /* Release PCI resources and disable device's PCI function */ 9416 scsi_host_put(shost); 9417 lpfc_disable_pci_dev(phba); 9418 9419 /* Finally, free the driver's device data structure */ 9420 lpfc_hba_free(phba); 9421 9422 return; 9423 } 9424 9425 /** 9426 * lpfc_pci_suspend_one_s4 - PCI func to suspend SLI-4 device for power mgmnt 9427 * @pdev: pointer to PCI device 9428 * @msg: power management message 9429 * 9430 * This routine is called from the kernel's PCI subsystem to support system 9431 * Power Management (PM) to device with SLI-4 interface spec. When PM invokes 9432 * this method, it quiesces the device by stopping the driver's worker 9433 * thread for the device, turning off device's interrupt and DMA, and bring 9434 * the device offline. Note that as the driver implements the minimum PM 9435 * requirements to a power-aware driver's PM support for suspend/resume -- all 9436 * the possible PM messages (SUSPEND, HIBERNATE, FREEZE) to the suspend() 9437 * method call will be treated as SUSPEND and the driver will fully 9438 * reinitialize its device during resume() method call, the driver will set 9439 * device to PCI_D3hot state in PCI config space instead of setting it 9440 * according to the @msg provided by the PM. 9441 * 9442 * Return code 9443 * 0 - driver suspended the device 9444 * Error otherwise 9445 **/ 9446 static int 9447 lpfc_pci_suspend_one_s4(struct pci_dev *pdev, pm_message_t msg) 9448 { 9449 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9450 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9451 9452 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 9453 "2843 PCI device Power Management suspend.\n"); 9454 9455 /* Bring down the device */ 9456 lpfc_offline_prep(phba); 9457 lpfc_offline(phba); 9458 kthread_stop(phba->worker_thread); 9459 9460 /* Disable interrupt from device */ 9461 lpfc_sli4_disable_intr(phba); 9462 lpfc_sli4_queue_destroy(phba); 9463 9464 /* Save device state to PCI config space */ 9465 pci_save_state(pdev); 9466 pci_set_power_state(pdev, PCI_D3hot); 9467 9468 return 0; 9469 } 9470 9471 /** 9472 * lpfc_pci_resume_one_s4 - PCI func to resume SLI-4 device for power mgmnt 9473 * @pdev: pointer to PCI device 9474 * 9475 * This routine is called from the kernel's PCI subsystem to support system 9476 * Power Management (PM) to device with SLI-4 interface spac. When PM invokes 9477 * this method, it restores the device's PCI config space state and fully 9478 * reinitializes the device and brings it online. Note that as the driver 9479 * implements the minimum PM requirements to a power-aware driver's PM for 9480 * suspend/resume -- all the possible PM messages (SUSPEND, HIBERNATE, FREEZE) 9481 * to the suspend() method call will be treated as SUSPEND and the driver 9482 * will fully reinitialize its device during resume() method call, the device 9483 * will be set to PCI_D0 directly in PCI config space before restoring the 9484 * state. 9485 * 9486 * Return code 9487 * 0 - driver suspended the device 9488 * Error otherwise 9489 **/ 9490 static int 9491 lpfc_pci_resume_one_s4(struct pci_dev *pdev) 9492 { 9493 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9494 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9495 uint32_t intr_mode; 9496 int error; 9497 9498 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, 9499 "0292 PCI device Power Management resume.\n"); 9500 9501 /* Restore device state from PCI config space */ 9502 pci_set_power_state(pdev, PCI_D0); 9503 pci_restore_state(pdev); 9504 9505 /* 9506 * As the new kernel behavior of pci_restore_state() API call clears 9507 * device saved_state flag, need to save the restored state again. 9508 */ 9509 pci_save_state(pdev); 9510 9511 if (pdev->is_busmaster) 9512 pci_set_master(pdev); 9513 9514 /* Startup the kernel thread for this host adapter. */ 9515 phba->worker_thread = kthread_run(lpfc_do_work, phba, 9516 "lpfc_worker_%d", phba->brd_no); 9517 if (IS_ERR(phba->worker_thread)) { 9518 error = PTR_ERR(phba->worker_thread); 9519 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9520 "0293 PM resume failed to start worker " 9521 "thread: error=x%x.\n", error); 9522 return error; 9523 } 9524 9525 /* Configure and enable interrupt */ 9526 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode); 9527 if (intr_mode == LPFC_INTR_ERROR) { 9528 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9529 "0294 PM resume Failed to enable interrupt\n"); 9530 return -EIO; 9531 } else 9532 phba->intr_mode = intr_mode; 9533 9534 /* Restart HBA and bring it online */ 9535 lpfc_sli_brdrestart(phba); 9536 lpfc_online(phba); 9537 9538 /* Log the current active interrupt mode */ 9539 lpfc_log_intr_mode(phba, phba->intr_mode); 9540 9541 return 0; 9542 } 9543 9544 /** 9545 * lpfc_sli4_prep_dev_for_recover - Prepare SLI4 device for pci slot recover 9546 * @phba: pointer to lpfc hba data structure. 9547 * 9548 * This routine is called to prepare the SLI4 device for PCI slot recover. It 9549 * aborts all the outstanding SCSI I/Os to the pci device. 9550 **/ 9551 static void 9552 lpfc_sli4_prep_dev_for_recover(struct lpfc_hba *phba) 9553 { 9554 struct lpfc_sli *psli = &phba->sli; 9555 struct lpfc_sli_ring *pring; 9556 9557 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9558 "2828 PCI channel I/O abort preparing for recovery\n"); 9559 /* 9560 * There may be errored I/Os through HBA, abort all I/Os on txcmplq 9561 * and let the SCSI mid-layer to retry them to recover. 9562 */ 9563 pring = &psli->ring[psli->fcp_ring]; 9564 lpfc_sli_abort_iocb_ring(phba, pring); 9565 } 9566 9567 /** 9568 * lpfc_sli4_prep_dev_for_reset - Prepare SLI4 device for pci slot reset 9569 * @phba: pointer to lpfc hba data structure. 9570 * 9571 * This routine is called to prepare the SLI4 device for PCI slot reset. It 9572 * disables the device interrupt and pci device, and aborts the internal FCP 9573 * pending I/Os. 9574 **/ 9575 static void 9576 lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba) 9577 { 9578 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9579 "2826 PCI channel disable preparing for reset\n"); 9580 9581 /* Block any management I/Os to the device */ 9582 lpfc_block_mgmt_io(phba); 9583 9584 /* Block all SCSI devices' I/Os on the host */ 9585 lpfc_scsi_dev_block(phba); 9586 9587 /* stop all timers */ 9588 lpfc_stop_hba_timers(phba); 9589 9590 /* Disable interrupt and pci device */ 9591 lpfc_sli4_disable_intr(phba); 9592 lpfc_sli4_queue_destroy(phba); 9593 pci_disable_device(phba->pcidev); 9594 9595 /* Flush all driver's outstanding SCSI I/Os as we are to reset */ 9596 lpfc_sli_flush_fcp_rings(phba); 9597 } 9598 9599 /** 9600 * lpfc_sli4_prep_dev_for_perm_failure - Prepare SLI4 dev for pci slot disable 9601 * @phba: pointer to lpfc hba data structure. 9602 * 9603 * This routine is called to prepare the SLI4 device for PCI slot permanently 9604 * disabling. It blocks the SCSI transport layer traffic and flushes the FCP 9605 * pending I/Os. 9606 **/ 9607 static void 9608 lpfc_sli4_prep_dev_for_perm_failure(struct lpfc_hba *phba) 9609 { 9610 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9611 "2827 PCI channel permanent disable for failure\n"); 9612 9613 /* Block all SCSI devices' I/Os on the host */ 9614 lpfc_scsi_dev_block(phba); 9615 9616 /* stop all timers */ 9617 lpfc_stop_hba_timers(phba); 9618 9619 /* Clean up all driver's outstanding SCSI I/Os */ 9620 lpfc_sli_flush_fcp_rings(phba); 9621 } 9622 9623 /** 9624 * lpfc_io_error_detected_s4 - Method for handling PCI I/O error to SLI-4 device 9625 * @pdev: pointer to PCI device. 9626 * @state: the current PCI connection state. 9627 * 9628 * This routine is called from the PCI subsystem for error handling to device 9629 * with SLI-4 interface spec. This function is called by the PCI subsystem 9630 * after a PCI bus error affecting this device has been detected. When this 9631 * function is invoked, it will need to stop all the I/Os and interrupt(s) 9632 * to the device. Once that is done, it will return PCI_ERS_RESULT_NEED_RESET 9633 * for the PCI subsystem to perform proper recovery as desired. 9634 * 9635 * Return codes 9636 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery 9637 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 9638 **/ 9639 static pci_ers_result_t 9640 lpfc_io_error_detected_s4(struct pci_dev *pdev, pci_channel_state_t state) 9641 { 9642 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9643 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9644 9645 switch (state) { 9646 case pci_channel_io_normal: 9647 /* Non-fatal error, prepare for recovery */ 9648 lpfc_sli4_prep_dev_for_recover(phba); 9649 return PCI_ERS_RESULT_CAN_RECOVER; 9650 case pci_channel_io_frozen: 9651 /* Fatal error, prepare for slot reset */ 9652 lpfc_sli4_prep_dev_for_reset(phba); 9653 return PCI_ERS_RESULT_NEED_RESET; 9654 case pci_channel_io_perm_failure: 9655 /* Permanent failure, prepare for device down */ 9656 lpfc_sli4_prep_dev_for_perm_failure(phba); 9657 return PCI_ERS_RESULT_DISCONNECT; 9658 default: 9659 /* Unknown state, prepare and request slot reset */ 9660 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9661 "2825 Unknown PCI error state: x%x\n", state); 9662 lpfc_sli4_prep_dev_for_reset(phba); 9663 return PCI_ERS_RESULT_NEED_RESET; 9664 } 9665 } 9666 9667 /** 9668 * lpfc_io_slot_reset_s4 - Method for restart PCI SLI-4 device from scratch 9669 * @pdev: pointer to PCI device. 9670 * 9671 * This routine is called from the PCI subsystem for error handling to device 9672 * with SLI-4 interface spec. It is called after PCI bus has been reset to 9673 * restart the PCI card from scratch, as if from a cold-boot. During the 9674 * PCI subsystem error recovery, after the driver returns 9675 * PCI_ERS_RESULT_NEED_RESET, the PCI subsystem will perform proper error 9676 * recovery and then call this routine before calling the .resume method to 9677 * recover the device. This function will initialize the HBA device, enable 9678 * the interrupt, but it will just put the HBA to offline state without 9679 * passing any I/O traffic. 9680 * 9681 * Return codes 9682 * PCI_ERS_RESULT_RECOVERED - the device has been recovered 9683 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 9684 */ 9685 static pci_ers_result_t 9686 lpfc_io_slot_reset_s4(struct pci_dev *pdev) 9687 { 9688 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9689 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9690 struct lpfc_sli *psli = &phba->sli; 9691 uint32_t intr_mode; 9692 9693 dev_printk(KERN_INFO, &pdev->dev, "recovering from a slot reset.\n"); 9694 if (pci_enable_device_mem(pdev)) { 9695 printk(KERN_ERR "lpfc: Cannot re-enable " 9696 "PCI device after reset.\n"); 9697 return PCI_ERS_RESULT_DISCONNECT; 9698 } 9699 9700 pci_restore_state(pdev); 9701 9702 /* 9703 * As the new kernel behavior of pci_restore_state() API call clears 9704 * device saved_state flag, need to save the restored state again. 9705 */ 9706 pci_save_state(pdev); 9707 9708 if (pdev->is_busmaster) 9709 pci_set_master(pdev); 9710 9711 spin_lock_irq(&phba->hbalock); 9712 psli->sli_flag &= ~LPFC_SLI_ACTIVE; 9713 spin_unlock_irq(&phba->hbalock); 9714 9715 /* Configure and enable interrupt */ 9716 intr_mode = lpfc_sli4_enable_intr(phba, phba->intr_mode); 9717 if (intr_mode == LPFC_INTR_ERROR) { 9718 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9719 "2824 Cannot re-enable interrupt after " 9720 "slot reset.\n"); 9721 return PCI_ERS_RESULT_DISCONNECT; 9722 } else 9723 phba->intr_mode = intr_mode; 9724 9725 /* Log the current active interrupt mode */ 9726 lpfc_log_intr_mode(phba, phba->intr_mode); 9727 9728 return PCI_ERS_RESULT_RECOVERED; 9729 } 9730 9731 /** 9732 * lpfc_io_resume_s4 - Method for resuming PCI I/O operation to SLI-4 device 9733 * @pdev: pointer to PCI device 9734 * 9735 * This routine is called from the PCI subsystem for error handling to device 9736 * with SLI-4 interface spec. It is called when kernel error recovery tells 9737 * the lpfc driver that it is ok to resume normal PCI operation after PCI bus 9738 * error recovery. After this call, traffic can start to flow from this device 9739 * again. 9740 **/ 9741 static void 9742 lpfc_io_resume_s4(struct pci_dev *pdev) 9743 { 9744 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9745 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9746 9747 /* 9748 * In case of slot reset, as function reset is performed through 9749 * mailbox command which needs DMA to be enabled, this operation 9750 * has to be moved to the io resume phase. Taking device offline 9751 * will perform the necessary cleanup. 9752 */ 9753 if (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)) { 9754 /* Perform device reset */ 9755 lpfc_offline_prep(phba); 9756 lpfc_offline(phba); 9757 lpfc_sli_brdrestart(phba); 9758 /* Bring the device back online */ 9759 lpfc_online(phba); 9760 } 9761 9762 /* Clean up Advanced Error Reporting (AER) if needed */ 9763 if (phba->hba_flag & HBA_AER_ENABLED) 9764 pci_cleanup_aer_uncorrect_error_status(pdev); 9765 } 9766 9767 /** 9768 * lpfc_pci_probe_one - lpfc PCI probe func to reg dev to PCI subsystem 9769 * @pdev: pointer to PCI device 9770 * @pid: pointer to PCI device identifier 9771 * 9772 * This routine is to be registered to the kernel's PCI subsystem. When an 9773 * Emulex HBA device is presented on PCI bus, the kernel PCI subsystem looks 9774 * at PCI device-specific information of the device and driver to see if the 9775 * driver state that it can support this kind of device. If the match is 9776 * successful, the driver core invokes this routine. This routine dispatches 9777 * the action to the proper SLI-3 or SLI-4 device probing routine, which will 9778 * do all the initialization that it needs to do to handle the HBA device 9779 * properly. 9780 * 9781 * Return code 9782 * 0 - driver can claim the device 9783 * negative value - driver can not claim the device 9784 **/ 9785 static int __devinit 9786 lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid) 9787 { 9788 int rc; 9789 struct lpfc_sli_intf intf; 9790 9791 if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0)) 9792 return -ENODEV; 9793 9794 if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) && 9795 (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4)) 9796 rc = lpfc_pci_probe_one_s4(pdev, pid); 9797 else 9798 rc = lpfc_pci_probe_one_s3(pdev, pid); 9799 9800 return rc; 9801 } 9802 9803 /** 9804 * lpfc_pci_remove_one - lpfc PCI func to unreg dev from PCI subsystem 9805 * @pdev: pointer to PCI device 9806 * 9807 * This routine is to be registered to the kernel's PCI subsystem. When an 9808 * Emulex HBA is removed from PCI bus, the driver core invokes this routine. 9809 * This routine dispatches the action to the proper SLI-3 or SLI-4 device 9810 * remove routine, which will perform all the necessary cleanup for the 9811 * device to be removed from the PCI subsystem properly. 9812 **/ 9813 static void __devexit 9814 lpfc_pci_remove_one(struct pci_dev *pdev) 9815 { 9816 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9817 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9818 9819 switch (phba->pci_dev_grp) { 9820 case LPFC_PCI_DEV_LP: 9821 lpfc_pci_remove_one_s3(pdev); 9822 break; 9823 case LPFC_PCI_DEV_OC: 9824 lpfc_pci_remove_one_s4(pdev); 9825 break; 9826 default: 9827 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9828 "1424 Invalid PCI device group: 0x%x\n", 9829 phba->pci_dev_grp); 9830 break; 9831 } 9832 return; 9833 } 9834 9835 /** 9836 * lpfc_pci_suspend_one - lpfc PCI func to suspend dev for power management 9837 * @pdev: pointer to PCI device 9838 * @msg: power management message 9839 * 9840 * This routine is to be registered to the kernel's PCI subsystem to support 9841 * system Power Management (PM). When PM invokes this method, it dispatches 9842 * the action to the proper SLI-3 or SLI-4 device suspend routine, which will 9843 * suspend the device. 9844 * 9845 * Return code 9846 * 0 - driver suspended the device 9847 * Error otherwise 9848 **/ 9849 static int 9850 lpfc_pci_suspend_one(struct pci_dev *pdev, pm_message_t msg) 9851 { 9852 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9853 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9854 int rc = -ENODEV; 9855 9856 switch (phba->pci_dev_grp) { 9857 case LPFC_PCI_DEV_LP: 9858 rc = lpfc_pci_suspend_one_s3(pdev, msg); 9859 break; 9860 case LPFC_PCI_DEV_OC: 9861 rc = lpfc_pci_suspend_one_s4(pdev, msg); 9862 break; 9863 default: 9864 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9865 "1425 Invalid PCI device group: 0x%x\n", 9866 phba->pci_dev_grp); 9867 break; 9868 } 9869 return rc; 9870 } 9871 9872 /** 9873 * lpfc_pci_resume_one - lpfc PCI func to resume dev for power management 9874 * @pdev: pointer to PCI device 9875 * 9876 * This routine is to be registered to the kernel's PCI subsystem to support 9877 * system Power Management (PM). When PM invokes this method, it dispatches 9878 * the action to the proper SLI-3 or SLI-4 device resume routine, which will 9879 * resume the device. 9880 * 9881 * Return code 9882 * 0 - driver suspended the device 9883 * Error otherwise 9884 **/ 9885 static int 9886 lpfc_pci_resume_one(struct pci_dev *pdev) 9887 { 9888 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9889 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9890 int rc = -ENODEV; 9891 9892 switch (phba->pci_dev_grp) { 9893 case LPFC_PCI_DEV_LP: 9894 rc = lpfc_pci_resume_one_s3(pdev); 9895 break; 9896 case LPFC_PCI_DEV_OC: 9897 rc = lpfc_pci_resume_one_s4(pdev); 9898 break; 9899 default: 9900 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9901 "1426 Invalid PCI device group: 0x%x\n", 9902 phba->pci_dev_grp); 9903 break; 9904 } 9905 return rc; 9906 } 9907 9908 /** 9909 * lpfc_io_error_detected - lpfc method for handling PCI I/O error 9910 * @pdev: pointer to PCI device. 9911 * @state: the current PCI connection state. 9912 * 9913 * This routine is registered to the PCI subsystem for error handling. This 9914 * function is called by the PCI subsystem after a PCI bus error affecting 9915 * this device has been detected. When this routine is invoked, it dispatches 9916 * the action to the proper SLI-3 or SLI-4 device error detected handling 9917 * routine, which will perform the proper error detected operation. 9918 * 9919 * Return codes 9920 * PCI_ERS_RESULT_NEED_RESET - need to reset before recovery 9921 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 9922 **/ 9923 static pci_ers_result_t 9924 lpfc_io_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 9925 { 9926 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9927 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9928 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT; 9929 9930 switch (phba->pci_dev_grp) { 9931 case LPFC_PCI_DEV_LP: 9932 rc = lpfc_io_error_detected_s3(pdev, state); 9933 break; 9934 case LPFC_PCI_DEV_OC: 9935 rc = lpfc_io_error_detected_s4(pdev, state); 9936 break; 9937 default: 9938 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9939 "1427 Invalid PCI device group: 0x%x\n", 9940 phba->pci_dev_grp); 9941 break; 9942 } 9943 return rc; 9944 } 9945 9946 /** 9947 * lpfc_io_slot_reset - lpfc method for restart PCI dev from scratch 9948 * @pdev: pointer to PCI device. 9949 * 9950 * This routine is registered to the PCI subsystem for error handling. This 9951 * function is called after PCI bus has been reset to restart the PCI card 9952 * from scratch, as if from a cold-boot. When this routine is invoked, it 9953 * dispatches the action to the proper SLI-3 or SLI-4 device reset handling 9954 * routine, which will perform the proper device reset. 9955 * 9956 * Return codes 9957 * PCI_ERS_RESULT_RECOVERED - the device has been recovered 9958 * PCI_ERS_RESULT_DISCONNECT - device could not be recovered 9959 **/ 9960 static pci_ers_result_t 9961 lpfc_io_slot_reset(struct pci_dev *pdev) 9962 { 9963 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9964 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9965 pci_ers_result_t rc = PCI_ERS_RESULT_DISCONNECT; 9966 9967 switch (phba->pci_dev_grp) { 9968 case LPFC_PCI_DEV_LP: 9969 rc = lpfc_io_slot_reset_s3(pdev); 9970 break; 9971 case LPFC_PCI_DEV_OC: 9972 rc = lpfc_io_slot_reset_s4(pdev); 9973 break; 9974 default: 9975 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 9976 "1428 Invalid PCI device group: 0x%x\n", 9977 phba->pci_dev_grp); 9978 break; 9979 } 9980 return rc; 9981 } 9982 9983 /** 9984 * lpfc_io_resume - lpfc method for resuming PCI I/O operation 9985 * @pdev: pointer to PCI device 9986 * 9987 * This routine is registered to the PCI subsystem for error handling. It 9988 * is called when kernel error recovery tells the lpfc driver that it is 9989 * OK to resume normal PCI operation after PCI bus error recovery. When 9990 * this routine is invoked, it dispatches the action to the proper SLI-3 9991 * or SLI-4 device io_resume routine, which will resume the device operation. 9992 **/ 9993 static void 9994 lpfc_io_resume(struct pci_dev *pdev) 9995 { 9996 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9997 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba; 9998 9999 switch (phba->pci_dev_grp) { 10000 case LPFC_PCI_DEV_LP: 10001 lpfc_io_resume_s3(pdev); 10002 break; 10003 case LPFC_PCI_DEV_OC: 10004 lpfc_io_resume_s4(pdev); 10005 break; 10006 default: 10007 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, 10008 "1429 Invalid PCI device group: 0x%x\n", 10009 phba->pci_dev_grp); 10010 break; 10011 } 10012 return; 10013 } 10014 10015 static struct pci_device_id lpfc_id_table[] = { 10016 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_VIPER, 10017 PCI_ANY_ID, PCI_ANY_ID, }, 10018 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FIREFLY, 10019 PCI_ANY_ID, PCI_ANY_ID, }, 10020 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_THOR, 10021 PCI_ANY_ID, PCI_ANY_ID, }, 10022 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PEGASUS, 10023 PCI_ANY_ID, PCI_ANY_ID, }, 10024 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_CENTAUR, 10025 PCI_ANY_ID, PCI_ANY_ID, }, 10026 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_DRAGONFLY, 10027 PCI_ANY_ID, PCI_ANY_ID, }, 10028 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SUPERFLY, 10029 PCI_ANY_ID, PCI_ANY_ID, }, 10030 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_RFLY, 10031 PCI_ANY_ID, PCI_ANY_ID, }, 10032 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PFLY, 10033 PCI_ANY_ID, PCI_ANY_ID, }, 10034 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE, 10035 PCI_ANY_ID, PCI_ANY_ID, }, 10036 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_SCSP, 10037 PCI_ANY_ID, PCI_ANY_ID, }, 10038 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_NEPTUNE_DCSP, 10039 PCI_ANY_ID, PCI_ANY_ID, }, 10040 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS, 10041 PCI_ANY_ID, PCI_ANY_ID, }, 10042 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_SCSP, 10043 PCI_ANY_ID, PCI_ANY_ID, }, 10044 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HELIOS_DCSP, 10045 PCI_ANY_ID, PCI_ANY_ID, }, 10046 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BMID, 10047 PCI_ANY_ID, PCI_ANY_ID, }, 10048 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BSMB, 10049 PCI_ANY_ID, PCI_ANY_ID, }, 10050 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR, 10051 PCI_ANY_ID, PCI_ANY_ID, }, 10052 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_HORNET, 10053 PCI_ANY_ID, PCI_ANY_ID, }, 10054 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_SCSP, 10055 PCI_ANY_ID, PCI_ANY_ID, }, 10056 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZEPHYR_DCSP, 10057 PCI_ANY_ID, PCI_ANY_ID, }, 10058 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZMID, 10059 PCI_ANY_ID, PCI_ANY_ID, }, 10060 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_ZSMB, 10061 PCI_ANY_ID, PCI_ANY_ID, }, 10062 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_TFLY, 10063 PCI_ANY_ID, PCI_ANY_ID, }, 10064 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP101, 10065 PCI_ANY_ID, PCI_ANY_ID, }, 10066 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP10000S, 10067 PCI_ANY_ID, PCI_ANY_ID, }, 10068 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LP11000S, 10069 PCI_ANY_ID, PCI_ANY_ID, }, 10070 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LPE11000S, 10071 PCI_ANY_ID, PCI_ANY_ID, }, 10072 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT, 10073 PCI_ANY_ID, PCI_ANY_ID, }, 10074 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_MID, 10075 PCI_ANY_ID, PCI_ANY_ID, }, 10076 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SMB, 10077 PCI_ANY_ID, PCI_ANY_ID, }, 10078 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_DCSP, 10079 PCI_ANY_ID, PCI_ANY_ID, }, 10080 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_SCSP, 10081 PCI_ANY_ID, PCI_ANY_ID, }, 10082 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_SAT_S, 10083 PCI_ANY_ID, PCI_ANY_ID, }, 10084 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_VF, 10085 PCI_ANY_ID, PCI_ANY_ID, }, 10086 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_PF, 10087 PCI_ANY_ID, PCI_ANY_ID, }, 10088 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_PROTEUS_S, 10089 PCI_ANY_ID, PCI_ANY_ID, }, 10090 {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK, 10091 PCI_ANY_ID, PCI_ANY_ID, }, 10092 {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TOMCAT, 10093 PCI_ANY_ID, PCI_ANY_ID, }, 10094 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FALCON, 10095 PCI_ANY_ID, PCI_ANY_ID, }, 10096 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_BALIUS, 10097 PCI_ANY_ID, PCI_ANY_ID, }, 10098 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FC, 10099 PCI_ANY_ID, PCI_ANY_ID, }, 10100 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FCOE, 10101 PCI_ANY_ID, PCI_ANY_ID, }, 10102 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FC_VF, 10103 PCI_ANY_ID, PCI_ANY_ID, }, 10104 {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FCOE_VF, 10105 PCI_ANY_ID, PCI_ANY_ID, }, 10106 { 0 } 10107 }; 10108 10109 MODULE_DEVICE_TABLE(pci, lpfc_id_table); 10110 10111 static struct pci_error_handlers lpfc_err_handler = { 10112 .error_detected = lpfc_io_error_detected, 10113 .slot_reset = lpfc_io_slot_reset, 10114 .resume = lpfc_io_resume, 10115 }; 10116 10117 static struct pci_driver lpfc_driver = { 10118 .name = LPFC_DRIVER_NAME, 10119 .id_table = lpfc_id_table, 10120 .probe = lpfc_pci_probe_one, 10121 .remove = __devexit_p(lpfc_pci_remove_one), 10122 .suspend = lpfc_pci_suspend_one, 10123 .resume = lpfc_pci_resume_one, 10124 .err_handler = &lpfc_err_handler, 10125 }; 10126 10127 /** 10128 * lpfc_init - lpfc module initialization routine 10129 * 10130 * This routine is to be invoked when the lpfc module is loaded into the 10131 * kernel. The special kernel macro module_init() is used to indicate the 10132 * role of this routine to the kernel as lpfc module entry point. 10133 * 10134 * Return codes 10135 * 0 - successful 10136 * -ENOMEM - FC attach transport failed 10137 * all others - failed 10138 */ 10139 static int __init 10140 lpfc_init(void) 10141 { 10142 int error = 0; 10143 10144 printk(LPFC_MODULE_DESC "\n"); 10145 printk(LPFC_COPYRIGHT "\n"); 10146 10147 if (lpfc_enable_npiv) { 10148 lpfc_transport_functions.vport_create = lpfc_vport_create; 10149 lpfc_transport_functions.vport_delete = lpfc_vport_delete; 10150 } 10151 lpfc_transport_template = 10152 fc_attach_transport(&lpfc_transport_functions); 10153 if (lpfc_transport_template == NULL) 10154 return -ENOMEM; 10155 if (lpfc_enable_npiv) { 10156 lpfc_vport_transport_template = 10157 fc_attach_transport(&lpfc_vport_transport_functions); 10158 if (lpfc_vport_transport_template == NULL) { 10159 fc_release_transport(lpfc_transport_template); 10160 return -ENOMEM; 10161 } 10162 } 10163 error = pci_register_driver(&lpfc_driver); 10164 if (error) { 10165 fc_release_transport(lpfc_transport_template); 10166 if (lpfc_enable_npiv) 10167 fc_release_transport(lpfc_vport_transport_template); 10168 } 10169 10170 return error; 10171 } 10172 10173 /** 10174 * lpfc_exit - lpfc module removal routine 10175 * 10176 * This routine is invoked when the lpfc module is removed from the kernel. 10177 * The special kernel macro module_exit() is used to indicate the role of 10178 * this routine to the kernel as lpfc module exit point. 10179 */ 10180 static void __exit 10181 lpfc_exit(void) 10182 { 10183 pci_unregister_driver(&lpfc_driver); 10184 fc_release_transport(lpfc_transport_template); 10185 if (lpfc_enable_npiv) 10186 fc_release_transport(lpfc_vport_transport_template); 10187 if (_dump_buf_data) { 10188 printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for " 10189 "_dump_buf_data at 0x%p\n", 10190 (1L << _dump_buf_data_order), _dump_buf_data); 10191 free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order); 10192 } 10193 10194 if (_dump_buf_dif) { 10195 printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for " 10196 "_dump_buf_dif at 0x%p\n", 10197 (1L << _dump_buf_dif_order), _dump_buf_dif); 10198 free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order); 10199 } 10200 } 10201 10202 module_init(lpfc_init); 10203 module_exit(lpfc_exit); 10204 MODULE_LICENSE("GPL"); 10205 MODULE_DESCRIPTION(LPFC_MODULE_DESC); 10206 MODULE_AUTHOR("Emulex Corporation - tech.support@emulex.com"); 10207 MODULE_VERSION("0:" LPFC_DRIVER_VERSION); 10208