tree 5418dbacedd6c89ef6652d756b94957499c101ea
parent 6ef1b512f4e6f936d89aa20be3d97a7ec7c290ac
author Eddie Wai <eddie.wai@broadcom.com> 1341013055 -0700
committer James Bottomley <JBottomley@Parallels.com> 1341737523 +0100

[SCSI] bnx2i: Removed the reference to the netdev->base_addr

The netdev->base_addr parameter has been deprecated in the L2 bnx2
driver.  This is used by bnx2i for the BARn iomapping.

This patch will directly reference the pci_resource_start instead
of using the deprecated netdev->base_addr.

This patch is actually a critical bug fix as the 1G bnx2 driver no
longer supports the netdev->base_addr in the current kernel of the scsi
tree.  This means that Broadcom's 1G Linux iSCSI offload solution would
not work at all without this patch. 

Signed-off-by: Eddie Wai <eddie.wai@broadcom.com>
Reviewed-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
