tree c9ae4867a01cbdb11c008c23830ddd7c7220bee8
parent d8e93df13c8f7bde45a7756944aab528c58df4cf
author James Smart <James.Smart@Emulex.Com> 1243018392 -0400
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1244478361 -0500

[SCSI] lpfc 8.3.2 : Miscellaneous Changes

Miscellaneous Changes:
- Convert from SLI2_ACTIVE flag to more correct SLI_ACTIVE (generic) flag
- Reposition log verbose messaging definitions
- Update naming for vpi object name from vport slang name
- Handle deferred error attention condition
- Add 10G link support
- Small bug fixup

Signed-off-by: James Smart <james.smart@emulex.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
