tree e07c5156a522f185eae2d17285e26731a2765387
parent 0ce3a7e5bd305e96c924fab1e3126480c665f017
author James Bottomley <James.Bottomley@HansenPartnership.com> 1215745855 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1215868691 -0500

[SCSI] fusion: default MSI to disabled for SPI and FC controllers

There's a fault on the FC controllers that makes them not respond
correctly to MSI.  The SPI controllers are fine, but are likely to be
onboard on older motherboards which don't handle MSI correctly, so
default both these cases to disabled.  Enable by setting the module
parameter mpt_msi_enable=1.

For the SAS case, enable MSI by default, but it can be disabled by
setting the module parameter mpt_msi_enable=0.

Cc: "Prakash, Sathya" <sathya.prakash@lsi.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
