tree 6820b74e8fbfb13c4eee4c8ef8b59a9132320799
parent 64a87b244b9297667ca80264aab849a36f494884
author Boaz Harrosh <bharrosh@panasas.com> 1209544046 +0300
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1209746005 -0500

[SCSI] add support for variable length extended commands

Add support for variable-length, extended, and vendor specific
CDBs to scsi-ml. It is now possible for initiators and ULD's
to issue these types of commands. LLDs need not change much.
All they need is to raise the .max_cmd_len to the longest command
they support (see iscsi patch).

- clean-up some code paths that did not expect commands to be
  larger than 16, and change cmd_len members' type to short as
  char is not enough.

Signed-off-by: Boaz Harrosh <bharrosh@panasas.com>
Signed-off-by: Benny Halevy <bhalevy@panasas.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
