tree f3ac1dd6adb76490afa828298e71992ba5045d8f
parent fdd78027fd472351783fb6110a72d991c1a07402
author Vasu Dev <vasu.dev@intel.com> 1237315349 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1238768587 -0500

[SCSI] fcoe, libfc: fix double fcoe_softc memory alloc

The foce_softc mem was reserved by libfc_host_alloc as well as
by fcoe_host_alloc.

Removes one liner fcoe_host_alloc completely, instead directly calls
libfc_host_alloc to alloc scsi_host with libfc for just one fcoe_softc
as fcoe private data.

Moves libfc_host_alloc to libfc.h since it is a libfc API, placed
lport_priv API adjacent to libfc_host_alloc since this is related
to scsi_host priv data.

Signed-off-by: Vasu Dev <vasu.dev@intel.com>
Signed-off-by: Robert Love <robert.w.love@intel.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
