tree 3bc8ea358bea85235a8d9691c8b999626e685e0d
parent 7c32c7a2d36c52d2b9ed040a9171364020ecc6a2
author Martin K. Petersen <martin.petersen@oracle.com> 1216283310 -0400
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1217099694 -0400

[SCSI] Host protection capabilities

Controllers that support protection information must indicate this to
the SCSI midlayer so that the ULD can prepare scsi_cmnds accordingly.

This patch implements a host mask and various types of protection:

 - DIF Type 1-3 (between HBA and disk)
 - DIX Type 0-3 (between OS and HBA)

The patch also allows the HBA to set the guard type to something
different than the T10-mandated CRC.

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
