Lines Matching refs:phba
64 lpfc_config_port_prep(struct lpfc_hba * phba)
66 lpfc_vpd_t *vp = &phba->vpd;
76 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
78 phba->hba_state = LPFC_HBA_ERROR;
83 phba->hba_state = LPFC_INIT_MBX_CMDS;
85 if (lpfc_is_LC_HBA(phba->pcidev->device)) {
94 lpfc_read_nv(phba, pmb);
100 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
103 lpfc_printf_log(phba,
109 phba->brd_no,
111 mempool_free(pmb, phba->mbox_mem_pool);
114 memcpy(phba->wwnn, (char *)mb->un.varRDnvp.nodename,
119 lpfc_read_rev(phba, pmb);
120 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
122 lpfc_printf_log(phba,
127 phba->brd_no,
129 mempool_free( pmb, phba->mbox_mem_pool);
139 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
142 phba->brd_no);
143 mempool_free(pmb, phba->mbox_mem_pool);
164 if (lpfc_is_LC_HBA(phba->pcidev->device))
165 memcpy(phba->RandomData, (char *)&mb->un.varWords[24],
166 sizeof (phba->RandomData));
177 lpfc_dump_mem(phba, pmb, offset);
178 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
181 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
184 phba->brd_no,
194 lpfc_parse_vpd(phba, lpfc_vpd_data, offset);
200 mempool_free(pmb, phba->mbox_mem_pool);
215 lpfc_config_port_post(struct lpfc_hba * phba)
220 struct lpfc_sli *psli = &phba->sli;
224 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
226 phba->hba_state = LPFC_HBA_ERROR;
231 lpfc_config_link(phba, pmb);
232 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
234 lpfc_printf_log(phba,
239 phba->brd_no,
241 phba->hba_state = LPFC_HBA_ERROR;
242 mempool_free( pmb, phba->mbox_mem_pool);
247 lpfc_read_sparam(phba, pmb);
248 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
249 lpfc_printf_log(phba,
254 phba->brd_no,
256 phba->hba_state = LPFC_HBA_ERROR;
258 mempool_free( pmb, phba->mbox_mem_pool);
259 lpfc_mbuf_free(phba, mp->virt, mp->phys);
266 memcpy(&phba->fc_sparam, mp->virt, sizeof (struct serv_parm));
267 lpfc_mbuf_free(phba, mp->virt, mp->phys);
271 if (phba->cfg_soft_wwnn)
272 u64_to_wwn(phba->cfg_soft_wwnn, phba->fc_sparam.nodeName.u.wwn);
273 if (phba->cfg_soft_wwpn)
274 u64_to_wwn(phba->cfg_soft_wwpn, phba->fc_sparam.portName.u.wwn);
275 memcpy(&phba->fc_nodename, &phba->fc_sparam.nodeName,
277 memcpy(&phba->fc_portname, &phba->fc_sparam.portName,
281 if (phba->SerialNumber[0] == 0) {
284 outptr = &phba->fc_nodename.u.s.IEEE[0];
289 phba->SerialNumber[i] =
292 phba->SerialNumber[i] =
297 phba->SerialNumber[i] =
300 phba->SerialNumber[i] =
305 lpfc_read_config(phba, pmb);
306 if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
307 lpfc_printf_log(phba,
312 phba->brd_no,
314 phba->hba_state = LPFC_HBA_ERROR;
315 mempool_free( pmb, phba->mbox_mem_pool);
320 if (phba->cfg_hba_queue_depth > (mb->un.varRdConfig.max_xri+1))
321 phba->cfg_hba_queue_depth =
324 phba->lmt = mb->un.varRdConfig.lmt;
327 lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
329 if ((phba->cfg_link_speed > LINK_SPEED_10G)
330 || ((phba->cfg_link_speed == LINK_SPEED_1G)
331 && !(phba->lmt & LMT_1Gb))
332 || ((phba->cfg_link_speed == LINK_SPEED_2G)
333 && !(phba->lmt & LMT_2Gb))
334 || ((phba->cfg_link_speed == LINK_SPEED_4G)
335 && !(phba->lmt & LMT_4Gb))
336 || ((phba->cfg_link_speed == LINK_SPEED_8G)
337 && !(phba->lmt & LMT_8Gb))
338 || ((phba->cfg_link_speed == LINK_SPEED_10G)
339 && !(phba->lmt & LMT_10Gb))) {
341 lpfc_printf_log(phba,
346 phba->brd_no,
347 phba->cfg_link_speed);
348 phba->cfg_link_speed = LINK_SPEED_AUTO;
351 phba->hba_state = LPFC_LINK_DOWN;
362 lpfc_post_rcv_buf(phba);
365 spin_lock_irq(phba->host->host_lock);
366 status = readl(phba->HCregaddr);
377 if ((phba->cfg_poll & ENABLE_FCP_RING_POLLING) &&
378 (phba->cfg_poll & DISABLE_FCP_RING_INT))
381 writel(status, phba->HCregaddr);
382 readl(phba->HCregaddr); /* flush */
383 spin_unlock_irq(phba->host->host_lock);
388 timeout = phba->fc_ratov << 1;
389 mod_timer(&phba->els_tmofunc, jiffies + HZ * timeout);
391 lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
393 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
394 lpfc_set_loopback_flag(phba);
396 lpfc_printf_log(phba,
401 phba->brd_no,
405 writel(0, phba->HCregaddr);
406 readl(phba->HCregaddr); /* flush */
408 writel(0xffffffff, phba->HAregaddr);
409 readl(phba->HAregaddr); /* flush */
411 phba->hba_state = LPFC_HBA_ERROR;
413 mempool_free(pmb, phba->mbox_mem_pool);
432 lpfc_hba_down_prep(struct lpfc_hba * phba)
435 writel(0, phba->HCregaddr);
436 readl(phba->HCregaddr); /* flush */
439 lpfc_els_flush_rscn(phba);
440 lpfc_els_flush_cmd(phba);
441 lpfc_disc_flush_list(phba);
456 lpfc_hba_down_post(struct lpfc_hba * phba)
458 struct lpfc_sli *psli = &phba->sli;
468 lpfc_mbuf_free(phba, mp->virt, mp->phys);
474 lpfc_sli_abort_iocb_ring(phba, pring);
489 lpfc_handle_eratt(struct lpfc_hba * phba)
491 struct lpfc_sli *psli = &phba->sli;
496 if (pci_channel_offline(phba->pcidev))
499 if (phba->work_hs & HS_FFER6 ||
500 phba->work_hs & HS_FFER5) {
502 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT,
505 phba->brd_no, phba->work_hs,
506 phba->work_status[0], phba->work_status[1]);
507 spin_lock_irq(phba->host->host_lock);
508 phba->fc_flag |= FC_ESTABLISH_LINK;
510 spin_unlock_irq(phba->host->host_lock);
519 lpfc_sli_abort_iocb_ring(phba, pring);
526 lpfc_offline_prep(phba);
527 lpfc_offline(phba);
528 lpfc_sli_brdrestart(phba);
529 if (lpfc_online(phba) == 0) { /* Initialize the HBA */
530 mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);
531 lpfc_unblock_mgmt_io(phba);
534 lpfc_unblock_mgmt_io(phba);
540 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
543 phba->brd_no, phba->work_hs,
544 phba->work_status[0], phba->work_status[1]);
547 fc_host_post_vendor_event(phba->host, fc_get_event_number(),
552 lpfc_offline_prep(phba);
553 lpfc_offline(phba);
554 lpfc_unblock_mgmt_io(phba);
555 phba->hba_state = LPFC_HBA_ERROR;
556 lpfc_hba_down_post(phba);
569 lpfc_handle_latt(struct lpfc_hba * phba)
571 struct lpfc_sli *psli = &phba->sli;
577 pmb = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
585 mp->virt = lpfc_mbuf_alloc(phba, 0, &mp->phys);
592 lpfc_els_flush_cmd(phba);
595 lpfc_read_la(phba, pmb, mp);
597 rc = lpfc_sli_issue_mbox (phba, pmb, (MBX_NOWAIT | MBX_STOP_IOCB));
602 spin_lock_irq(phba->host->host_lock);
603 writel(HA_LATT, phba->HAregaddr);
604 readl(phba->HAregaddr); /* flush */
605 spin_unlock_irq(phba->host->host_lock);
610 lpfc_mbuf_free(phba, mp->virt, mp->phys);
614 mempool_free(pmb, phba->mbox_mem_pool);
617 spin_lock_irq(phba->host->host_lock);
619 control = readl(phba->HCregaddr);
621 writel(control, phba->HCregaddr);
622 readl(phba->HCregaddr); /* flush */
625 writel(HA_LATT, phba->HAregaddr);
626 readl(phba->HAregaddr); /* flush */
627 spin_unlock_irq(phba->host->host_lock);
628 lpfc_linkdown(phba);
629 phba->hba_state = LPFC_HBA_ERROR;
633 lpfc_printf_log(phba,
637 phba->brd_no);
649 lpfc_parse_vpd(struct lpfc_hba * phba, uint8_t * vpd, int len)
661 lpfc_printf_log(phba,
665 phba->brd_no,
698 phba->SerialNumber[j++] = vpd[index++];
702 phba->SerialNumber[j] = 0;
706 phba->vpd_flag |= VPD_MODEL_DESC;
713 phba->ModelDesc[j++] = vpd[index++];
717 phba->ModelDesc[j] = 0;
721 phba->vpd_flag |= VPD_MODEL_NAME;
728 phba->ModelName[j++] = vpd[index++];
732 phba->ModelName[j] = 0;
736 phba->vpd_flag |= VPD_PROGRAM_TYPE;
743 phba->ProgramType[j++] = vpd[index++];
747 phba->ProgramType[j] = 0;
751 phba->vpd_flag |= VPD_PORT;
758 phba->Port[j++] = vpd[index++];
762 phba->Port[j] = 0;
788 lpfc_get_hba_model_desc(struct lpfc_hba * phba, uint8_t * mdp, uint8_t * descp)
791 uint16_t dev_id = phba->pcidev->device;
803 if (phba->lmt & LMT_10Gb)
805 else if (phba->lmt & LMT_8Gb)
807 else if (phba->lmt & LMT_4Gb)
809 else if (phba->lmt & LMT_2Gb)
814 vp = &phba->vpd;
946 lpfc_post_buffer(struct lpfc_hba * phba, struct lpfc_sli_ring * pring, int cnt,
958 spin_lock_irq(phba->host->host_lock);
959 iocb = lpfc_sli_get_iocbq(phba);
960 spin_unlock_irq(phba->host->host_lock);
971 mp1->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
975 spin_lock_irq(phba->host->host_lock);
976 lpfc_sli_release_iocbq(phba, iocb);
977 spin_unlock_irq(phba->host->host_lock);
987 mp2->virt = lpfc_mbuf_alloc(phba, MEM_PRI,
991 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
993 spin_lock_irq(phba->host->host_lock);
994 lpfc_sli_release_iocbq(phba, iocb);
995 spin_unlock_irq(phba->host->host_lock);
1021 spin_lock_irq(phba->host->host_lock);
1022 if (lpfc_sli_issue_iocb(phba, pring, iocb, 0) == IOCB_ERROR) {
1023 lpfc_mbuf_free(phba, mp1->virt, mp1->phys);
1027 lpfc_mbuf_free(phba, mp2->virt, mp2->phys);
1031 lpfc_sli_release_iocbq(phba, iocb);
1033 spin_unlock_irq(phba->host->host_lock);
1036 spin_unlock_irq(phba->host->host_lock);
1037 lpfc_sli_ringpostbuf_put(phba, pring, mp1);
1039 lpfc_sli_ringpostbuf_put(phba, pring, mp2);
1053 lpfc_post_rcv_buf(struct lpfc_hba * phba)
1055 struct lpfc_sli *psli = &phba->sli;
1058 lpfc_post_buffer(phba, &psli->ring[LPFC_ELS_RING], LPFC_BUF_RING0, 1);
1150 lpfc_hba_init(struct lpfc_hba *phba, uint32_t *hbainit)
1154 uint32_t *pwwnn = phba->wwnn;
1165 lpfc_challenge_key(phba->RandomData + t, HashWorking + t);
1173 lpfc_cleanup(struct lpfc_hba * phba)
1177 /* clean up phba - lpfc specific */
1178 lpfc_can_disctmo(phba);
1179 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp)
1182 INIT_LIST_HEAD(&phba->fc_nodes);
1190 struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
1195 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
1198 phba->brd_no, phba->fc_flag, phba->hba_state);
1199 spin_lock_irqsave(phba->host->host_lock, iflag);
1200 phba->fc_flag &= ~FC_ESTABLISH_LINK;
1201 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1205 lpfc_stop_timer(struct lpfc_hba * phba)
1207 struct lpfc_sli *psli = &phba->sli;
1209 del_timer_sync(&phba->fcp_poll_timer);
1210 del_timer_sync(&phba->fc_estabtmo);
1211 del_timer_sync(&phba->fc_disctmo);
1212 del_timer_sync(&phba->fc_fdmitmo);
1213 del_timer_sync(&phba->els_tmofunc);
1214 psli = &phba->sli;
1220 lpfc_online(struct lpfc_hba * phba)
1222 if (!phba)
1225 if (!(phba->fc_flag & FC_OFFLINE_MODE))
1228 lpfc_printf_log(phba,
1232 phba->brd_no);
1234 lpfc_block_mgmt_io(phba);
1236 if (!lpfc_sli_queue_setup(phba)) {
1237 lpfc_unblock_mgmt_io(phba);
1241 if (lpfc_sli_hba_setup(phba)) { /* Initialize the HBA */
1242 lpfc_unblock_mgmt_io(phba);
1246 spin_lock_irq(phba->host->host_lock);
1247 phba->fc_flag &= ~FC_OFFLINE_MODE;
1248 spin_unlock_irq(phba->host->host_lock);
1250 lpfc_unblock_mgmt_io(phba);
1255 lpfc_block_mgmt_io(struct lpfc_hba * phba)
1259 spin_lock_irqsave(phba->host->host_lock, iflag);
1260 phba->fc_flag |= FC_BLOCK_MGMT_IO;
1261 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1265 lpfc_unblock_mgmt_io(struct lpfc_hba * phba)
1269 spin_lock_irqsave(phba->host->host_lock, iflag);
1270 phba->fc_flag &= ~FC_BLOCK_MGMT_IO;
1271 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1275 lpfc_offline_prep(struct lpfc_hba * phba)
1279 if (phba->fc_flag & FC_OFFLINE_MODE)
1282 lpfc_block_mgmt_io(phba);
1284 lpfc_linkdown(phba);
1287 list_for_each_entry_safe(ndlp, next_ndlp, &phba->fc_nodes, nlp_listp)
1289 lpfc_unreg_rpi(phba, ndlp);
1291 lpfc_sli_flush_mbox_queue(phba);
1295 lpfc_offline(struct lpfc_hba * phba)
1299 if (phba->fc_flag & FC_OFFLINE_MODE)
1303 lpfc_stop_timer(phba);
1305 lpfc_printf_log(phba,
1309 phba->brd_no);
1313 lpfc_sli_hba_down(phba);
1314 lpfc_cleanup(phba);
1315 spin_lock_irqsave(phba->host->host_lock, iflag);
1316 phba->work_hba_events = 0;
1317 phba->work_ha = 0;
1318 phba->fc_flag |= FC_OFFLINE_MODE;
1319 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1329 lpfc_scsi_free(struct lpfc_hba * phba)
1334 spin_lock_irq(phba->host->host_lock);
1336 list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
1338 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
1341 phba->total_scsi_bufs--;
1345 list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
1348 phba->total_iocbq_bufs--;
1351 spin_unlock_irq(phba->host->host_lock);
1356 void lpfc_remove_device(struct lpfc_hba *phba)
1360 lpfc_free_sysfs_attr(phba);
1362 spin_lock_irqsave(phba->host->host_lock, iflag);
1363 phba->fc_flag |= FC_UNLOADING;
1365 spin_unlock_irqrestore(phba->host->host_lock, iflag);
1367 fc_remove_host(phba->host);
1368 scsi_remove_host(phba->host);
1370 kthread_stop(phba->worker_thread);
1377 lpfc_sli_hba_down(phba);
1378 lpfc_sli_brdrestart(phba);
1381 free_irq(phba->pcidev->irq, phba);
1382 pci_disable_msi(phba->pcidev);
1384 lpfc_cleanup(phba);
1385 lpfc_stop_timer(phba);
1386 phba->work_hba_events = 0;
1392 lpfc_scsi_free(phba);
1393 lpfc_mem_free(phba);
1396 dma_free_coherent(&phba->pcidev->dev, SLI2_SLIM_SIZE,
1397 phba->slim2p, phba->slim2p_mapping);
1400 iounmap(phba->ctrl_regs_memmap_p);
1401 iounmap(phba->slim_memmap_p);
1403 pci_release_regions(phba->pcidev);
1404 pci_disable_device(phba->pcidev);
1406 idr_remove(&lpfc_hba_index, phba->brd_no);
1407 scsi_host_put(phba->host);
1412 struct lpfc_hba *phba = (struct lpfc_hba*)host->hostdata;
1414 if (lpfc_alloc_sysfs_attr(phba))
1417 phba->MBslimaddr = phba->slim_memmap_p;
1418 phba->HAregaddr = phba->ctrl_regs_memmap_p + HA_REG_OFFSET;
1419 phba->CAregaddr = phba->ctrl_regs_memmap_p + CA_REG_OFFSET;
1420 phba->HSregaddr = phba->ctrl_regs_memmap_p + HS_REG_OFFSET;
1421 phba->HCregaddr = phba->ctrl_regs_memmap_p + HC_REG_OFFSET;
1423 if (lpfc_sli_hba_setup(phba))
1430 host->can_queue = phba->cfg_hba_queue_depth - 10;
1434 lpfc_remove_device(phba);
1439 struct lpfc_hba *phba = (struct lpfc_hba *)shost->hostdata;
1441 if (!phba->host)
1446 if (phba->hba_state != LPFC_HBA_READY)
1448 if (phba->num_disc_nodes || phba->fc_prli_sent)
1450 if ((phba->fc_map_cnt == 0) && (time < 2 * HZ))
1452 if (phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE)
1454 if ((phba->hba_state > LPFC_LINK_DOWN) || (time < 15 * HZ))
1458 if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
1460 lpfc_poll_start_timer(phba);
1469 fc_host_node_name(shost) = wwn_to_u64(phba->fc_nodename.u.wwn);
1470 fc_host_port_name(shost) = wwn_to_u64(phba->fc_portname.u.wwn);
1478 lpfc_get_hba_sym_node_name(phba, fc_host_symbolic_name(shost));
1481 if (phba->lmt & LMT_10Gb)
1483 if (phba->lmt & LMT_4Gb)
1485 if (phba->lmt & LMT_2Gb)
1487 if (phba->lmt & LMT_1Gb)
1491 ((((uint32_t) phba->fc_sparam.cmn.bbRcvSizeMsb & 0x0F) << 8) |
1492 (uint32_t) phba->fc_sparam.cmn.bbRcvSizeLsb);
1501 phba->fc_flag &= ~FC_LOADING;
1511 struct lpfc_hba *phba;
1528 phba = (struct lpfc_hba*)host->hostdata;
1529 memset(phba, 0, sizeof (struct lpfc_hba));
1530 phba->host = host;
1532 phba->fc_flag |= FC_LOADING;
1533 phba->pcidev = pdev;
1539 error = idr_get_new(&lpfc_hba_index, NULL, &phba->brd_no);
1543 host->unique_id = phba->brd_no;
1546 init_timer(&phba->fc_estabtmo);
1547 phba->fc_estabtmo.function = lpfc_establish_link_tmo;
1548 phba->fc_estabtmo.data = (unsigned long)phba;
1549 init_timer(&phba->fc_disctmo);
1550 phba->fc_disctmo.function = lpfc_disc_timeout;
1551 phba->fc_disctmo.data = (unsigned long)phba;
1553 init_timer(&phba->fc_fdmitmo);
1554 phba->fc_fdmitmo.function = lpfc_fdmi_tmo;
1555 phba->fc_fdmitmo.data = (unsigned long)phba;
1556 init_timer(&phba->els_tmofunc);
1557 phba->els_tmofunc.function = lpfc_els_timeout;
1558 phba->els_tmofunc.data = (unsigned long)phba;
1559 psli = &phba->sli;
1562 psli->mbox_tmo.data = (unsigned long)phba;
1564 init_timer(&phba->fcp_poll_timer);
1565 phba->fcp_poll_timer.function = lpfc_poll_timeout;
1566 phba->fcp_poll_timer.data = (unsigned long)phba;
1572 lpfc_get_cfgparam(phba);
1575 host->max_lun = phba->cfg_max_luns;
1578 INIT_LIST_HEAD(&phba->fc_nodes);
1586 if (pci_set_dma_mask(phba->pcidev, DMA_64BIT_MASK) != 0)
1587 if (pci_set_dma_mask(phba->pcidev, DMA_32BIT_MASK) != 0)
1594 phba->pci_bar0_map = pci_resource_start(phba->pcidev, 0);
1595 bar0map_len = pci_resource_len(phba->pcidev, 0);
1597 phba->pci_bar2_map = pci_resource_start(phba->pcidev, 2);
1598 bar2map_len = pci_resource_len(phba->pcidev, 2);
1601 phba->slim_memmap_p = ioremap(phba->pci_bar0_map, bar0map_len);
1602 if (!phba->slim_memmap_p) {
1610 phba->ctrl_regs_memmap_p = ioremap(phba->pci_bar2_map, bar2map_len);
1611 if (!phba->ctrl_regs_memmap_p) {
1619 phba->slim2p = dma_alloc_coherent(&phba->pcidev->dev, SLI2_SLIM_SIZE,
1620 &phba->slim2p_mapping, GFP_KERNEL);
1621 if (!phba->slim2p)
1624 memset(phba->slim2p, 0, SLI2_SLIM_SIZE);
1627 lpfc_sli_setup(phba);
1628 lpfc_sli_queue_setup(phba);
1630 error = lpfc_mem_alloc(phba);
1635 INIT_LIST_HEAD(&phba->lpfc_iocb_list);
1647 iotag = lpfc_sli_next_iotag(phba, iocbq_entry);
1656 spin_lock_irq(phba->host->host_lock);
1657 list_add(&iocbq_entry->list, &phba->lpfc_iocb_list);
1658 phba->total_iocbq_bufs++;
1659 spin_unlock_irq(phba->host->host_lock);
1663 phba->fc_edtov = FF_DEF_EDTOV;
1664 phba->fc_ratov = FF_DEF_RATOV;
1665 phba->fc_altov = FF_DEF_ALTOV;
1666 phba->fc_arbtov = FF_DEF_ARBTOV;
1668 INIT_LIST_HEAD(&phba->work_list);
1669 phba->work_ha_mask = (HA_ERATT|HA_MBATT|HA_LATT);
1670 phba->work_ha_mask |= (HA_RXMASK << (LPFC_ELS_RING * 4));
1673 phba->worker_thread = kthread_run(lpfc_do_work, phba,
1674 "lpfc_worker_%d", phba->brd_no);
1675 if (IS_ERR(phba->worker_thread)) {
1676 error = PTR_ERR(phba->worker_thread);
1685 host->can_queue = phba->cfg_hba_queue_depth - 10;
1691 spin_lock_init(&phba->scsi_buf_list_lock);
1692 INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
1697 if (phba->cfg_use_msi) {
1698 error = pci_enable_msi(phba->pcidev);
1700 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, "%d:0452 "
1702 "IRQ\n", phba->brd_no);
1705 error = request_irq(phba->pcidev->irq, lpfc_intr_handler, IRQF_SHARED,
1706 LPFC_DRIVER_NAME, phba);
1708 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1710 phba->brd_no);
1723 lpfc_stop_timer(phba);
1724 phba->work_hba_events = 0;
1725 free_irq(phba->pcidev->irq, phba);
1726 pci_disable_msi(phba->pcidev);
1728 kthread_stop(phba->worker_thread);
1731 &phba->lpfc_iocb_list, list) {
1732 spin_lock_irq(phba->host->host_lock);
1734 phba->total_iocbq_bufs--;
1735 spin_unlock_irq(phba->host->host_lock);
1737 lpfc_mem_free(phba);
1739 dma_free_coherent(&pdev->dev, SLI2_SLIM_SIZE, phba->slim2p,
1740 phba->slim2p_mapping);
1742 iounmap(phba->ctrl_regs_memmap_p);
1744 iounmap(phba->slim_memmap_p);
1746 idr_remove(&lpfc_hba_index, phba->brd_no);
1748 phba->host = NULL;
1763 struct lpfc_hba *phba = (struct lpfc_hba *)host->hostdata;
1765 lpfc_remove_device(phba);
1782 struct lpfc_hba *phba = (struct lpfc_hba *)host->hostdata;
1783 struct lpfc_sli *psli = &phba->sli;
1796 lpfc_sli_abort_iocb_ring(phba, pring);
1811 struct lpfc_hba *phba = (struct lpfc_hba *)host->hostdata;
1812 struct lpfc_sli *psli = &phba->sli;
1825 spin_lock_irq(phba->host->host_lock);
1826 phba->fc_flag |= FC_ESTABLISH_LINK;
1828 spin_unlock_irq(phba->host->host_lock);
1832 lpfc_offline(phba);
1833 lpfc_sli_brdrestart(phba);
1848 struct lpfc_hba *phba = (struct lpfc_hba *)host->hostdata;
1850 if (lpfc_online(phba) == 0) {
1851 mod_timer(&phba->fc_estabtmo, jiffies + HZ * 60);