tree 6be2387ebfcff7a1a729061b35f1ea6fdd115a46
parent b2ab99c9a300e572105d6db7f6efe0a4d1572167
author Robert Love <robert.w.love@intel.com> 1235760955 -0800
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1236693935 -0500

[SCSI] libfc, fcoe: Remove unnecessary cast by removing inline wrapper

Comment from "Andrew Morton <akpm@linux-foundation.org>"

> +{
> +     return (struct fcoe_softc *)lport_priv(lp);

unneeded/undesirable cast of void*.  There are probably zillions of
instances of this - there always are.

This whole inline function was unnecessary. The FCoE layer knows
that it's data structure is stored in the lport private data, it
can just access it from lport_priv().

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