tree a9cba8a221e0c03f5457e23510fc014a772cbe38
parent a4976d688650b4593831fbffbb217f2d916b1aa0
author Ed Lin - PTU <ed.lin@promise.com> 1232966411 -0800
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1236880683 -0500

[SCSI] stex: Fix for potential invalid response

The interrupt routine is good for normal cases. However, if the firmware
is abnormal and returns an invalid response, the driver may reuse a
ccb structure that has already been handled. This may cause problem.
Fix this by setting the req member to NULL. Next time we know the
response is invalid and handle accordingly if req is NULL.

Signed-off-by: Ed Lin <ed.lin@promise.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
