tree 9f1dfb9ab936ca7963f93106cb2eaf6c03f26850
parent 87b5c328c7e32ab9075086f990001bffb7b19550
author Brian King <brking@linux.vnet.ibm.com> 1229614011 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571474 -0600

[SCSI] ibmvfc: Improve async event handling

While doing various error injection testing, such as cable
pulls and target moves, some issues were observed in handling
these events. This patch improves the way these events are handled
by increasing the delay waiting for the fabric to settle and also
changes the behavior of Link Up to break the CRQ to ensure everything
gets cleaned up properly on the VIOS.

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