tree 59045a1bdcb5d48286f244dc700482495973a018
parent b225cf9b8040849e16add4da8e84a72a3548ada8
author Christof Schmitt <christof.schmitt@de.ibm.com> 1229702221 +0100
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230572308 -0600

[SCSI] zfcp: Add support for unchained FSF requests

Add the support to send CT and ELS requests as unchained FSF requests. This is
required for older hardware and was somehow omitted during the cleanup of the
FSF layer. The req_count and resp_count attributes are unused, so remove them
instead of adding a special case for setting them. Also add debug data and a
warning, when the ct request hits a limit.

Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Acked-by: Martin Petermann <martin@linux.vnet.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
