tree 80b682f3fc0622de08278e37e51c59f94ad530e0
parent 2ca39c48ea0d2fd265479d0b62f2ac8878900360
author Salyzyn, Mark <Mark_Salyzyn@adaptec.com> 1200590707 -0800
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1201109374 -0600

[SCSI] aacraid: add Voodoo Lite class of cards.

The cards being added are supported in a limited sense already through
family matching, but we needed to add some functionality to the driver
to expose selectively the physical drives. These Physical drives are
specifically marked to not be part of any array and thus are declared
JBODs (Just a Bunch Of Drives) for generic SCSI access.

We report that this is the second patch in a set of two, but merely
depends on the stand-alone functionality of the first patch which adds
in that case the ability to report a driver feature flag via sysfs. We
leverage that functionality by reporting that this driver now supports
this new JBOD feature for the controller so that the array management
applications may react accordingly and guide the user as they manage
the controller.

Signed-off-by: Mark Salyzyn <aacraid@adaptec.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
