tree 2d56318f2b64753e0e0797d0a1db3b869e4d52a4
parent 6df19a791bdd5d820cccd8c7a12679888ae62099
author Brian King <brking@linux.vnet.ibm.com> 1228323774 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571463 -0600

[SCSI] ibmvfc: Delay NPIV login retry and add retries

Adds a delay prior to retrying a failed NPIV login. This fixes
a scenario if the backing fibre channel adapter is getting reset
due to an EEH event, NPIV login will fail. Currently, ibmvfc
retries three times very quickly, resets the CRQ and tries one
more time. If the adapter is getting reset due to EEH, this isn't
enough time. This adds a delay prior to retrying a failed NPIV
login and also increments the number of retries.

Signed-off-by: Brian King <brking@linux.vnet.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
