tree 929f7609d410db8654ed1e262725ca2d3203f199
parent b29f841378460c37e99a2398d0015d9bd7901a09
author Mike Christie <michaelc@cs.wisc.edu> 1228199524 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571460 -0600

[SCSI] iscsi_tcp: prepare helpers for LLDs that can offload some operations

cxgb3i is unlike qla4xxx and bnx2i in that it does not offload entire
scsi commands or iscsi sequences. Instead it only offloads the transfer
of a ISCSI DATA_IN pdu's data, the digests and padding. This patch fixes up the
iscsi tcp recv path so that it exports its skb recv processing so
cxgb3i and other drivers can call them. All they have to do is pass
the function the skb with the hdr or data pdu header and this function
will do the rest.

Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
