static void
bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
enum bfa_itnim_aen_event event)
{
struct bfa_fcs_rport_s *rport = itnim->rport;
union bfa_aen_data_u aen_data;
struct bfa_log_mod_s *logmod = rport->fcs->logm;
wwn_t lpwwn = bfa_fcs_port_get_pwwn(rport->port);
wwn_t rpwwn = rport->pwwn;
char lpwwn_ptr[BFA_STRING_32];
char rpwwn_ptr[BFA_STRING_32];
/*
* Don't post events for well known addresses
*/
if (BFA_FCS_PID_IS_WKA(rport->pid))
return;
wwn2str(lpwwn_ptr, lpwwn);
wwn2str(rpwwn_ptr, rpwwn);
switch (event) {
case BFA_ITNIM_AEN_ONLINE:
bfa_log(logmod, BFA_AEN_ITNIM_ONLINE, rpwwn_ptr, lpwwn_ptr);
break;
case BFA_ITNIM_AEN_OFFLINE:
bfa_log(logmod, BFA_AEN_ITNIM_OFFLINE, rpwwn_ptr, lpwwn_ptr);
break;
case BFA_ITNIM_AEN_DISCONNECT:
bfa_log(logmod, BFA_AEN_ITNIM_DISCONNECT, rpwwn_ptr, lpwwn_ptr);
break;
default:
break;
}
aen_data.itnim.vf_id = rport->port->fabric->vf_id;
aen_data.itnim.ppwwn =
bfa_fcs_port_get_pwwn(bfa_fcs_get_base_port(itnim->fcs));
aen_data.itnim.lpwwn = lpwwn;
aen_data.itnim.rpwwn = rpwwn;
}
/**
* Send AEN notification
*/
static void
bfa_fcs_vport_aen_post(bfa_fcs_lport_t *port, enum bfa_lport_aen_event event)
{
union bfa_aen_data_u aen_data;
struct bfa_log_mod_s *logmod = port->fcs->logm;
enum bfa_port_role role = port->port_cfg.roles;
wwn_t lpwwn = bfa_fcs_port_get_pwwn(port);
char lpwwn_ptr[BFA_STRING_32];
char *role_str[BFA_PORT_ROLE_FCP_MAX / 2 + 1] =
{ "Initiator", "Target", "IPFC" };
wwn2str(lpwwn_ptr, lpwwn);
bfa_assert(role <= BFA_PORT_ROLE_FCP_MAX);
switch (event) {
case BFA_LPORT_AEN_NPIV_DUP_WWN:
bfa_log(logmod, BFA_AEN_LPORT_NPIV_DUP_WWN, lpwwn_ptr,
role_str[role / 2]);
break;
case BFA_LPORT_AEN_NPIV_FABRIC_MAX:
bfa_log(logmod, BFA_AEN_LPORT_NPIV_FABRIC_MAX, lpwwn_ptr,
role_str[role / 2]);
break;
case BFA_LPORT_AEN_NPIV_UNKNOWN:
bfa_log(logmod, BFA_AEN_LPORT_NPIV_UNKNOWN, lpwwn_ptr,
role_str[role / 2]);
break;
default:
break;
}
aen_data.lport.vf_id = port->fabric->vf_id;
aen_data.lport.roles = role;
aen_data.lport.ppwwn =
bfa_fcs_port_get_pwwn(bfa_fcs_get_base_port(port->fcs));
aen_data.lport.lpwwn = lpwwn;
}
static void
bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
{
union bfa_aen_data_u aen_data;
struct bfa_log_mod_s *logmod = fcport->bfa->logm;
wwn_t pwwn = fcport->pwwn;
char pwwn_ptr[BFA_STRING_32];
memset(&aen_data, 0, sizeof(aen_data));
wwn2str(pwwn_ptr, pwwn);
bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_PORT, event), pwwn_ptr);
aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
aen_data.port.pwwn = pwwn;
}
bfa_status_t
bfad_start_ops(struct bfad_s *bfad)
{
int retval;
/* PPORT FCS config */
bfad_fcs_port_cfg(bfad);
retval = bfad_cfg_pport(bfad, BFA_PORT_ROLE_FCP_IM);
if (retval != BFA_STATUS_OK)
goto out_cfg_pport_failure;
/* BFAD level FC4 (IM/TM/IPFC) specific resource allocation */
retval = bfad_fc4_probe(bfad);
if (retval != BFA_STATUS_OK) {
printk(KERN_WARNING "bfad_fc4_probe failed\n");
goto out_fc4_probe_failure;
}
bfad_drv_start(bfad);
/*
* If bfa_linkup_delay is set to -1 default; try to retrive the
* value using the bfad_os_get_linkup_delay(); else use the
* passed in module param value as the bfa_linkup_delay.
*/
if (bfa_linkup_delay < 0) {
bfa_linkup_delay = bfad_os_get_linkup_delay(bfad);
bfad_os_rport_online_wait(bfad);
bfa_linkup_delay = -1;
} else {
bfad_os_rport_online_wait(bfad);
}
bfa_log(bfad->logmod, BFA_LOG_LINUX_DEVICE_CLAIMED, bfad->pci_name);
return BFA_STATUS_OK;
out_fc4_probe_failure:
bfad_fc4_probe_undo(bfad);
bfad_uncfg_pport(bfad);
out_cfg_pport_failure:
return BFA_STATUS_FAILED;
}
static void
bfa_pport_aen_post(struct bfa_pport_s *pport, enum bfa_port_aen_event event)
{
union bfa_aen_data_u aen_data;
struct bfa_log_mod_s *logmod = pport->bfa->logm;
wwn_t pwwn = pport->pwwn;
char pwwn_ptr[BFA_STRING_32];
struct bfa_ioc_attr_s ioc_attr;
wwn2str(pwwn_ptr, pwwn);
switch (event) {
case BFA_PORT_AEN_ONLINE:
bfa_log(logmod, BFA_AEN_PORT_ONLINE, pwwn_ptr);
break;
case BFA_PORT_AEN_OFFLINE:
bfa_log(logmod, BFA_AEN_PORT_OFFLINE, pwwn_ptr);
break;
case BFA_PORT_AEN_ENABLE:
bfa_log(logmod, BFA_AEN_PORT_ENABLE, pwwn_ptr);
break;
case BFA_PORT_AEN_DISABLE:
bfa_log(logmod, BFA_AEN_PORT_DISABLE, pwwn_ptr);
break;
case BFA_PORT_AEN_DISCONNECT:
bfa_log(logmod, BFA_AEN_PORT_DISCONNECT, pwwn_ptr);
break;
case BFA_PORT_AEN_QOS_NEG:
bfa_log(logmod, BFA_AEN_PORT_QOS_NEG, pwwn_ptr);
break;
default:
break;
}
bfa_ioc_get_attr(&pport->bfa->ioc, &ioc_attr);
aen_data.port.ioc_type = ioc_attr.ioc_type;
aen_data.port.pwwn = pwwn;
}
void
bfa_panic(int line, char *file, char *panicstr)
{
bfa_log(NULL, BFA_LOG_HAL_ASSERT, file, line, panicstr);
bfa_os_panic();
}
void
bfa_sm_panic(struct bfa_log_mod_s *logm, int line, char *file, int event)
{
bfa_log(logm, BFA_LOG_HAL_SM_ASSERT, file, line, event);
bfa_os_panic();
}
/**
* PCI probe entry.
*/
int
bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
{
struct bfad_s *bfad;
int error = -ENODEV, retval;
char buf[16];
/*
* For single port cards - only claim function 0
*/
if ((pdev->device == BFA_PCI_DEVICE_ID_FC_8G1P)
&& (PCI_FUNC(pdev->devfn) != 0))
return -ENODEV;
BFA_TRACE(BFA_INFO, "bfad_pci_probe entry");
bfad = kzalloc(sizeof(struct bfad_s), GFP_KERNEL);
if (!bfad) {
error = -ENOMEM;
goto out;
}
bfad->trcmod = kzalloc(sizeof(struct bfa_trc_mod_s), GFP_KERNEL);
if (!bfad->trcmod) {
printk(KERN_WARNING "Error alloc trace buffer!\n");
error = -ENOMEM;
goto out_alloc_trace_failure;
}
/*
* LOG/TRACE INIT
*/
bfa_trc_init(bfad->trcmod);
bfa_trc(bfad, bfad_inst);
bfad->logmod = &bfad->log_data;
sprintf(buf, "%d", bfad_inst);
bfa_log_init(bfad->logmod, buf, bfa_os_printf);
bfad_drv_log_level_set(bfad);
bfad->aen = &bfad->aen_buf;
if (!(bfad_load_fwimg(pdev))) {
printk(KERN_WARNING "bfad_load_fwimg failure!\n");
kfree(bfad->trcmod);
goto out_alloc_trace_failure;
}
retval = bfad_pci_init(pdev, bfad);
if (retval) {
printk(KERN_WARNING "bfad_pci_init failure!\n");
error = retval;
goto out_pci_init_failure;
}
mutex_lock(&bfad_mutex);
bfad->inst_no = bfad_inst++;
list_add_tail(&bfad->list_entry, &bfad_list);
mutex_unlock(&bfad_mutex);
spin_lock_init(&bfad->bfad_lock);
pci_set_drvdata(pdev, bfad);
bfad->ref_count = 0;
bfad->pport.bfad = bfad;
retval = bfad_drv_init(bfad);
if (retval != BFA_STATUS_OK)
goto out_drv_init_failure;
if (!(bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
printk(KERN_WARNING "bfad%d: hal init failed\n", bfad->inst_no);
goto ok;
}
/*
* PPORT FCS config
*/
bfad_fcs_port_cfg(bfad);
retval = bfad_cfg_pport(bfad, BFA_PORT_ROLE_FCP_IM);
if (retval != BFA_STATUS_OK)
goto out_cfg_pport_failure;
/*
* BFAD level FC4 (IM/TM/IPFC) specific resource allocation
*/
retval = bfad_fc4_probe(bfad);
if (retval != BFA_STATUS_OK) {
printk(KERN_WARNING "bfad_fc4_probe failed\n");
goto out_fc4_probe_failure;
}
bfad_drv_start(bfad);
/*
* If bfa_linkup_delay is set to -1 default; try to retrive the
* value using the bfad_os_get_linkup_delay(); else use the
* passed in module param value as the bfa_linkup_delay.
*/
if (bfa_linkup_delay < 0) {
bfa_linkup_delay = bfad_os_get_linkup_delay(bfad);
bfad_os_rport_online_wait(bfad);
bfa_linkup_delay = -1;
} else {
bfad_os_rport_online_wait(bfad);
}
bfa_log(bfad->logmod, BFA_LOG_LINUX_DEVICE_CLAIMED, bfad->pci_name);
ok:
return 0;
out_fc4_probe_failure:
bfad_fc4_probe_undo(bfad);
bfad_uncfg_pport(bfad);
out_cfg_pport_failure:
bfad_drv_uninit(bfad);
out_drv_init_failure:
mutex_lock(&bfad_mutex);
bfad_inst--;
list_del(&bfad->list_entry);
mutex_unlock(&bfad_mutex);
bfad_pci_uninit(pdev, bfad);
out_pci_init_failure:
kfree(bfad->trcmod);
out_alloc_trace_failure:
kfree(bfad);
out:
return error;
}
