tree 0bfd3f90706e83fd5caf49a8271fd38117176806
parent ef9e1b9bdca82d9b692da77e35595c2d4b87a4b5
author Jayamohan Kallickal <jayamohank@gmail.com> 1365219508 -0700
committer James Bottomley <JBottomley@Parallels.com> 1367507411 -0700

[SCSI] be2iscsi: Fix displaying the FW Version from driver.

The mgmt_hba_attributes structure declared was not proper and
because of that the FW response returned for the MBX_CMD was not
matching. This issue went unnoticed as mgmt_hba_attribs structure
members were never used in the code path.

This fix of displaying the FW version had to change the mgmt_hba_attrib
structure also. The latest driver will also work with the older FW as
the issue was in the driver declaration.

Signed-off-by: John Soni Jose <sony.john-n@emulex.com>
Signed-off-by: Jayamohan Kallickal <jayamohan.kallickal@emulex.com>
Reviewed-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
