tree 52880ae49bce8a8b733d0d59bd84b324eb0871ef
parent 40859ae5f13534624cc35a05179b4f93ecbf531a
author Andrew Vasquez <andrew.vasquez@qlogic.com> 1244048117 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1244490401 -0500

[SCSI] qla2xxx: Fallback to 'golden-firmware' operation on supported ISPs.

In case the onboard firmware is unable to be read or loaded for
operation, attempt to fallback to a limited-operational firmware
image stored in a different flash region.  This will allow a user
to reflash and correct a board with proper operational firmware.

Signed-off-by: Andrew Vasquez <andrew.vasquez@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
