tree 194fc6230e5264c2795b42fb99956d9477590ce4
parent e916141c6889e2a35869d7057ef1cc5e5a2e86eb
author Anirban Chakraborty <anirban.chakraborty@qlogic.com> 1234155011 -0800
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1234282519 -0500

[SCSI] qla2xxx: Remove interrupt request bit check in the response processing path in multiq mode.

Correct response-queue-0 processing by instructing the firmware
to run with interrupt-handshaking disabled, similarly to what is
now done for all non-0 response queues.  Since all
response-queues now run in the same mode, the driver no longer
needs the hot-path 'is-disabled-HCCR' test.

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