tree 9a7211c761b0476216eaf24f0aebd7ced7945a37
parent 2d507a01dac338831266b44ccbb01c69e84606ed
author James Bottomley <James.Bottomley@HansenPartnership.com> 1199039851 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1200097755 -0600

[SCSI] libsas: don't use made up error codes

This is bad for two reasons:

     1. If they're returned to outside applications, no-one knows what
        they mean.
     2. Eventually they'll clash with the ever expanding standard error
        codes.

The problem error code in question is ETASK.  I've replaced this by
ECOMM (communications error on send) a network error code that seems to
most closely relay what ETASK meant.

Acked-by: Darrick J. Wong <djwong@us.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
