tree bd51c151a123789fb24dde00052ab1fd09e1aadb
parent 2f7ecc55b37ef9f0208360e64d8b9d2313df8ce6
author Prakash, Sathya <sathya.prakash@lsi.com> 1202488535 +0530
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1202746854 -0600

[SCSI] mpt fusion: Request I/O resources only when required

This patch modifies the I/O resource allocation behavior of FUSION
driver.  The current version of driver allocates the I/O resources
even if they are not required and this creates trouble in low resource
environments.  This driver now uses
pci_enable_device_mem/pci_enable_device functions to differentiate the
resource allocations.

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