tree 219211924d44553b97579682cd8c27750b47b631
parent 7404ad3b6d04efbd918e9e2e776bf560fbedf47d
author Andrew Vasquez <andrew.vasquez@qlogic.com> 1216395172 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1223052375 -0500

[SCSI] fc_transport: Add an API to allow an LLD to create vports

There's already a fc_vport_termintate() call exported by
the transport.  This patch adds a symmetric call to the API to allow
an NPIV-capable LLD to instantiate vports sans user intervention.

Additional comments/updates:

   Re: scsi_fc_transport.txt
     Add a function prototype for fc_vport_terminate similar to what's
     done for fc_vport_create

   Re: fc_vport_create
     I recommend we pass the channel number in fc_vport_create rather
     than fixing it at zero.

     Also, ids->vport_type should be set to FC_PORTTYPE_NPIV prior to
     calling fc_vport_create. The comment is also meaningless.

Added-by and
Signed-off-by: James Smart <james.smart@emulex.com>
Signed-off-by: Andrew Vasquez <andrew.vasquez@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
