android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[SCSI] lpfc 8.3.28: Miscellaneous fixes in sysfs and mgmt interfaces

Browse Source 
Miscellaneous fixes in sysfs and mgmt interfaces:

- Added SLI4 INTF_TYPE and SLI_FAMILY as sub-field to the fwrev sysfs
  attribute (CR 124103)
- Added a sysfs attribute "protocol" to report SLI4 port link protocol
  type (CR 124102)
- Increment mix-and-match minor number by 1 for added "protocol" sysfs
  attribute. (124102)
- Move the link speed check into the generic sli3/sli4 code
  path. (CR 124185, 124122)
- Deleted check for inExtWLen (CR 122523)
- Add the word "offline" to message 2889 (CR 124385)
- Conditionalize the firmware upgrade/downgrade so that it is only
  attempted for SLI4 type 2 boards (CR 124406)
- Return an error if the mbox sysfs is called. (CR 124210)
- When port_state is less than LPFC_VPORT_READY, report
  FC_PORTSTATE_BYPASSED (CR 120018)
- Added driver support for performing persistent linkdown based on
  configure region 23 (CR 124534)
- Added restore state and error log when sysfs board_mode attribute
  access failed (CR 124158)
- Added support for SLI4_CONFIG non-embedded COMN_GET_CNTL_ADDL_ATTR
  pass-through (CR 124466)
- Rejecting un-supported multi-buffer mailbox commands (CR 124771)
- Byte swap the extended data request and response data for extended
  mailbox data (CR 125081)

Signed-off-by: Alex Iannicelli <alex.iannicelli@emulex.com>
Signed-off-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
This commit is contained in:
James Smart 2011-12-13 13:20:45 -05:00 committed by James Bottomley
parent 2cb6fc8c01
commit 026abb87a5
9 changed files with 356 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
drivers/scsi/lpfc/lpfc.h
View File

@ -247,18 +247,6 @@ struct lpfc_stats {
uint32_t fcpLocalErr; uint32_t fcpLocalErr;
}; };
enum sysfs_mbox_state {
SMBOX_IDLE,
SMBOX_WRITING,
SMBOX_READING
};
struct lpfc_sysfs_mbox {
enum sysfs_mbox_state state;
size_t offset;
struct lpfcMboxq * mbox;
};
struct lpfc_hba; struct lpfc_hba;
@ -783,8 +771,6 @@ struct lpfc_hba {
uint64_t bg_apptag_err_cnt; uint64_t bg_apptag_err_cnt;
uint64_t bg_reftag_err_cnt; uint64_t bg_reftag_err_cnt;
struct lpfc_sysfs_mbox sysfs_mbox;
/* fastpath list. */ /* fastpath list. */
spinlock_t scsi_buf_list_lock; spinlock_t scsi_buf_list_lock;
struct list_head lpfc_scsi_buf_list; struct list_head lpfc_scsi_buf_list;

413
drivers/scsi/lpfc/lpfc_attr.c
View File

@ -351,10 +351,23 @@ lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
struct Scsi_Host *shost = class_to_shost(dev); struct Scsi_Host *shost = class_to_shost(dev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
uint32_t if_type;
uint8_t sli_family;
char fwrev[32]; char fwrev[32];
int len;
lpfc_decode_firmware_rev(phba, fwrev, 1); lpfc_decode_firmware_rev(phba, fwrev, 1);
return snprintf(buf, PAGE_SIZE, "%s, sli-%d\n", fwrev, phba->sli_rev); if_type = phba->sli4_hba.pc_sli4_params.if_type;
sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
if (phba->sli_rev < LPFC_SLI_REV4)
len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
fwrev, phba->sli_rev);
else
len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
fwrev, phba->sli_rev, if_type, sli_family);
return len;
} }
/** /**
@ -487,6 +500,34 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
return len; return len;
} }
/**
* lpfc_sli4_protocol_show - Return the fip mode of the HBA
* @dev: class unused variable.
* @attr: device attribute, not used.
* @buf: on return contains the module description text.
*
* Returns: size of formatted string.
**/
static ssize_t
lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct Scsi_Host *shost = class_to_shost(dev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba;
if (phba->sli_rev < LPFC_SLI_REV4)
return snprintf(buf, PAGE_SIZE, "fc\n");
if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
return snprintf(buf, PAGE_SIZE, "fcoe\n");
if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
return snprintf(buf, PAGE_SIZE, "fc\n");
}
return snprintf(buf, PAGE_SIZE, "unknown\n");
}
/** /**
* lpfc_link_state_store - Transition the link_state on an HBA port * lpfc_link_state_store - Transition the link_state on an HBA port
* @dev: class device that is converted into a Scsi_host. * @dev: class device that is converted into a Scsi_host.
@ -773,7 +814,12 @@ lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
* the readyness after performing a firmware reset. * the readyness after performing a firmware reset.
* *
* Returns: * Returns:
* zero for success * zero for success, -EPERM when port does not have privilage to perform the
* reset, -EIO when port timeout from recovering from the reset.
*
* Note:
* As the caller will interpret the return code by value, be careful in making
* change or addition to return codes.
**/ **/
int int
lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba) lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
@ -826,9 +872,11 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
{ {
struct completion online_compl; struct completion online_compl;
struct pci_dev *pdev = phba->pcidev; struct pci_dev *pdev = phba->pcidev;
uint32_t before_fc_flag;
uint32_t sriov_nr_virtfn;
uint32_t reg_val; uint32_t reg_val;
int status = 0; int status = 0, rc = 0;
int rc; int job_posted = 1, sriov_err;
if (!phba->cfg_enable_hba_reset) if (!phba->cfg_enable_hba_reset)
return -EACCES; return -EACCES;
@ -838,6 +886,10 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
LPFC_SLI_INTF_IF_TYPE_2)) LPFC_SLI_INTF_IF_TYPE_2))
return -EPERM; return -EPERM;
/* Keep state if we need to restore back */
before_fc_flag = phba->pport->fc_flag;
sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
/* Disable SR-IOV virtual functions if enabled */ /* Disable SR-IOV virtual functions if enabled */
if (phba->cfg_sriov_nr_virtfn) { if (phba->cfg_sriov_nr_virtfn) {
pci_disable_sriov(pdev); pci_disable_sriov(pdev);
@ -869,21 +921,44 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
/* delay driver action following IF_TYPE_2 reset */ /* delay driver action following IF_TYPE_2 reset */
rc = lpfc_sli4_pdev_status_reg_wait(phba); rc = lpfc_sli4_pdev_status_reg_wait(phba);
if (rc) if (rc == -EPERM) {
/* no privilage for reset, restore if needed */
if (before_fc_flag & FC_OFFLINE_MODE)
goto out;
} else if (rc == -EIO) {
/* reset failed, there is nothing more we can do */
return rc; return rc;
}
/* keep the original port state */
if (before_fc_flag & FC_OFFLINE_MODE)
goto out;
init_completion(&online_compl); init_completion(&online_compl);
rc = lpfc_workq_post_event(phba, &status, &online_compl, job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
LPFC_EVT_ONLINE); LPFC_EVT_ONLINE);
if (rc == 0) if (!job_posted)
return -ENOMEM; goto out;
wait_for_completion(&online_compl); wait_for_completion(&online_compl);
if (status != 0) out:
return -EIO; /* in any case, restore the virtual functions enabled as before */
if (sriov_nr_virtfn) {
sriov_err =
lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
if (!sriov_err)
phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
}
return 0; /* return proper error code */
if (!rc) {
if (!job_posted)
rc = -ENOMEM;
else if (status)
rc = -EIO;
}
return rc;
} }
/** /**
@ -955,33 +1030,38 @@ lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata; struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba; struct lpfc_hba *phba = vport->phba;
struct completion online_compl; struct completion online_compl;
int status=0; char *board_mode_str = NULL;
int status = 0;
int rc; int rc;
if (!phba->cfg_enable_hba_reset) if (!phba->cfg_enable_hba_reset) {
return -EACCES; status = -EACCES;
goto board_mode_out;
}
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
"3050 lpfc_board_mode set to %s\n", buf); "3050 lpfc_board_mode set to %s\n", buf);
init_completion(&online_compl); init_completion(&online_compl);
if(strncmp(buf, "online", sizeof("online") - 1) == 0) { if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
rc = lpfc_workq_post_event(phba, &status, &online_compl, rc = lpfc_workq_post_event(phba, &status, &online_compl,
LPFC_EVT_ONLINE); LPFC_EVT_ONLINE);
if (rc == 0) if (rc == 0) {
return -ENOMEM; status = -ENOMEM;
goto board_mode_out;
}
wait_for_completion(&online_compl); wait_for_completion(&online_compl);
} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0) } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE); status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0) else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
if (phba->sli_rev == LPFC_SLI_REV4) if (phba->sli_rev == LPFC_SLI_REV4)
return -EINVAL; status = -EINVAL;
else else
status = lpfc_do_offline(phba, LPFC_EVT_WARM_START); status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
else if (strncmp(buf, "error", sizeof("error") - 1) == 0) else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
if (phba->sli_rev == LPFC_SLI_REV4) if (phba->sli_rev == LPFC_SLI_REV4)
return -EINVAL; status = -EINVAL;
else else
status = lpfc_do_offline(phba, LPFC_EVT_KILL); status = lpfc_do_offline(phba, LPFC_EVT_KILL);
else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0) else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
@ -991,12 +1071,21 @@ lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0) else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET); status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
else else
return -EINVAL; status = -EINVAL;
board_mode_out:
if (!status) if (!status)
return strlen(buf); return strlen(buf);
else else {
board_mode_str = strchr(buf, '\n');
if (board_mode_str)
*board_mode_str = '\0';
lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
"3097 Failed \"%s\", status(%d), "
"fc_flag(x%x)\n",
buf, status, phba->pport->fc_flag);
return status; return status;
}
} }
/** /**
@ -1942,6 +2031,7 @@ static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL); static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO, static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
lpfc_sriov_hw_max_virtfn_show, NULL); lpfc_sriov_hw_max_virtfn_show, NULL);
static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
static char *lpfc_soft_wwn_key = "C99G71SL8032A"; static char *lpfc_soft_wwn_key = "C99G71SL8032A";
@ -3830,6 +3920,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
&dev_attr_lpfc_fips_rev, &dev_attr_lpfc_fips_rev,
&dev_attr_lpfc_dss, &dev_attr_lpfc_dss,
&dev_attr_lpfc_sriov_hw_max_virtfn, &dev_attr_lpfc_sriov_hw_max_virtfn,
&dev_attr_protocol,
NULL, NULL,
}; };
@ -3987,23 +4078,6 @@ static struct bin_attribute sysfs_ctlreg_attr = {
.write = sysfs_ctlreg_write, .write = sysfs_ctlreg_write,
}; };
/**
* sysfs_mbox_idle - frees the sysfs mailbox
* @phba: lpfc_hba pointer
**/
static void
sysfs_mbox_idle(struct lpfc_hba *phba)
{
phba->sysfs_mbox.state = SMBOX_IDLE;
phba->sysfs_mbox.offset = 0;
if (phba->sysfs_mbox.mbox) {
mempool_free(phba->sysfs_mbox.mbox,
phba->mbox_mem_pool);
phba->sysfs_mbox.mbox = NULL;
}
}
/** /**
* sysfs_mbox_write - Write method for writing information via mbox * sysfs_mbox_write - Write method for writing information via mbox
* @filp: open sysfs file * @filp: open sysfs file
@ -4014,71 +4088,18 @@ sysfs_mbox_idle(struct lpfc_hba *phba)
* @count: bytes to transfer. * @count: bytes to transfer.
* *
* Description: * Description:
* Accessed via /sys/class/scsi_host/hostxxx/mbox. * Deprecated function. All mailbox access from user space is performed via the
* Uses the sysfs mbox to send buf contents to the adapter. * bsg interface.
* *
* Returns: * Returns:
* -ERANGE off and count combo out of range * -EPERM operation not permitted
* -EINVAL off, count or buff address invalid
* zero if count is zero
* -EPERM adapter is offline
* -ENOMEM failed to allocate memory for the mail box
* -EAGAIN offset, state or mbox is NULL
* count number of bytes transferred
**/ **/
static ssize_t static ssize_t
sysfs_mbox_write(struct file *filp, struct kobject *kobj, sysfs_mbox_write(struct file *filp, struct kobject *kobj,
struct bin_attribute *bin_attr, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
struct device *dev = container_of(kobj, struct device, kobj); return -EPERM;
struct Scsi_Host *shost = class_to_shost(dev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba;
struct lpfcMboxq *mbox = NULL;
if ((count + off) > MAILBOX_CMD_SIZE)
return -ERANGE;
if (off % 4 || count % 4 || (unsigned long)buf % 4)
return -EINVAL;
if (count == 0)
return 0;
if (off == 0) {
mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
if (!mbox)
return -ENOMEM;
memset(mbox, 0, sizeof (LPFC_MBOXQ_t));
}
spin_lock_irq(&phba->hbalock);
if (off == 0) {
if (phba->sysfs_mbox.mbox)
mempool_free(mbox, phba->mbox_mem_pool);
else
phba->sysfs_mbox.mbox = mbox;
phba->sysfs_mbox.state = SMBOX_WRITING;
} else {
if (phba->sysfs_mbox.state != SMBOX_WRITING ||
phba->sysfs_mbox.offset != off ||
phba->sysfs_mbox.mbox == NULL) {
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EAGAIN;
}
}
memcpy((uint8_t *) &phba->sysfs_mbox.mbox->u.mb + off,
buf, count);
phba->sysfs_mbox.offset = off + count;
spin_unlock_irq(&phba->hbalock);
return count;
} }
/** /**
@ -4091,201 +4112,18 @@ sysfs_mbox_write(struct file *filp, struct kobject *kobj,
* @count: bytes to transfer. * @count: bytes to transfer.
* *
* Description: * Description:
* Accessed via /sys/class/scsi_host/hostxxx/mbox. * Deprecated function. All mailbox access from user space is performed via the
* Uses the sysfs mbox to receive data from to the adapter. * bsg interface.
* *
* Returns: * Returns:
* -ERANGE off greater than mailbox command size * -EPERM operation not permitted
* -EINVAL off, count or buff address invalid
* zero if off and count are zero
* -EACCES adapter over temp
* -EPERM garbage can value to catch a multitude of errors
* -EAGAIN management IO not permitted, state or off error
* -ETIME mailbox timeout
* -ENODEV mailbox error
* count number of bytes transferred
**/ **/
static ssize_t static ssize_t
sysfs_mbox_read(struct file *filp, struct kobject *kobj, sysfs_mbox_read(struct file *filp, struct kobject *kobj,
struct bin_attribute *bin_attr, struct bin_attribute *bin_attr,
char *buf, loff_t off, size_t count) char *buf, loff_t off, size_t count)
{ {
struct device *dev = container_of(kobj, struct device, kobj); return -EPERM;
struct Scsi_Host *shost = class_to_shost(dev);
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
struct lpfc_hba *phba = vport->phba;
LPFC_MBOXQ_t *mboxq;
MAILBOX_t *pmb;
uint32_t mbox_tmo;
int rc;
if (off > MAILBOX_CMD_SIZE)
return -ERANGE;
if ((count + off) > MAILBOX_CMD_SIZE)
count = MAILBOX_CMD_SIZE - off;
if (off % 4 || count % 4 || (unsigned long)buf % 4)
return -EINVAL;
if (off && count == 0)
return 0;
spin_lock_irq(&phba->hbalock);
if (phba->over_temp_state == HBA_OVER_TEMP) {
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EACCES;
}
if (off == 0 &&
phba->sysfs_mbox.state == SMBOX_WRITING &&
phba->sysfs_mbox.offset >= 2 * sizeof(uint32_t)) {
mboxq = (LPFC_MBOXQ_t *)&phba->sysfs_mbox.mbox;
pmb = &mboxq->u.mb;
switch (pmb->mbxCommand) {
/* Offline only */
case MBX_INIT_LINK:
case MBX_DOWN_LINK:
case MBX_CONFIG_LINK:
case MBX_CONFIG_RING:
case MBX_RESET_RING:
case MBX_UNREG_LOGIN:
case MBX_CLEAR_LA:
case MBX_DUMP_CONTEXT:
case MBX_RUN_DIAGS:
case MBX_RESTART:
case MBX_SET_MASK:
case MBX_SET_DEBUG:
if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
printk(KERN_WARNING "mbox_read:Command 0x%x "
"is illegal in on-line state\n",
pmb->mbxCommand);
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EPERM;
}
case MBX_WRITE_NV:
case MBX_WRITE_VPARMS:
case MBX_LOAD_SM:
case MBX_READ_NV:
case MBX_READ_CONFIG:
case MBX_READ_RCONFIG:
case MBX_READ_STATUS:
case MBX_READ_XRI:
case MBX_READ_REV:
case MBX_READ_LNK_STAT:
case MBX_DUMP_MEMORY:
case MBX_DOWN_LOAD:
case MBX_UPDATE_CFG:
case MBX_KILL_BOARD:
case MBX_LOAD_AREA:
case MBX_LOAD_EXP_ROM:
case MBX_BEACON:
case MBX_DEL_LD_ENTRY:
case MBX_SET_VARIABLE:
case MBX_WRITE_WWN:
case MBX_PORT_CAPABILITIES:
case MBX_PORT_IOV_CONTROL:
break;
case MBX_SECURITY_MGMT:
case MBX_AUTH_PORT:
if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
printk(KERN_WARNING "mbox_read:Command 0x%x "
"is not permitted\n", pmb->mbxCommand);
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EPERM;
}
break;
case MBX_READ_SPARM64:
case MBX_READ_TOPOLOGY:
case MBX_REG_LOGIN:
case MBX_REG_LOGIN64:
case MBX_CONFIG_PORT:
case MBX_RUN_BIU_DIAG:
printk(KERN_WARNING "mbox_read: Illegal Command 0x%x\n",
pmb->mbxCommand);
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EPERM;
default:
printk(KERN_WARNING "mbox_read: Unknown Command 0x%x\n",
pmb->mbxCommand);
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EPERM;
}
/* If HBA encountered an error attention, allow only DUMP
* or RESTART mailbox commands until the HBA is restarted.
*/
if (phba->pport->stopped &&
pmb->mbxCommand != MBX_DUMP_MEMORY &&
pmb->mbxCommand != MBX_RESTART &&
pmb->mbxCommand != MBX_WRITE_VPARMS &&
pmb->mbxCommand != MBX_WRITE_WWN)
lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
"1259 mbox: Issued mailbox cmd "
"0x%x while in stopped state.\n",
pmb->mbxCommand);
phba->sysfs_mbox.mbox->vport = vport;
/* Don't allow mailbox commands to be sent when blocked
* or when in the middle of discovery
*/
if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EAGAIN;
}
if ((vport->fc_flag & FC_OFFLINE_MODE) ||
(!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
spin_unlock_irq(&phba->hbalock);
rc = lpfc_sli_issue_mbox (phba,
phba->sysfs_mbox.mbox,
MBX_POLL);
spin_lock_irq(&phba->hbalock);
} else {
spin_unlock_irq(&phba->hbalock);
mbox_tmo = lpfc_mbox_tmo_val(phba, mboxq);
rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
spin_lock_irq(&phba->hbalock);
}
if (rc != MBX_SUCCESS) {
if (rc == MBX_TIMEOUT) {
phba->sysfs_mbox.mbox = NULL;
}
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
}
phba->sysfs_mbox.state = SMBOX_READING;
}
else if (phba->sysfs_mbox.offset != off ||
phba->sysfs_mbox.state != SMBOX_READING) {
printk(KERN_WARNING "mbox_read: Bad State\n");
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return -EAGAIN;
}
memcpy(buf, (uint8_t *) &pmb + off, count);
phba->sysfs_mbox.offset = off + count;
if (phba->sysfs_mbox.offset == MAILBOX_CMD_SIZE)
sysfs_mbox_idle(phba);
spin_unlock_irq(&phba->hbalock);
return count;
} }
static struct bin_attribute sysfs_mbox_attr = { static struct bin_attribute sysfs_mbox_attr = {
@ -4429,8 +4267,13 @@ lpfc_get_host_port_state(struct Scsi_Host *shost)
case LPFC_LINK_UP: case LPFC_LINK_UP:
case LPFC_CLEAR_LA: case LPFC_CLEAR_LA:
case LPFC_HBA_READY: case LPFC_HBA_READY:
/* Links up, beyond this port_type reports state */ /* Links up, reports port state accordingly */
fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; if (vport->port_state < LPFC_VPORT_READY)
fc_host_port_state(shost) =
FC_PORTSTATE_BYPASSED;
else
fc_host_port_state(shost) =
FC_PORTSTATE_ONLINE;
break; break;
case LPFC_HBA_ERROR: case LPFC_HBA_ERROR:
fc_host_port_state(shost) = FC_PORTSTATE_ERROR; fc_host_port_state(shost) = FC_PORTSTATE_ERROR;

74
drivers/scsi/lpfc/lpfc_bsg.c
View File

@ -3140,6 +3140,9 @@ lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
unsigned long flags; unsigned long flags;
uint32_t size; uint32_t size;
int rc = 0; int rc = 0;
struct lpfc_dmabuf *dmabuf;
struct lpfc_sli_config_mbox *sli_cfg_mbx;
uint8_t *pmbx;
spin_lock_irqsave(&phba->ct_ev_lock, flags); spin_lock_irqsave(&phba->ct_ev_lock, flags);
dd_data = pmboxq->context1; dd_data = pmboxq->context1;
@ -3156,7 +3159,19 @@ lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
*/ */
pmb = (uint8_t *)&pmboxq->u.mb; pmb = (uint8_t *)&pmboxq->u.mb;
pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb; pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
/* Copy the byte swapped response mailbox back to the user */
memcpy(pmb_buf, pmb, sizeof(MAILBOX_t)); memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
/* if there is any non-embedded extended data copy that too */
dmabuf = phba->mbox_ext_buf_ctx.mbx_dmabuf;
sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
if (!bsg_bf_get(lpfc_mbox_hdr_emb,
&sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
pmbx = (uint8_t *)dmabuf->virt;
/* byte swap the extended data following the mailbox command */
lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
&pmbx[sizeof(MAILBOX_t)],
sli_cfg_mbx->un.sli_config_emb0_subsys.mse[0].buf_len);
}
job = dd_data->context_un.mbox.set_job; job = dd_data->context_un.mbox.set_job;
if (job) { if (job) {
@ -3519,6 +3534,18 @@ lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
/* state change */ /* state change */
phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT; phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
/*
* Non-embedded mailbox subcommand data gets byte swapped here because
* the lower level driver code only does the first 64 mailbox words.
*/
if ((!bsg_bf_get(lpfc_mbox_hdr_emb,
&sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) &&
(nemb_tp == nemb_mse))
lpfc_sli_pcimem_bcopy(&pmbx[sizeof(MAILBOX_t)],
&pmbx[sizeof(MAILBOX_t)],
sli_cfg_mbx->un.sli_config_emb0_subsys.
mse[0].buf_len);
rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT); rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) { if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC, lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
@ -3575,7 +3602,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
&sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr); &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) { if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC, lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
"2953 Handled SLI_CONFIG(mse) wr, " "2953 Failed SLI_CONFIG(mse) wr, "
"ext_buf_cnt(%d) out of range(%d)\n", "ext_buf_cnt(%d) out of range(%d)\n",
ext_buf_cnt, ext_buf_cnt,
LPFC_MBX_SLI_CONFIG_MAX_MSE); LPFC_MBX_SLI_CONFIG_MAX_MSE);
@ -3593,7 +3620,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count; ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) { if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC, lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
"2954 Handled SLI_CONFIG(hbd) wr, " "2954 Failed SLI_CONFIG(hbd) wr, "
"ext_buf_cnt(%d) out of range(%d)\n", "ext_buf_cnt(%d) out of range(%d)\n",
ext_buf_cnt, ext_buf_cnt,
LPFC_MBX_SLI_CONFIG_MAX_HBD); LPFC_MBX_SLI_CONFIG_MAX_HBD);
@ -3687,6 +3714,7 @@ lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
"2956 Failed to issue SLI_CONFIG ext-buffer " "2956 Failed to issue SLI_CONFIG ext-buffer "
"maibox command, rc:x%x\n", rc); "maibox command, rc:x%x\n", rc);
rc = -EPIPE; rc = -EPIPE;
goto job_error;
} }
/* wait for additoinal external buffers */ /* wait for additoinal external buffers */
@ -3721,7 +3749,7 @@ lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
uint32_t opcode; uint32_t opcode;
int rc = SLI_CONFIG_NOT_HANDLED; int rc = SLI_CONFIG_NOT_HANDLED;
/* state change */ /* state change on new multi-buffer pass-through mailbox command */
phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_HOST; phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_HOST;
sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt; sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
@ -3752,18 +3780,36 @@ lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
break; break;
default: default:
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC, lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
"2959 Not handled SLI_CONFIG " "2959 Reject SLI_CONFIG "
"subsys_fcoe, opcode:x%x\n", "subsys_fcoe, opcode:x%x\n",
opcode); opcode);
rc = SLI_CONFIG_NOT_HANDLED; rc = -EPERM;
break;
}
} else if (subsys == SLI_CONFIG_SUBSYS_COMN) {
switch (opcode) {
case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
"3106 Handled SLI_CONFIG "
"subsys_fcoe, opcode:x%x\n",
opcode);
rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
nemb_mse, dmabuf);
break;
default:
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
"3107 Reject SLI_CONFIG "
"subsys_fcoe, opcode:x%x\n",
opcode);
rc = -EPERM;
break; break;
} }
} else { } else {
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC, lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
"2977 Handled SLI_CONFIG " "2977 Reject SLI_CONFIG "
"subsys:x%d, opcode:x%x\n", "subsys:x%d, opcode:x%x\n",
subsys, opcode); subsys, opcode);
rc = SLI_CONFIG_NOT_HANDLED; rc = -EPERM;
} }
} else { } else {
subsys = bsg_bf_get(lpfc_emb1_subcmnd_subsys, subsys = bsg_bf_get(lpfc_emb1_subcmnd_subsys,
@ -3799,12 +3845,17 @@ lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
} }
} else { } else {
lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC, lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
"2978 Handled SLI_CONFIG " "2978 Not handled SLI_CONFIG "
"subsys:x%d, opcode:x%x\n", "subsys:x%d, opcode:x%x\n",
subsys, opcode); subsys, opcode);
rc = SLI_CONFIG_NOT_HANDLED; rc = SLI_CONFIG_NOT_HANDLED;
} }
} }
/* state reset on not handled new multi-buffer mailbox command */
if (rc != SLI_CONFIG_HANDLED)
phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
return rc; return rc;
} }
@ -4262,11 +4313,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
/* extended mailbox commands will need an extended buffer */ /* extended mailbox commands will need an extended buffer */
if (mbox_req->inExtWLen || mbox_req->outExtWLen) { if (mbox_req->inExtWLen || mbox_req->outExtWLen) {
/* any data for the device? */ from = pmbx;
if (mbox_req->inExtWLen) { ext = from + sizeof(MAILBOX_t);
from = pmbx;
ext = from + sizeof(MAILBOX_t);
}
pmboxq->context2 = ext; pmboxq->context2 = ext;
pmboxq->in_ext_byte_len = pmboxq->in_ext_byte_len =
mbox_req->inExtWLen * sizeof(uint32_t); mbox_req->inExtWLen * sizeof(uint32_t);

3
drivers/scsi/lpfc/lpfc_bsg.h
View File

@ -96,7 +96,7 @@ struct get_mgmt_rev {
}; };
#define MANAGEMENT_MAJOR_REV 1 #define MANAGEMENT_MAJOR_REV 1
#define MANAGEMENT_MINOR_REV 0 #define MANAGEMENT_MINOR_REV 1
/* the MgmtRevInfo structure */ /* the MgmtRevInfo structure */
struct MgmtRevInfo { struct MgmtRevInfo {
@ -248,6 +248,7 @@ struct lpfc_sli_config_emb1_subsys {
#define COMN_OPCODE_WRITE_OBJECT 0xAC #define COMN_OPCODE_WRITE_OBJECT 0xAC
#define COMN_OPCODE_READ_OBJECT_LIST 0xAD #define COMN_OPCODE_READ_OBJECT_LIST 0xAD
#define COMN_OPCODE_DELETE_OBJECT 0xAE #define COMN_OPCODE_DELETE_OBJECT 0xAE
#define COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES 0x79
uint32_t timeout; uint32_t timeout;
uint32_t request_length; uint32_t request_length;
uint32_t word9; uint32_t word9;

2
drivers/scsi/lpfc/lpfc_crtn.h
View File

@ -26,7 +26,7 @@ void lpfc_sli_read_link_ste(struct lpfc_hba *);
void lpfc_dump_mem(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t, uint16_t); void lpfc_dump_mem(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t, uint16_t);
void lpfc_dump_wakeup_param(struct lpfc_hba *, LPFC_MBOXQ_t *); void lpfc_dump_wakeup_param(struct lpfc_hba *, LPFC_MBOXQ_t *);
int lpfc_dump_static_vport(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t); int lpfc_dump_static_vport(struct lpfc_hba *, LPFC_MBOXQ_t *, uint16_t);
int lpfc_dump_fcoe_param(struct lpfc_hba *, struct lpfcMboxq *); int lpfc_sli4_dump_cfg_rg23(struct lpfc_hba *, struct lpfcMboxq *);
void lpfc_read_nv(struct lpfc_hba *, LPFC_MBOXQ_t *); void lpfc_read_nv(struct lpfc_hba *, LPFC_MBOXQ_t *);
void lpfc_config_async(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t); void lpfc_config_async(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t);

2
drivers/scsi/lpfc/lpfc_hw4.h
View File

@ -2104,6 +2104,8 @@ struct lpfc_mbx_read_config {
#define lpfc_mbx_rd_conf_lnk_type_SHIFT 6 #define lpfc_mbx_rd_conf_lnk_type_SHIFT 6
#define lpfc_mbx_rd_conf_lnk_type_MASK 0x00000003 #define lpfc_mbx_rd_conf_lnk_type_MASK 0x00000003
#define lpfc_mbx_rd_conf_lnk_type_WORD word2 #define lpfc_mbx_rd_conf_lnk_type_WORD word2
#define LPFC_LNK_TYPE_GE 0
#define LPFC_LNK_TYPE_FC 1
#define lpfc_mbx_rd_conf_lnk_ldv_SHIFT 8 #define lpfc_mbx_rd_conf_lnk_ldv_SHIFT 8
#define lpfc_mbx_rd_conf_lnk_ldv_MASK 0x00000001 #define lpfc_mbx_rd_conf_lnk_ldv_MASK 0x00000001
#define lpfc_mbx_rd_conf_lnk_ldv_WORD word2 #define lpfc_mbx_rd_conf_lnk_ldv_WORD word2

84
drivers/scsi/lpfc/lpfc_init.c
View File

@ -475,27 +475,6 @@ lpfc_config_port_post(struct lpfc_hba *phba)
/* Get the default values for Model Name and Description */ /* Get the default values for Model Name and Description */
lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc); lpfc_get_hba_model_desc(phba, phba->ModelName, phba->ModelDesc);
if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_16G)
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G)
&& !(phba->lmt & LMT_1Gb))
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G)
&& !(phba->lmt & LMT_2Gb))
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G)
&& !(phba->lmt & LMT_4Gb))
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G)
&& !(phba->lmt & LMT_8Gb))
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G)
&& !(phba->lmt & LMT_10Gb))
|| ((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G)
&& !(phba->lmt & LMT_16Gb))) {
/* Reset link speed to auto */
lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
"1302 Invalid speed for this board: "
"Reset link speed to auto: x%x\n",
phba->cfg_link_speed);
phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
}
phba->link_state = LPFC_LINK_DOWN; phba->link_state = LPFC_LINK_DOWN;
/* Only process IOCBs on ELS ring till hba_state is READY */ /* Only process IOCBs on ELS ring till hba_state is READY */
@ -585,28 +564,10 @@ lpfc_config_port_post(struct lpfc_hba *phba)
return -EIO; return -EIO;
} }
} else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) { } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
lpfc_init_link(phba, pmb, phba->cfg_topology, mempool_free(pmb, phba->mbox_mem_pool);
phba->cfg_link_speed); rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; if (rc)
lpfc_set_loopback_flag(phba); return rc;
rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
if (rc != MBX_SUCCESS) {
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
"0454 Adapter failed to init, mbxCmd x%x "
"INIT_LINK, mbxStatus x%x\n",
mb->mbxCommand, mb->mbxStatus);
/* Clear all interrupt enable conditions */
writel(0, phba->HCregaddr);
readl(phba->HCregaddr); /* flush */
/* Clear all pending interrupts */
writel(0xffffffff, phba->HAregaddr);
readl(phba->HAregaddr); /* flush */
phba->link_state = LPFC_HBA_ERROR;
if (rc != MBX_BUSY)
mempool_free(pmb, phba->mbox_mem_pool);
return -EIO;
}
} }
/* MBOX buffer will be freed in mbox compl */ /* MBOX buffer will be freed in mbox compl */
pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
@ -681,6 +642,26 @@ lpfc_hba_init_link(struct lpfc_hba *phba, uint32_t flag)
mb = &pmb->u.mb; mb = &pmb->u.mb;
pmb->vport = vport; pmb->vport = vport;
if ((phba->cfg_link_speed > LPFC_USER_LINK_SPEED_MAX) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_1G) &&
!(phba->lmt & LMT_1Gb)) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_2G) &&
!(phba->lmt & LMT_2Gb)) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_4G) &&
!(phba->lmt & LMT_4Gb)) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_8G) &&
!(phba->lmt & LMT_8Gb)) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_10G) &&
!(phba->lmt & LMT_10Gb)) ||
((phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G) &&
!(phba->lmt & LMT_16Gb))) {
/* Reset link speed to auto */
lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
"1302 Invalid speed for this board:%d "
"Reset link speed to auto.\n",
phba->cfg_link_speed);
phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
}
lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed); lpfc_init_link(phba, pmb, phba->cfg_topology, phba->cfg_link_speed);
pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
lpfc_set_loopback_flag(phba); lpfc_set_loopback_flag(phba);
@ -1474,7 +1455,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba)
/* TODO: Register for Overtemp async events. */ /* TODO: Register for Overtemp async events. */
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
"2889 Port Overtemperature event, " "2889 Port Overtemperature event, "
"taking port\n"); "taking port offline\n");
spin_lock_irq(&phba->hbalock); spin_lock_irq(&phba->hbalock);
phba->over_temp_state = HBA_OVER_TEMP; phba->over_temp_state = HBA_OVER_TEMP;
spin_unlock_irq(&phba->hbalock); spin_unlock_irq(&phba->hbalock);
@ -9198,12 +9179,15 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
/* Perform post initialization setup */ /* Perform post initialization setup */
lpfc_post_init_setup(phba); lpfc_post_init_setup(phba);
/* check for firmware upgrade or downgrade */ /* check for firmware upgrade or downgrade (if_type 2 only) */
snprintf(file_name, 16, "%s.grp", phba->ModelName); if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
error = request_firmware(&fw, file_name, &phba->pcidev->dev); LPFC_SLI_INTF_IF_TYPE_2) {
if (!error) { snprintf(file_name, 16, "%s.grp", phba->ModelName);
lpfc_write_firmware(phba, fw); error = request_firmware(&fw, file_name, &phba->pcidev->dev);
release_firmware(fw); if (!error) {
lpfc_write_firmware(phba, fw);
release_firmware(fw);
}
} }
/* Check if there are static vports to be created. */ /* Check if there are static vports to be created. */

13
drivers/scsi/lpfc/lpfc_mbox.c
View File

@ -2175,16 +2175,15 @@ lpfc_unreg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
} }
/** /**
* lpfc_dump_fcoe_param - Dump config region 23 to get FCoe parameters. * lpfc_sli4_dump_cfg_rg23 - Dump sli4 port config region 23
* @phba: pointer to the hba structure containing. * @phba: pointer to the hba structure containing.
* @mbox: pointer to lpfc mbox command to initialize. * @mbox: pointer to lpfc mbox command to initialize.
* *
* This function create a SLI4 dump mailbox command to dump FCoE * This function create a SLI4 dump mailbox command to dump configure
* parameters stored in region 23. * region 23.
**/ **/
int int
lpfc_dump_fcoe_param(struct lpfc_hba *phba, lpfc_sli4_dump_cfg_rg23(struct lpfc_hba *phba, struct lpfcMboxq *mbox)
struct lpfcMboxq *mbox)
{ {
struct lpfc_dmabuf *mp = NULL; struct lpfc_dmabuf *mp = NULL;
MAILBOX_t *mb; MAILBOX_t *mb;
@ -2198,9 +2197,9 @@ lpfc_dump_fcoe_param(struct lpfc_hba *phba,
if (!mp || !mp->virt) { if (!mp || !mp->virt) {
kfree(mp); kfree(mp);
/* dump_fcoe_param failed to allocate memory */ /* dump config region 23 failed to allocate memory */
lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX, lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
"2569 lpfc_dump_fcoe_param: memory" "2569 lpfc dump config region 23: memory"
" allocation failed\n"); " allocation failed\n");
return 1; return 1;
} }

149
drivers/scsi/lpfc/lpfc_sli.c
View File

@ -4566,7 +4566,7 @@ lpfc_sli4_read_fcoe_params(struct lpfc_hba *phba,
phba->fc_map[2] = LPFC_FCOE_FCF_MAP2; phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
mqe = &mboxq->u.mqe; mqe = &mboxq->u.mqe;
if (lpfc_dump_fcoe_param(phba, mboxq)) if (lpfc_sli4_dump_cfg_rg23(phba, mboxq))
return -ENOMEM; return -ENOMEM;
mp = (struct lpfc_dmabuf *) mboxq->context1; mp = (struct lpfc_dmabuf *) mboxq->context1;
@ -6205,7 +6205,11 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
rc = 0; rc = 0;
phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi, phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi,
&mboxq->u.mqe.un.reg_fcfi); &mboxq->u.mqe.un.reg_fcfi);
/* Check if the port is configured to be disabled */
lpfc_sli_read_link_ste(phba);
} }
/* /*
* The port is ready, set the host's link state to LINK_DOWN * The port is ready, set the host's link state to LINK_DOWN
* in preparation for link interrupts. * in preparation for link interrupts.
@ -6213,7 +6217,19 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
spin_lock_irq(&phba->hbalock); spin_lock_irq(&phba->hbalock);
phba->link_state = LPFC_LINK_DOWN; phba->link_state = LPFC_LINK_DOWN;
spin_unlock_irq(&phba->hbalock); spin_unlock_irq(&phba->hbalock);
if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) { if (!(phba->hba_flag & HBA_FCOE_MODE) &&
(phba->hba_flag & LINK_DISABLED)) {
lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
"3103 Adapter Link is disabled.\n");
lpfc_down_link(phba, mboxq);
rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
if (rc != MBX_SUCCESS) {
lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_SLI,
"3104 Adapter failed to issue "
"DOWN_LINK mbox cmd, rc:x%x\n", rc);
goto out_unset_queue;
}
} else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT); rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
if (rc) if (rc)
goto out_unset_queue; goto out_unset_queue;
@ -15252,45 +15268,42 @@ lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *phba)
} }
/** /**
* lpfc_sli_read_link_ste - Read region 23 to decide if link is disabled. * lpfc_sli_get_config_region23 - Get sli3 port region 23 data.
* @phba: pointer to lpfc hba data structure. * @phba: pointer to lpfc hba data structure.
* @rgn23_data: pointer to configure region 23 data.
* *
* This function read region 23 and parse TLV for port status to * This function gets SLI3 port configure region 23 data through memory dump
* decide if the user disaled the port. If the TLV indicates the * mailbox command. When it successfully retrieves data, the size of the data
* port is disabled, the hba_flag is set accordingly. * will be returned, otherwise, 0 will be returned.
**/ **/
void static uint32_t
lpfc_sli_read_link_ste(struct lpfc_hba *phba) lpfc_sli_get_config_region23(struct lpfc_hba *phba, char *rgn23_data)
{ {
LPFC_MBOXQ_t *pmb = NULL; LPFC_MBOXQ_t *pmb = NULL;
MAILBOX_t *mb; MAILBOX_t *mb;
uint8_t *rgn23_data = NULL; uint32_t offset = 0;
uint32_t offset = 0, data_size, sub_tlv_len, tlv_offset;
int rc; int rc;
if (!rgn23_data)
return 0;
pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
if (!pmb) { if (!pmb) {
lpfc_printf_log(phba, KERN_ERR, LOG_INIT, lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
"2600 lpfc_sli_read_serdes_param failed to" "2600 failed to allocate mailbox memory\n");
" allocate mailbox memory\n"); return 0;
goto out;
} }
mb = &pmb->u.mb; mb = &pmb->u.mb;
/* Get adapter Region 23 data */
rgn23_data = kzalloc(DMP_RGN23_SIZE, GFP_KERNEL);
if (!rgn23_data)
goto out;
do { do {
lpfc_dump_mem(phba, pmb, offset, DMP_REGION_23); lpfc_dump_mem(phba, pmb, offset, DMP_REGION_23);
rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL); rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
if (rc != MBX_SUCCESS) { if (rc != MBX_SUCCESS) {
lpfc_printf_log(phba, KERN_INFO, LOG_INIT, lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
"2601 lpfc_sli_read_link_ste failed to" "2601 failed to read config "
" read config region 23 rc 0x%x Status 0x%x\n", "region 23, rc 0x%x Status 0x%x\n",
rc, mb->mbxStatus); rc, mb->mbxStatus);
mb->un.varDmp.word_cnt = 0; mb->un.varDmp.word_cnt = 0;
} }
/* /*
@ -15303,13 +15316,96 @@ lpfc_sli_read_link_ste(struct lpfc_hba *phba)
mb->un.varDmp.word_cnt = DMP_RGN23_SIZE - offset; mb->un.varDmp.word_cnt = DMP_RGN23_SIZE - offset;
lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET, lpfc_sli_pcimem_bcopy(((uint8_t *)mb) + DMP_RSP_OFFSET,
rgn23_data + offset, rgn23_data + offset,
mb->un.varDmp.word_cnt); mb->un.varDmp.word_cnt);
offset += mb->un.varDmp.word_cnt; offset += mb->un.varDmp.word_cnt;
} while (mb->un.varDmp.word_cnt && offset < DMP_RGN23_SIZE); } while (mb->un.varDmp.word_cnt && offset < DMP_RGN23_SIZE);
data_size = offset; mempool_free(pmb, phba->mbox_mem_pool);
offset = 0; return offset;
}
/**
* lpfc_sli4_get_config_region23 - Get sli4 port region 23 data.
* @phba: pointer to lpfc hba data structure.
* @rgn23_data: pointer to configure region 23 data.
*
* This function gets SLI4 port configure region 23 data through memory dump
* mailbox command. When it successfully retrieves data, the size of the data
* will be returned, otherwise, 0 will be returned.
**/
static uint32_t
lpfc_sli4_get_config_region23(struct lpfc_hba *phba, char *rgn23_data)
{
LPFC_MBOXQ_t *mboxq = NULL;
struct lpfc_dmabuf *mp = NULL;
struct lpfc_mqe *mqe;
uint32_t data_length = 0;
int rc;
if (!rgn23_data)
return 0;
mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
if (!mboxq) {
lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
"3105 failed to allocate mailbox memory\n");
return 0;
}
if (lpfc_sli4_dump_cfg_rg23(phba, mboxq))
goto out;
mqe = &mboxq->u.mqe;
mp = (struct lpfc_dmabuf *) mboxq->context1;
rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
if (rc)
goto out;
data_length = mqe->un.mb_words[5];
if (data_length == 0)
goto out;
if (data_length > DMP_RGN23_SIZE) {
data_length = 0;
goto out;
}
lpfc_sli_pcimem_bcopy((char *)mp->virt, rgn23_data, data_length);
out:
mempool_free(mboxq, phba->mbox_mem_pool);
if (mp) {
lpfc_mbuf_free(phba, mp->virt, mp->phys);
kfree(mp);
}
return data_length;
}
/**
* lpfc_sli_read_link_ste - Read region 23 to decide if link is disabled.
* @phba: pointer to lpfc hba data structure.
*
* This function read region 23 and parse TLV for port status to
* decide if the user disaled the port. If the TLV indicates the
* port is disabled, the hba_flag is set accordingly.
**/
void
lpfc_sli_read_link_ste(struct lpfc_hba *phba)
{
uint8_t *rgn23_data = NULL;
uint32_t if_type, data_size, sub_tlv_len, tlv_offset;
uint32_t offset = 0;
/* Get adapter Region 23 data */
rgn23_data = kzalloc(DMP_RGN23_SIZE, GFP_KERNEL);
if (!rgn23_data)
goto out;
if (phba->sli_rev < LPFC_SLI_REV4)
data_size = lpfc_sli_get_config_region23(phba, rgn23_data);
else {
if_type = bf_get(lpfc_sli_intf_if_type,
&phba->sli4_hba.sli_intf);
if (if_type == LPFC_SLI_INTF_IF_TYPE_0)
goto out;
data_size = lpfc_sli4_get_config_region23(phba, rgn23_data);
}
if (!data_size) if (!data_size)
goto out; goto out;
@ -15373,9 +15469,8 @@ lpfc_sli_read_link_ste(struct lpfc_hba *phba)
goto out; goto out;
} }
} }
out: out:
if (pmb)
mempool_free(pmb, phba->mbox_mem_pool);
kfree(rgn23_data); kfree(rgn23_data);
return; return;
} }