
















--                      ADAPTEC UNIVERSAL STORAGE MIB
--                      REVISION 1.4
--

--                      This is the main MIB for Adaptec Storage Manager.
--                      This is a MIB for block-oriented storage.  Future
--                      enhancements may include network attached storage.

--                      This document is Copyright (C) 2004-present, Adaptec, Inc.






























ADAPTEC-UNIVERSAL-STORAGE-MIB DEFINITIONS ::= BEGIN

IMPORTS
    enterprises, Counter
        FROM RFC1155-SMI
    DisplayString
        FROM RFC1213-MIB
    TRAP-TYPE
        FROM RFC-1215
    OBJECT-TYPE
        FROM RFC-1212;

--  This MIB module uses the extended OBJECT-TYPE macro as
--  defined in [14];


adaptec                        OBJECT IDENTIFIER ::= { enterprises 795 }
universalStorage               OBJECT IDENTIFIER ::= { adaptec 14 }
ausMIB                         OBJECT IDENTIFIER ::= { universalStorage 1 }

----------------------------------------------------------------------------
-- Administrative section of the MIB
----------------------------------------------------------------------------

ausMibStatus                   OBJECT IDENTIFIER ::= { ausMIB 100 }

----------------------------------------------------------------------------
-- Physical section of the MIB
----------------------------------------------------------------------------

ausAggregatedController        OBJECT IDENTIFIER ::= { ausMIB 200 }
ausController                  OBJECT IDENTIFIER ::= { ausMIB 201 }
ausControllerRelationship      OBJECT IDENTIFIER ::= { ausMIB 202 }
--  Additional specific controller types should be assigned sequentially
--  starting at 210
ausI2ORaidController           OBJECT IDENTIFIER ::= { ausMIB 210 }
ausCCodeController             OBJECT IDENTIFIER ::= { ausMIB 211 }
ausHostRAIDController          OBJECT IDENTIFIER ::= { ausMIB 212 }
ausServeRAIDController         OBJECT IDENTIFIER ::= { ausMIB 213 }

ausChannel                     OBJECT IDENTIFIER ::= { ausMIB 300 }
ausChannelRelationship         OBJECT IDENTIFIER ::= { ausMIB 301 }

ausDevice                      OBJECT IDENTIFIER ::= { ausMIB 400 }
ausDevicePort                  OBJECT IDENTIFIER ::= { ausMIB 401 }

-- Additional specific device types should be assigned sequentially
-- starting at 410.
ausStorageDevice               OBJECT IDENTIFIER ::= { ausMIB 410 }
ausEnclosureDevice             OBJECT IDENTIFIER ::= { ausMIB 411 }
ausExternalRaidDevice          OBJECT IDENTIFIER ::= { ausMIB 412 }
ausOtherDevice                 OBJECT IDENTIFIER ::= { ausMIB 499 }

-- Additional enclosure feature tables should be assigned sequentially
-- starting at 600.
ausEnclosureFan                OBJECT IDENTIFIER ::= { ausMIB 500 }
ausEnclosurePowerSupply        OBJECT IDENTIFIER ::= { ausMIB 501 }
ausEnclosureTemperatureSensor  OBJECT IDENTIFIER ::= { ausMIB 502 }
ausEnclosureSlot               OBJECT IDENTIFIER ::= { ausMIB 503 }

----------------------------------------------------------------------------
-- Logical section of the MIB
----------------------------------------------------------------------------

ausArray                       OBJECT IDENTIFIER ::= { ausMIB 1000 }
ausExtent                      OBJECT IDENTIFIER ::= { ausMIB 1001 }
ausSpare                       OBJECT IDENTIFIER ::= { ausMIB 1002 }

----------------------------------------------------------------------------
-- Logging section of the MIB
----------------------------------------------------------------------------

ausEventLogCount               OBJECT IDENTIFIER ::= { ausMIB 2000 }
ausEventLog                    OBJECT IDENTIFIER ::= { ausMIB 2001 }

----------------------------------------------------------------------------
 -- Global type definitions
----------------------------------------------------------------------------

TriState ::=        INTEGER
                    {
                        unknown(1),
                        false(2),
                        true(3)
                    }

ObjectStatus ::=    INTEGER
                    {
                        unknown(1),
                        other(2),
                        okay(3),
                        warning(4),
                        failure(5)
                    }

OptionStatus ::=    INTEGER
                    {
                        unknown(1),
                        other(2),
                        notApplicable(3),
                        notInstalled(4),
                        installedAndInactive(5),
                        installedAndActive(6)
                    }

BatteryStatus ::=   INTEGER
                    {
                        unknown(1),
                        other(2),
                        notApplicable(3),
                        notInstalled(4),
                        okay(5),
                        failed(6),
                        charging(7),
                        discharging(8),
                        inMaintenanceMode(9),
                        chargingDisabled(10)
                    }

ZMMStatus ::=   INTEGER
                    {
                        unknown(0),
                        okay(1),
                        charging(2),
                        failed(3),
                        notInstalled(4)                       
                    }

-- The IndexList is used to facilitate description of many-to-many
-- relationships.  In this MIB, objects are related to each other
-- by referencing the index of a related object.  When there are
-- multiple related objects, a simple integer index will not suffice.
-- In this case this MIB uses the IndexList, which is nothing more
-- than a comma-delimited list of integers specifying the indices
-- of another table.  For example, if TableA uses an IndexList to
-- associate with objects in TableB, and if a particular row of TableA
-- is associated with rows indexed as 1, 7, and 24 in TableB, then
-- TableA will use an IndexList of the form "1,7,24" to express the
-- association.
IndexList ::=       DisplayString

----------------------------------------------------------------------------
-- Administrative section of the MIB
----------------------------------------------------------------------------

 -- the Adaptec Universal Storage MIB Status group

  -- Implementation of the MIB Status group is mandatory for all
  -- systems.

ausMibStatusRevMajor OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The major number of the revision of the Adaptec
        Universal Storage MIB."
    ::= { ausMibStatus 1 }

ausMibStatusRevMinor OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The minor number of the revision of the Adaptec
        Universal Storage MIB."
    ::= { ausMibStatus 2 }

ausMibStatusSecondsSinceInitiation OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The number of elapsed seconds since this SNMP subagent
        was initiated."
    ::= { ausMibStatus 3 }

ausMibStatusCopyright OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Copyright notification.  This string shall always be
        reported as 'Copyright (C) 2011 PMC-Sierra, Inc'.  The year
        may be modified as appropriate."
    ::= { ausMibStatus 4 }

ausMibStatusOverall OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Overall operational status.  This is the 'worst' overall
        status of all controllers reported in the MIB."
    ::= { ausMibStatus 5 }

----------------------------------------------------------------------------
-- Physical section of the MIB
----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Aggregated Controller group

  -- Implementation of the Aggregated Controller group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Aggregated Controller table

  -- The Aggregated Controller table contains information on physical
  -- controllers that are aggregated by software drivers to form arrays.
  -- This table exists to show array relationships between controllers, and
  -- to provide an anchor point for the array table to point to as the owning
  -- controller.
  -- Note: It is possible that controllers may be related for reasons other
  -- than being aggregated to form an array.  For example, controllers could
  -- have a failover relationship to each other.  Other forms of controller
  -- relationships are maintained in the ausControllerRelationship table.
  -- This table is solely for arrays that span multiple controllers.
  --
  -- Note: The Aggregated Controller table is reserved for future expansion.
  -- Current versions of the SNMP agent for this MIB will not populate this
  -- table.

ausAggregatedControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusAggregatedControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of aggregated controllers."
    ::= { ausAggregatedController 1 }

ausAggregatedControllerEntry OBJECT-TYPE
    SYNTAX  AusAggregatedControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An aggregated controller entry."
    INDEX   { ausAggregatedControllerIndex }
    ::= { ausAggregatedControllerTable 1 }

AusAggregatedControllerEntry ::=
    SEQUENCE
    {
        ausAggregatedControllerIndex
            INTEGER,
        ausAggregatedControllerList
            IndexList
    }

ausAggregatedControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each aggregated controller
        beginning with 1."
    ::= { ausAggregatedControllerEntry 1 }

ausAggregatedControllerList OBJECT-TYPE
    SYNTAX  IndexList
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A list of indices into the ausControllerTable
        specifying the controllers that are aggregated by a
        software driver to form an array."
    ::= { ausAggregatedControllerEntry 2 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Controller group

  -- Implementation of the Controller group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Controller table

  -- The Controller table contains information on the available
  -- controllers (host bus adapters).

ausControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of controllers."
    ::= { ausController 1 }

ausControllerEntry OBJECT-TYPE
    SYNTAX  AusControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A controller entry."
    INDEX   { ausControllerIndex }
    ::= { ausControllerTable 1 }

AusControllerEntry ::=
    SEQUENCE
    {
        ausControllerIndex
            INTEGER,
        ausControllerUniqueId
            DisplayString,
        ausControllerVendor
            DisplayString,
        ausControllerModel
            DisplayString,
        ausControllerRevision
            DisplayString,
        ausControllerSerialNumber
            DisplayString,
        ausControllerDescription
            DisplayString,
        ausControllerHostBusType
            INTEGER,
        ausControllerHostBusMaximumTransferRate
            INTEGER,
        ausControllerNumberOfChannels
            INTEGER,
        ausControllerHighestChannelWithDevices
            INTEGER,
        ausControllerInstalledMemory
            INTEGER,
        ausControllerAudibleAlarmStatus
            OptionStatus,
        ausControllerBatteryStatus
            BatteryStatus,
        ausControllerZMMStatus
            ZMMStatus,
        ausControllerStatus
            ObjectStatus,
        ausControllerOverallStatus
            ObjectStatus,
        ausControllerPerformanceMode
            INTEGER,
        ausControllerMaxCacheSupported
            INTEGER,
        ausControllerMaxCacheAssignedDrives
            INTEGER,
        ausControllerMaximumAllowedMaxCacheDrives
            INTEGER,
        ausControllerNCQStatus
            INTEGER
    }

ausControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each controller beginning with
        1."
    ::= { ausControllerEntry 1 }

ausControllerUniqueId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "An ID for this controller that is unique across all
        namespaces."
        -- Report 'None' if no unique ID exists.
        -- Report 'Unknown (exists)' if unique ID exists but can't be
        --     determined.
        -- Report 'Unknown' if it is unknown whether a unique ID exists.
    ::= { ausControllerEntry 2 }

ausControllerVendor OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Vendor (manufacturer) of the controller."
        -- Report 'Unknown' if vendor information unavailable
    ::= { ausControllerEntry 3 }

ausControllerModel OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Model (descriptive name) of the controller."
        -- Report 'Unknown' if model information unavailable
    ::= { ausControllerEntry 4 }

ausControllerRevision OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Revision information of the controller."
        -- Report 'Unknown' if revision information unavailable
    ::= { ausControllerEntry 5 }

ausControllerSerialNumber OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Serial number of the controller."
        -- Report 'Unknown' if serial number information unavailable
    ::= { ausControllerEntry 6 }

ausControllerDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Free form text for additional description of the
        controller."
        -- Report 'No additional description' if information unavailable
    ::= { ausControllerEntry 7 }

ausControllerHostBusType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        notApplicable(3),
        pci(4),
        pci-32(5),
        pci-64(6),
        pcix(7),
        pcie(8)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Type of host computer system bus for this controller."
    ::= { ausControllerEntry 8 }

ausControllerHostBusMaximumTransferRate OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Maximum possible transfer rate on the host bus in
        megabytes per second."
        -- Report -1 if unknown
    ::= { ausControllerEntry 9 }

ausControllerNumberOfChannels OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The number of channels present on this controller."
    ::= { ausControllerEntry 10 }

ausControllerHighestChannelWithDevices OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The 0-relative channel number within the controller
        which has at least one device attached to it."
    ::= { ausControllerEntry 11 }

ausControllerInstalledMemory OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Memory installed on this controller in megabytes."
        -- Report -1 if unknown
    ::= { ausControllerEntry 12 }

ausControllerAudibleAlarmStatus OBJECT-TYPE
    SYNTAX  OptionStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of audible alarm for this controller."
    ::= { ausControllerEntry 13 }

ausControllerBatteryStatus OBJECT-TYPE
    SYNTAX  BatteryStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of battery for this controller."
    ::= { ausControllerEntry 14 }

ausControllerZMMStatus OBJECT-TYPE
    SYNTAX  ZMMStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of ZMM for this controller."
    ::= { ausControllerEntry 15 }
    
ausControllerStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Operational status of this controller."
    ::= { ausControllerEntry 16 }

ausControllerOverallStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Overall operational status of this controller and its
        children.  This is the 'worst' status of the controller
        status and that of all arrays and un-arrayed devices
        attached to this controller."
    ::= { ausControllerEntry 17 }
    
ausControllerPerformanceMode OBJECT-TYPE
    SYNTAX  INTEGER
    {
        Dynamic(0),
        OLTPDatabase(3)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "To ensure optimal performance of the logical drives in the 
        storage space, the performance mode is used.It improves 
        I/O throughput based on the needs of the application."
    ::= { ausControllerEntry 18 }

ausControllerMaxCacheSupported OBJECT-TYPE
    SYNTAX  INTEGER
    {
        False(0),
        True(1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        ""
    ::= { ausControllerEntry 19 }

ausControllerMaxCacheAssignedDrives OBJECT-TYPE
    SYNTAX  INTEGER
    {
    	notSupported(-1)	
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        ""
    ::= { ausControllerEntry 20 }
    
ausControllerMaximumAllowedMaxCacheDrives OBJECT-TYPE
    SYNTAX  INTEGER
    {
       	notSupported(-1)	
    }    
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        ""
    ::= { ausControllerEntry 21 }
    
ausControllerNCQStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        Disabled(0),
        Enabled(1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        ""
    ::= { ausControllerEntry 22 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Controller Relationship group

  -- Implementation of the Controller Relationship group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Controller Relationship table

  -- The Controller Relationship table contains information about
  -- relationships between physical controllers.  The connectivity structure
  -- of the system can be understood without referring to this table, but
  -- this table adds additional information about relationships formed among
  -- controllers (usually by software).

ausControllerRelationshipTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusControllerRelationshipEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of controller relationships."
    ::= { ausControllerRelationship 1 }

ausControllerRelationshipEntry OBJECT-TYPE
    SYNTAX  AusControllerRelationshipEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A controller relationship entry."
    INDEX   { ausControllerRelationshipIndex }
    ::= { ausControllerRelationshipTable 1 }

AusControllerRelationshipEntry ::=
    SEQUENCE
    {
        ausControllerRelationshipIndex
            INTEGER,
        ausControllerRelationshipType
            INTEGER,
        ausControllerRelationshipList
            IndexList,
        ausControllerRelationshipRelation
            INTEGER
    }

ausControllerRelationshipIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each controller relationship
        beginning with 1."
    ::= { ausControllerRelationshipEntry 1 }

ausControllerRelationshipType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        hostAttachedController(1),
        externalRaid(2)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Selects whether this row entry is a relationship between
        entries in the ausController table or entries in the
        ausExternalRaidDevice table.  Setting of this field
        determines if the ausControllerRelationshipList is a
        list of indices in the ausController table or the
        ausExternalRaidDevice table."
    ::= { ausControllerRelationshipEntry 2 }

ausControllerRelationshipList OBJECT-TYPE
    SYNTAX  IndexList
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A list of indices into the appropriate controller table
        specifying the controllers that are related."
    ::= { ausControllerRelationshipEntry 3 }

ausControllerRelationshipRelation OBJECT-TYPE
    SYNTAX  INTEGER
            -- Note: This is a bit field.  Multiple bits may
            -- be simultaneously set.
            -- Bit 0 (LSB) = failover
            -- Bit 1       = load balanced
            -- Bit 2       = aggregated for bandwidth
            -- Bit 3       = Active/Active
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The attributes of the relationship among the related
        controllers."
    ::= { ausControllerRelationshipEntry 4 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage I2O RAID Controllers group

  -- Implementation of the I2O RAID Controller group is optional.

  -- the Adaptec Universal Storage I2O RAID Controller table

  -- The I2O RAID Controller table contains extended information on
  -- I2O RAID architecture controllers.

ausI2ORaidControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusI2ORaidControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of I2O RAID storage controllers."
    ::= { ausI2ORaidController 1 }

ausI2ORaidControllerEntry OBJECT-TYPE
    SYNTAX  AusI2ORaidControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A I2O RAID storage controller entry."
    INDEX   { ausI2ORaidControllerIndex }
    ::= { ausI2ORaidControllerTable 1 }

AusI2ORaidControllerEntry ::=
    SEQUENCE
    {
        ausI2ORaidControllerIndex
            INTEGER,
        ausI2ORaidControllerAddress
            INTEGER,
        ausI2ORaidControllerBackgroundTaskPriority
            INTEGER,
        ausI2ORaidControllerBiosRevision
            DisplayString,
        ausI2ORaidControllerSmorRevision
            DisplayString,
        ausI2ORaidControllerMainIndex
            INTEGER
    }

ausI2ORaidControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each I2O RAID controller."
    ::= { ausI2ORaidControllerEntry 1 }

ausI2ORaidControllerAddress OBJECT-TYPE
    SYNTAX           INTEGER (0..'FFFFFFFE'h)
    ACCESS           read-only
    STATUS           mandatory
    DESCRIPTION
        "The controller Address (normally displayed in hex.) It
        is a 32-bit value representing the memory address used by
        the controller"
        -- Report -1 if unknown
    ::= { ausI2ORaidControllerEntry 2 }

ausI2ORaidControllerBackgroundTaskPriority OBJECT-TYPE
    SYNTAX           INTEGER (1..10)
    ACCESS           read-only
    STATUS           mandatory
    DESCRIPTION
        "This object controls the priority of array background
        tasks such as Build, Rebuild and Verify for this
        controller.  The values range from 1 to 10.  A value of 1
        is the slowest but uses the least amount of the
        controller's bandwidth.  While a value of 10 is the
        fastest but it uses the most bandwidth."
    ::= { ausI2ORaidControllerEntry 3 }

ausI2ORaidControllerBiosRevision OBJECT-TYPE
    SYNTAX           DisplayString
    ACCESS           read-only
    STATUS           mandatory
    DESCRIPTION
        "The controller B.I.O.S. revision information."
        -- Report 'Unknown' if BIOS unavailable
    ::= { ausI2ORaidControllerEntry 4 }

ausI2ORaidControllerSmorRevision OBJECT-TYPE
    SYNTAX           DisplayString
    ACCESS           read-only
    STATUS           mandatory
    DESCRIPTION
        "The controller S.M.O.R. revision information."
        -- Report 'Unknown' if vendor information unavailable
    ::= { ausI2ORaidControllerEntry 5 }

ausI2ORaidControllerMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausControllerTable of the row
		 that is extended by this row of
		 ausI2ORaidControllerTable."
    ::= { ausI2ORaidControllerEntry 6 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Container Code Controllers group

  -- Implementation of the Container Code Controller group is optional.

  -- the Adaptec Universal Storage Container Code Controller table

  -- The Container Code Controller table contains extended information on
  -- Container Code architecture controllers.

ausCCodeControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusCCodeControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of Container Code storage controllers."
    ::= { ausCCodeController 1 }

ausCCodeControllerEntry OBJECT-TYPE
    SYNTAX  AusCCodeControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A Container Code storage controller entry."
    INDEX   { ausCCodeControllerIndex }
    ::= { ausCCodeControllerTable 1 }

AusCCodeControllerEntry ::=
    SEQUENCE
    {
        ausCCodeControllerIndex
            INTEGER,
        ausCCodeControllerPCIBusId
            INTEGER,
        ausCCodeControllerPCISlotNumber
            INTEGER,
        ausCCodeControllerBiosVersion
            DisplayString,
        ausCCodeControllerMainIndex
            INTEGER
    }

ausCCodeControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each Container Code controller."
    ::= { ausCCodeControllerEntry 1 }

ausCCodeControllerPCIBusId OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The identifier of the host computer PCI bus the
        controller is attached to."
    ::= { ausCCodeControllerEntry 2 }

ausCCodeControllerPCISlotNumber OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The slot number of the host computer PCI bus the
        controller is in."
    ::= { ausCCodeControllerEntry 3 }

ausCCodeControllerBiosVersion OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The B.I.O.S. software version."
    ::= { ausCCodeControllerEntry 4 }

ausCCodeControllerMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausControllerTable of the row
		 that is extended by this row of
		 ausCCodeControllerTable."
    ::= { ausCCodeControllerEntry 5 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage HostRAID Controllers group

  -- Implementation of the HostRAID Controller group is optional.

  -- the Adaptec Universal Storage HostRAID Controller table

  -- The HostRAID Controller table contains extended information on
  -- HostRAID architecture controllers.

ausHostRAIDControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusHostRAIDControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of HostRAID storage controllers."
    ::= { ausHostRAIDController 1 }

ausHostRAIDControllerEntry OBJECT-TYPE
    SYNTAX  AusHostRAIDControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A HostRAID storage controller entry."
    INDEX   { ausHostRAIDControllerIndex }
    ::= { ausHostRAIDControllerTable 1 }

AusHostRAIDControllerEntry ::=
    SEQUENCE
    {
        ausHostRAIDControllerIndex
            INTEGER,
        ausHostRAIDControllerPCIBus
            INTEGER,
        ausHostRAIDControllerPCIDevice
            INTEGER,
        ausHostRAIDControllerPCIFunction
            INTEGER,
        ausHostRAIDControllerMainIndex
            INTEGER
    }

ausHostRAIDControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each HostRAID controller."
    ::= { ausHostRAIDControllerEntry 1 }

ausHostRAIDControllerPCIBus OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The PCI bus number of this controller."
    ::= { ausHostRAIDControllerEntry 2 }

ausHostRAIDControllerPCIDevice OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The PCI device number of this controller."
    ::= { ausHostRAIDControllerEntry 3 }

ausHostRAIDControllerPCIFunction OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The PCI function number of this controller."
    ::= { ausHostRAIDControllerEntry 4 }

ausHostRAIDControllerMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausControllerTable of the row
		 that is extended by this row of
		 ausI2ORaidControllerTable."
    ::= { ausHostRAIDControllerEntry 5 }



----------------------------------------------------------------------------

 -- the Adaptec Universal Storage ServeRAID Controllers group

  -- Implementation of the ServeRAID Controller group is optional.

  -- the Adaptec Universal Storage ServeRAID Controller table

  -- The ServeRAID Controller table contains extended information on
  -- ServeRAID architecture controllers.

ausServeRAIDControllerTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusServeRAIDControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of ServeRAID storage controllers."
    ::= { ausServeRAIDController 1 }

ausServeRAIDControllerEntry OBJECT-TYPE
    SYNTAX  AusServeRAIDControllerEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A ServeRAID storage controller entry."
    INDEX   { ausServeRAIDControllerIndex }
    ::= { ausServeRAIDControllerTable 1 }

AusServeRAIDControllerEntry ::=
    SEQUENCE
    {
        ausServeRAIDControllerIndex
            INTEGER,
        ausServeRAIDControllerBIOSRevision
            DisplayString,
        ausServeRAIDControllerDefaultRebuildRate
            INTEGER,
        ausServeRAIDControllerSlotNumber
            INTEGER,
        ausServeRAIDControllerMainIndex
            INTEGER
    }

ausServeRAIDControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each ServeRAID controller."
    ::= { ausServeRAIDControllerEntry 1 }

ausServeRAIDControllerBIOSRevision OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The B.I.O.S. Revision of this controller."
    ::= { ausServeRAIDControllerEntry 2 }

ausServeRAIDControllerDefaultRebuildRate OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        low(3),
        medium(4),
        high(5)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The default rebuild rate of this controller."
    ::= { ausServeRAIDControllerEntry 3 }

ausServeRAIDControllerSlotNumber OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The slot number of this controller."
    ::= { ausServeRAIDControllerEntry 4 }

ausServeRAIDControllerMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausControllerTable of the row
		 that is extended by this row of
		 ausServeRAIDControllerTable."
    ::= { ausServeRAIDControllerEntry 5 }


----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Channel group

  -- Implementation of the Channel group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Channel table

  -- The Channel table contains information on the available
  -- channels (host bus adapter channels).

ausChannelTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusChannelEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of channels."
    ::= { ausChannel 1 }

ausChannelEntry OBJECT-TYPE
    SYNTAX  AusChannelEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A channel entry."
    INDEX   { ausChannelIndex }
    ::= { ausChannelTable 1 }

AusChannelEntry ::=
    SEQUENCE
    {
        ausChannelIndex
            INTEGER,
        ausChannelLocation
            INTEGER,
        ausChannelAusControllerIndex
            INTEGER,
        ausChannelAusControllerChannelNumber
            INTEGER,
        ausChannelType
            INTEGER,
        ausChannelTypeDescription
            DisplayString,
        ausChannelControllerId
            DisplayString,
        ausChannelControllerSubId
            DisplayString,
        ausChannelWidth
            INTEGER,
        ausChannelMaximumTransferRate
            INTEGER,
        ausChannelMaximumAttachments
            INTEGER,
        ausChannelOverallStatus
            ObjectStatus
    }

ausChannelIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each channel beginning with 1."
    ::= { ausChannelEntry 1 }

ausChannelLocation OBJECT-TYPE
    SYNTAX  INTEGER
    {
        hostAttached(1),
        externalRaid(2)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Indicates whether the channelAusControllerIndex field
        should be interpreted as an index into the
        controllerTable or the externalRaidDeviceTable.  In other
        words, shows whether this channel is a channel connected
        directly to the host or is a back-end channel connected
        to an external RAID controller."
    ::= { ausChannelEntry 2 }

ausChannelAusControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage controller
        table containing the entry that hosts this channel, or an
        index into the externalRaidDevice table containing the
        external RAID controller that hosts this channel.  Where
        the index points is selected by channelLocation above."
    ::= { ausChannelEntry 3 }

ausChannelAusControllerChannelNumber OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Channel number within the controller referenced by
        channelAusControllerIndex.  Channels are numbered
        sequentially starting with 0."
    ::= { ausChannelEntry 4 }

ausChannelType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        scsi(3),
        ide(4),
        fibreChannel(5),
        sata(6),
        sas(7)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Physical transmission technology for this channel."
    ::= { ausChannelEntry 5 }

ausChannelTypeDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A finer-grained description for the channel.  For
        example, SCSI may be further refined as 'Ultra160' or
        'Ultra320'.  IDE may be further refined per the various
        different performance types available."
        -- Report 'No further information' if no further information available
    ::= { ausChannelEntry 6 }

ausChannelControllerId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Controller ID number used on this channel.  Meaning is
        dependent on channelType.  For example, SCSI channels
        would report controller SCSI ID in this field.  The field
        is a string to allow for a wide range of addressing
        schemes."
        -- Report 'None' if channel has no concept of ID.
        -- Report 'Unknown' if channel ID unknown.
    ::= { ausChannelEntry 7 }

ausChannelControllerSubId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Controller SubId number used on this channel.  Meaning
        is dependent on channelType.  For example, SCSI channels
        would report controller SCSI LUN in this field.  The
        field is a string to allow for a wide range of addressing
        schemes."
        -- Report 'None' if channel has no concept of subId.
        -- Report 'Unknown' if channel SubId unknown.
    ::= { ausChannelEntry 8 }

ausChannelWidth OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Width of the channel in bits.  For example, SCSI would
        be 8 or 16.  Serial interfaces would be 1."
        -- Report -1 if unknown
    ::= { ausChannelEntry 9 }

ausChannelMaximumTransferRate OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Maximum transfer rate of this channel in megabytes per
        second."
        -- Report -1 if unknown
    ::= { ausChannelEntry 10 }

ausChannelMaximumAttachments OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Maximum number of devices that may be attached to this
        this channel (include controller in the count).  In case
        of SATA, this is the total number of ports.  Ports are
        virtualized into IDs on 'SCSI channels'."
        -- Report -1 if unknown
    ::= { ausChannelEntry 11 }

ausChannelOverallStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Overall operational status of this channel.  This is the
        'worst' status of all arrays and un-arrayed devices
        attached to this channel."
    ::= { ausChannelEntry 12 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Channel Relationship group

  -- Implementation of the Channel Relationship group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Channel Relationship table

  -- The Channel Relationship table contains information about relationships
  -- between channels.  The connectivity structure of the system
  -- can be understood without referring to this table, but this table adds
  -- additional information about relationships formed among channels
  -- (usually by software).

ausChannelRelationshipTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusChannelRelationshipEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of channel relationships."
    ::= { ausChannelRelationship 1 }

ausChannelRelationshipEntry OBJECT-TYPE
    SYNTAX  AusChannelRelationshipEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A channel relationship entry."
    INDEX   { ausChannelRelationshipIndex }
    ::= { ausChannelRelationshipTable 1 }

AusChannelRelationshipEntry ::=
    SEQUENCE
    {
        ausChannelRelationshipIndex
            INTEGER,
        ausChannelRelationshipList
            IndexList,
        ausChannelRelationshipRelation
            INTEGER
    }

ausChannelRelationshipIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each channel relationship
        beginning with 1."
    ::= { ausChannelRelationshipEntry 1 }

ausChannelRelationshipList OBJECT-TYPE
    SYNTAX  IndexList
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A list of indices into the channel table specifying the
        channels that are related."
    ::= { ausChannelRelationshipEntry 2 }

ausChannelRelationshipRelation OBJECT-TYPE
    SYNTAX  INTEGER
            -- Note: This is a bit field.  Multiple bits may
            -- be simultaneously set.
            -- Bit 0 (LSB) = single controller failover
            -- Bit 1       = single controller load balanced
            -- Bit 2       = single controller aggregated for bandwidth
            -- Bit 16      = accessible from multiple controllers
            -- Note: Bit 16 will never be simultaneously set with
            -- any other bit.
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The attributes of the relationship among the related
        controllers."
    ::= { ausChannelRelationshipEntry 3 }


----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Device group

  -- Implementation of the Device group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Device table

  -- The Device table contains information on the available
  -- devices.

ausDeviceTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of devices."
    ::= { ausDevice 1 }

ausDeviceEntry OBJECT-TYPE
    SYNTAX  AusDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A device entry."
    INDEX   { ausDeviceIndex }
    ::= { ausDeviceTable 1 }

AusDeviceEntry ::=
    SEQUENCE
    {
        ausDeviceIndex
            INTEGER,
        ausDeviceUniqueId
            DisplayString,
        ausDeviceAusChannelIndices
            IndexList,
        ausDeviceType
            INTEGER,
        ausDeviceTypeGroup
            INTEGER,
        ausDeviceVendor
            DisplayString,
        ausDeviceModel
            DisplayString,
        ausDeviceRevision
            DisplayString,
        ausDeviceSerialNumber
            DisplayString,
        ausDeviceNumberOfPorts
            INTEGER,
        ausDeviceStatus
            ObjectStatus,
        ausDeviceLocation
            DisplayString,
        ausDeviceMaxCacheCapable
            INTEGER,
        ausDeviceMaxCacheAssigned
            INTEGER,
        ausDeviceSataNCQEnabled
            INTEGER
    }

ausDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each device beginning with 1."
    ::= { ausDeviceEntry 1 }

ausDeviceUniqueId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "An ID for this device that is unique across all
        namespaces."
        -- Report 'None' if no unique ID exists.
        -- Report 'Unknown (exists)' if unique ID exists but can't be
        --     determined.
        -- Report 'Unknown' if it is unknown whether a unique ID exists.
    ::= { ausDeviceEntry 2 }

ausDeviceAusChannelIndices OBJECT-TYPE
    SYNTAX  IndexList
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A list of indices into the Adaptec Universal Storage
        Channel table to which this device is attached.  (For
        detailed information about connections between the device
        and the channel, refer to the ausDevicePort
        table.)"
    ::= { ausDeviceEntry 3 }

ausDeviceType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        directAccess(3),
        sequentialAccess(4),
        printer(5),
        processor(6),
        writeOnce(7),
        cdRom(8),
        scanner(9),
        opticalMemory(10),
        mediumChanger(11),
        communications(12)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Device type for this device."
        --  Current set of device types is from the SCSI specification,
        --  but may be expanded as needed
    ::= { ausDeviceEntry 4 }

ausDeviceTypeGroup OBJECT-TYPE
    SYNTAX  INTEGER
    {
        noSubordinateTable(1),
        storageDevice(2),
        enclosureDevice(3),
        externalRaidDevice(4),
        otherDevice(5)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Selects which of the subordinate device tables contains
        more information about this device."
    ::= { ausDeviceEntry 5 }

ausDeviceVendor OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Vendor (manufacturer) of this device."
        -- Report 'Unknown' if unknown
    ::= { ausDeviceEntry 6 }

ausDeviceModel OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Model of this device."
        -- Report 'Unknown' if unknown
    ::= { ausDeviceEntry 7 }

ausDeviceRevision OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Revision information for this device."
        -- Report 'Unknown' if unknown
    ::= { ausDeviceEntry 8 }

ausDeviceSerialNumber OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Serial number of this device."
        -- Report 'Unknown' if unknown
    ::= { ausDeviceEntry 9 }

ausDeviceNumberOfPorts OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of entries present in the device port table for
        this device (which is the same as the number of ports on
        the device)."
    ::= { ausDeviceEntry 10 }

ausDeviceStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Operational status of this device."
    ::= { ausDeviceEntry 11 }

ausDeviceLocation OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Describes the location of this device in a technology-specific
        manner.  This value usually matches the location string on any
        traps involving this device."
    ::= { ausDeviceEntry 12 }

ausDeviceMaxCacheCapable OBJECT-TYPE
    SYNTAX  INTEGER
    {
            False(0),
            True(1),
            Unknown(-1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "."
    ::= { ausDeviceEntry 13 }
    
ausDeviceMaxCacheAssigned OBJECT-TYPE
    SYNTAX  INTEGER
    {
            False(0),
            True(1),
            Unknown(-1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        ""
    ::= { ausDeviceEntry 14 }
    
ausDeviceSataNCQEnabled OBJECT-TYPE
    SYNTAX  INTEGER
    {
            False(0),
            True(1),
            Unknown(-1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "."
    ::= { ausDeviceEntry 15 }
----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Device Port group

  -- Implementation of the Device Port group is mandatory for all
  -- systems.

  -- the Adaptec Universal Storage Device Port table

  -- The Device Port table contains information on the ports
  -- (connections) available from devices.  These ports
  -- are used to connect devices to channels.
  -- The connectivity of a device to channels can be determined
  -- in the aggregate without referring to this table (see
  -- ausDeviceAusChannelIndices), but for detailed information
  -- about the device's connection this table is the source.

ausDevicePortTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusDevicePortEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of device ports."
    ::= { ausDevicePort 1 }

ausDevicePortEntry OBJECT-TYPE
    SYNTAX  AusDevicePortEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A device port entry."
    INDEX   { ausDevicePortIndex }
    ::= { ausDevicePortTable 1 }

AusDevicePortEntry ::=
    SEQUENCE
    {
        ausDevicePortIndex
            INTEGER,
        ausDevicePortUniqueId
            DisplayString,
        ausDevicePortAusDeviceIndex
            INTEGER,
        ausDevicePortAusDevicePortNumber
            INTEGER,
        ausDevicePortAusChannelIndex
            INTEGER,
        ausDevicePortId
            DisplayString,
        ausDevicePortSubId
            DisplayString,
        ausDevicePortWidth
            INTEGER,
        ausDevicePortMaximumTransferRate
            INTEGER,
        ausDevicePortNegotiatedTransferRate
            INTEGER,
        ausDevicePortStatus
            ObjectStatus
    }

ausDevicePortIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each device port beginning with
        1."
    ::= { ausDevicePortEntry 1 }

ausDevicePortUniqueId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "An ID for this device port that is unique across all
        namespaces."
        -- Report 'None' if no unique ID exists.
        -- Report 'Unknown (exists)' if unique ID exists but can't be
        --     determined.
        -- Report 'Unknown' if it is unknown whether a unique ID exists.
    ::= { ausDevicePortEntry 2 }

ausDevicePortAusDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage Device table
        locating the device that contains this port."
    ::= { ausDevicePortEntry 3 }

ausDevicePortAusDevicePortNumber OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Port number within the device referenced by
        ausDevicePortAusDeviceIndex.  Ports are numbered
        sequentially starting with 0."
    ::= { ausDevicePortEntry 4 }

ausDevicePortAusChannelIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage Channel table
        locating the channel to which this device port is
        attached."
    ::= { ausDevicePortEntry 5 }

ausDevicePortId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Port ID number used by this device.  Meaning is
        dependent on channel type.  For example, SCSI channels
        would report device SCSI ID in this field.  The field is
        a string to allow for a wide range of addressing
        schemes.  For non-parallel SCSI this is the virtual SCSI
		targetId"
        -- Report 'None' if port has no concept of ID.
        -- Report 'Unknown' if port ID unknown.
    ::= { ausDevicePortEntry 6 }

ausDevicePortSubId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Port SubId number used by this device.  Meaning is
        dependent on channel type.  For example, SCSI channels
        would report device SCSI LUN in this field.  The field is
        a string to allow for a wide range of addressing
        schemes.  For non-parallel SCSI this is the virtual SCSI
		LUN"
        -- Report 'None' if port has no concept of SubId.
        -- Report 'Unknown' if port SubId unknown.
    ::= { ausDevicePortEntry 7 }

ausDevicePortWidth OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Port width capability of this device.  This may be
        narrower than the channel width - for example, an eight
        bit SCSI device on a sixteen bit SCSI channel."
        -- Report -1 if unknown
    ::= { ausDevicePortEntry 8 }

ausDevicePortMaximumTransferRate OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Maximum transfer rate of this device in megabytes per
        second."
        -- Report -1 if unknown
    ::= { ausDevicePortEntry 9 }

ausDevicePortNegotiatedTransferRate OBJECT-TYPE
    SYNTAX  INTEGER
    {
        	None(-1),
        	5(0),
        	10(5),
        	20(10),
        	40(20),
        	80(40),
        	160(80),
        	320(160),
        	Optimal(30),
        	187(150),
        	375(300),
        	750(600),
        	187(151),
    		375(301),
        	750(601)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Negotiated transfer rate of this device port/ controller
        channel pair in megabytes per second."
        -- Report -1 if unknown
    ::= { ausDevicePortEntry 10 }

ausDevicePortStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Operational status of this device port."
    ::= { ausDevicePortEntry 11 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Storage Device group

  -- Implementation of the Storage Device group is optional

  -- the Adaptec Universal Storage Storage Device table

  -- The Storage Device table contains additional information on storage
  -- devices. Storage devices include hard disks, CD-ROMs, MO drives,
  -- tape drives, and generally anything else that records user data.

ausStorageDeviceTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusStorageDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of storage devices."
    ::= { ausStorageDevice 1 }

ausStorageDeviceEntry OBJECT-TYPE
    SYNTAX  AusStorageDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A storage device entry."
    INDEX   { ausStorageDeviceIndex }
    ::= { ausStorageDeviceTable 1 }

AusStorageDeviceEntry ::=
    SEQUENCE
    {
        ausStorageDeviceIndex
            INTEGER,
        ausStorageDeviceDescription
            DisplayString,
        ausStorageDeviceFormattedCapacity
            INTEGER,
        ausStorageDeviceBlockSize
            INTEGER,
        ausStorageDeviceNumberOfBlocksLow
            INTEGER,
        ausStorageDeviceNumberOfBlocksHigh
            INTEGER,
        ausStorageDeviceRemovableMedia
            INTEGER,
        ausStorageDeviceSmartStatus
            INTEGER,
        ausStorageDeviceMainIndex
            INTEGER
    }

ausStorageDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each storage device."
    ::= { ausStorageDeviceEntry 1 }

ausStorageDeviceDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Free form text for additional description of the storage
        device."
        -- Report 'No additional description' if information unavailable
    ::= { ausStorageDeviceEntry 2 }

ausStorageDeviceFormattedCapacity OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Formatted capacity of this storage device in megabytes."
        -- Report -1 if unknown
    ::= { ausStorageDeviceEntry 3 }

ausStorageDeviceBlockSize OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Physical block size of this storage device in bytes."
        -- Report -1 if unknown
    ::= { ausStorageDeviceEntry 4 }

ausStorageDeviceNumberOfBlocksLow OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of physical blocks for this storage device (least
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausStorageDeviceEntry 5 }

ausStorageDeviceNumberOfBlocksHigh OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of physical blocks for this storage device (most
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausStorageDeviceEntry 6 }

ausStorageDeviceRemovableMedia OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        notSupported(2),
        supportedAndNotLoaded(3),
        supportedAndLoaded(4)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of removable media for this storage device."
    ::= { ausStorageDeviceEntry 7 }

ausStorageDeviceSmartStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        notSupported(2),
        notEnabled(3),
        okay(4),
        errorPredicted(5)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "S.M.A.R.T. status of this storage device."
    ::= { ausStorageDeviceEntry 8 }

ausStorageDeviceMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausDeviceTable of the row
		 that is extended by this row of
		 ausStorageDeviceTable."
    ::= { ausStorageDeviceEntry 9 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Enclosure Device group

  -- Implementation of the Enclosure Device group is optional

  -- the Adaptec Universal Storage Enclosure Device table

  -- The Enclosure Device table contains additional information on enclosure
  -- devices.

ausEnclosureDeviceTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEnclosureDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of enclosure devices."
    ::= { ausEnclosureDevice 1 }

ausEnclosureDeviceEntry OBJECT-TYPE
    SYNTAX  AusEnclosureDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An enclosure device entry."
    INDEX   { ausEnclosureDeviceIndex }
    ::= { ausEnclosureDeviceTable 1 }

AusEnclosureDeviceEntry ::=
    SEQUENCE
    {
        ausEnclosureDeviceIndex
            INTEGER,
        ausEnclosureDeviceDescription
            DisplayString,
        ausEnclosureDeviceProcessorType
            INTEGER,
        ausEnclosureDeviceNumberOfFans
            INTEGER,
        ausEnclosureDeviceNumberOfPowerSupplies
            INTEGER,
        ausEnclosureDeviceNumberOfSlots
            INTEGER,
        ausEnclosureDeviceNumberOfTemperatureSensors
            INTEGER,
        ausEnclosureDeviceIdLow
            INTEGER,
        ausEnclosureDeviceIdHigh
            INTEGER,
        ausEnclosureDeviceStandardRevision
            DisplayString,
        ausEnclosureDevicePowerOnTime
            INTEGER,
        ausEnclosureDevicePowerCycles
            INTEGER,
        ausEnclosureDeviceDoorLock
            OptionStatus,
        ausEnclosureDeviceSpeaker
            OptionStatus,
        ausEnclosureDeviceTemperatureState
            INTEGER,
        ausEnclosureDeviceMainIndex
            INTEGER
    }

ausEnclosureDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each enclosure device."
    ::= { ausEnclosureDeviceEntry 1 }

ausEnclosureDeviceDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Free form text for additional description of the
        enclosure."
        -- Report 'No additional description' if information unavailable
    ::= { ausEnclosureDeviceEntry 2 }

ausEnclosureDeviceProcessorType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        decFault(3),
        saf-te(4),
        ses(5),
        aemi(6)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Standard supported by this enclosure."
    ::= { ausEnclosureDeviceEntry 3 }

ausEnclosureDeviceNumberOfFans OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of fans installed in this enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 4 }

ausEnclosureDeviceNumberOfPowerSupplies OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of power supplies installed in this enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 5 }

ausEnclosureDeviceNumberOfSlots OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of slots installed in this enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 6 }

ausEnclosureDeviceNumberOfTemperatureSensors OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of temperature sensors installed in this
        enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 7 }

ausEnclosureDeviceIdLow OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Unique enclosure ID obtained from inquiry (least
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 8 }

ausEnclosureDeviceIdHigh OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Unique enclosure ID obtained from inquiry (most
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 9 }

ausEnclosureDeviceStandardRevision OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Revision of standard adhered to for this enclosure
        (obtained from inquiry)."
        -- Report 'Unknown' if unknown
    ::= { ausEnclosureDeviceEntry 10 }

ausEnclosureDevicePowerOnTime OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Total number of power on minutes for this enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 11 }

ausEnclosureDevicePowerCycles OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Total number of power cycles for this enclosure."
        -- Report -1 if unknown
    ::= { ausEnclosureDeviceEntry 12 }

ausEnclosureDeviceDoorLock OBJECT-TYPE
    SYNTAX  OptionStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Presence and current status of this enclosure's door
        lock."
    ::= { ausEnclosureDeviceEntry 13 }

ausEnclosureDeviceSpeaker OBJECT-TYPE
    SYNTAX  OptionStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Presence and current status of this enclosure's
        speaker."
    ::= { ausEnclosureDeviceEntry 14 }

ausEnclosureDeviceTemperatureState OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        okay(3),
        tooHot(4)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Indicates state of internal temperature for this
        enclosure."
    ::= { ausEnclosureDeviceEntry 15 }

ausEnclosureDeviceMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausDeviceTable of the row
		 that is extended by this row of
		 ausEnclosureDeviceTable."
    ::= { ausEnclosureDeviceEntry 16 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage external RAID device group

  -- Implementation of the external RAID device group is mandatory if
  -- an external RAID controller is present.

  -- the Adaptec Universal Storage external RAID device table

  -- The external RAID device table contains information on the available
  -- external RAID controllers.

ausExternalRaidDeviceTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusExternalRaidDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of external RAID controllers."
    ::= { ausExternalRaidDevice 1 }

ausExternalRaidDeviceEntry OBJECT-TYPE
    SYNTAX  AusExternalRaidDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An external RAID controller entry."
    INDEX   { ausExternalRaidDeviceIndex }
    ::= { ausExternalRaidDeviceTable 1 }

AusExternalRaidDeviceEntry ::=
    SEQUENCE
    {
        ausExternalRaidDeviceIndex
            INTEGER,
        ausExternalRaidDeviceDescription
            DisplayString,
        ausExternalRaidDeviceNumberOfChannels
            INTEGER,
        ausExternalRaidDeviceInstalledMemory
            INTEGER,
        ausExternalRaidDeviceAudibleAlarmStatus
            OptionStatus,
        ausExternalRaidDeviceBatteryStatus
            BatteryStatus,
        ausExternalRaidDeviceMainIndex
            INTEGER
    }

ausExternalRaidDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each external RAID device."
    ::= { ausExternalRaidDeviceEntry 1 }

ausExternalRaidDeviceDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Free form text for additional description of the
        external RAID controller."
        -- Report 'No additional description' if information unavailable
    ::= { ausExternalRaidDeviceEntry 2 }

ausExternalRaidDeviceNumberOfChannels OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The number of back-end channels present on this external
        RAID controller."
    ::= { ausExternalRaidDeviceEntry 3 }

ausExternalRaidDeviceInstalledMemory OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Installed memory in this external RAID controller in
        megabytes."
        -- Report -1 if unknown
    ::= { ausExternalRaidDeviceEntry 4 }

ausExternalRaidDeviceAudibleAlarmStatus OBJECT-TYPE
    SYNTAX  OptionStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of audible alarm for this external RAID
        controller."
    ::= { ausExternalRaidDeviceEntry 5 }

ausExternalRaidDeviceBatteryStatus OBJECT-TYPE
    SYNTAX  BatteryStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of battery for this external RAID controller."
    ::= { ausExternalRaidDeviceEntry 6 }

ausExternalRaidDeviceMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausDeviceTable of the row
		 that is extended by this row of
		 ausExternalRaidDeviceTable."
    ::= { ausExternalRaidDeviceEntry 7 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Other Device group

  -- Implementation of the Other Device group is optional

  -- the Adaptec Universal Storage Other Device table

  -- The Other Device table contains additional information on other
  -- devices.  Other devices are devices not covered in one of the
  -- previous specific device type tables - that is, they are not
  -- storage devices, not enclosures, and not external RAID.  This
  -- leaves other devices like scanners and printers.

ausOtherDeviceTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusOtherDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of other devices."
    ::= { ausOtherDevice 1 }

ausOtherDeviceEntry OBJECT-TYPE
    SYNTAX  AusOtherDeviceEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An other device entry."
    INDEX   { ausOtherDeviceIndex }
    ::= { ausOtherDeviceTable 1 }

AusOtherDeviceEntry ::=
    SEQUENCE
    {
        ausOtherDeviceIndex
            INTEGER,
        ausOtherDeviceDescription
            DisplayString,
        ausOtherDeviceMainIndex
            INTEGER
    }

ausOtherDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each other device."
    ::= { ausOtherDeviceEntry 1 }

ausOtherDeviceDescription OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Free form text for additional description of this
        device."
        -- Report 'No additional description' if no information available.
    ::= { ausOtherDeviceEntry 2 }

ausOtherDeviceMainIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This is the index into ausDeviceTable of the row
		 that is extended by this row of
		 ausOtherDeviceTable."
    ::= { ausOtherDeviceEntry 3 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Enclosure Fan group

  -- Implementation of the Enclosure Fan group is optional

  -- the Adaptec Universal Storage Enclosure Fan table

  -- The Enclosure Fan table contains information on fans
  -- installed in enclosures.

ausEnclosureFanTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEnclosureFanEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of enclosure fans."
    ::= { ausEnclosureFan 1 }

ausEnclosureFanEntry OBJECT-TYPE
    SYNTAX  AusEnclosureFanEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An enclosure fan entry."
    INDEX   { ausEnclosureFanIndex }
    ::= { ausEnclosureFanTable 1 }

AusEnclosureFanEntry ::=
    SEQUENCE
    {
        ausEnclosureFanIndex
            INTEGER,
        ausEnclosureFanAusEnclosureDeviceIndex
            INTEGER,
        ausEnclosureFanOrdinal
            INTEGER,
        ausEnclosureFanSpeed
            INTEGER,
        ausEnclosureFanStatus
            ObjectStatus
    }

ausEnclosureFanIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each fan."
    ::= { ausEnclosureFanEntry 1 }

ausEnclosureFanAusEnclosureDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The index of the ausEnclosureDeviceTable entry housing
        this fan."
    ::= { ausEnclosureFanEntry 2 }

ausEnclosureFanOrdinal OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Zero-relative fan number within an enclosure."
    ::= { ausEnclosureFanEntry 3 }

ausEnclosureFanSpeed OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Rotational speed of this fan in RPM."
    ::= { ausEnclosureFanEntry 4 }

ausEnclosureFanStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of this fan."
    ::= { ausEnclosureFanEntry 5 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Enclosure Power Supply group

  -- Implementation of the Enclosure Power Supply group is optional

  -- the Adaptec Universal Storage Enclosure Power Supply table

  -- The Enclosure Power Supply table contains information on power supplies
  -- installed in enclosures.

ausEnclosurePowerSupplyTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEnclosurePowerSupplyEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of enclosure power supplies."
    ::= { ausEnclosurePowerSupply 1 }

ausEnclosurePowerSupplyEntry OBJECT-TYPE
    SYNTAX  AusEnclosurePowerSupplyEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An enclosure power supply entry."
    INDEX   { ausEnclosurePowerSupplyIndex }
    ::= { ausEnclosurePowerSupplyTable 1 }

AusEnclosurePowerSupplyEntry ::=
    SEQUENCE
    {
        ausEnclosurePowerSupplyIndex
            INTEGER,
        ausEnclosurePowerSupplyAusEnclosureDeviceIndex
            INTEGER,
        ausEnclosurePowerSupplyOrdinal
            INTEGER,
        ausEnclosurePowerSupplyStatus
            INTEGER
    }

ausEnclosurePowerSupplyIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each power supply."
    ::= { ausEnclosurePowerSupplyEntry 1 }

ausEnclosurePowerSupplyAusEnclosureDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The index of the ausEnclosureDeviceTable entry housing
        this power supply."
    ::= { ausEnclosurePowerSupplyEntry 2 }

ausEnclosurePowerSupplyOrdinal OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Zero-relative power supply number within an enclosure."
    ::= { ausEnclosurePowerSupplyEntry 3 }

ausEnclosurePowerSupplyStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        operationalAndOn(3),
        operationalAndOff(4),
        onAndMalfunctioning(5),
        offAndMalfunctioning(6),
        installed(7),
        notInstalled(8)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Status of this power supply."
    ::= { ausEnclosurePowerSupplyEntry 4 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Enclosure Temperature Sensor group

  -- Implementation of the Enclosure Temperature Sensor group is optional

  -- the Adaptec Universal Storage Enclosure Temperature Sensor table

  -- The Enclosure Temperature Sensor table contains information on
  -- temperature sensors installed in enclosures.

ausEnclosureTemperatureSensorTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEnclosureTemperatureSensorEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of enclosure temperature sensors."
    ::= { ausEnclosureTemperatureSensor 1 }

ausEnclosureTemperatureSensorEntry OBJECT-TYPE
    SYNTAX  AusEnclosureTemperatureSensorEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An enclosure temperature sensor entry."
    INDEX   { ausEnclosureTemperatureSensorIndex }
    ::= { ausEnclosureTemperatureSensorTable 1 }

AusEnclosureTemperatureSensorEntry ::=
    SEQUENCE
    {
        ausEnclosureTemperatureSensorIndex
            INTEGER,
        ausEnclosureTemperatureSensorAusEnclosureDeviceIndex
            INTEGER,
        ausEnclosureTemperatureSensorOrdinal
            INTEGER,
        ausEnclosureTemperatureSensorOverTemperature
            ObjectStatus,
        ausEnclosureTemperatureSensorDegrees
            INTEGER
    }

ausEnclosureTemperatureSensorIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each temperature sensor."
    ::= { ausEnclosureTemperatureSensorEntry 1 }

ausEnclosureTemperatureSensorAusEnclosureDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The index of the ausEnclosureDeviceTable entry housing
        this temperature sensor."
    ::= { ausEnclosureTemperatureSensorEntry 2 }

ausEnclosureTemperatureSensorOrdinal OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Zero-relative temperature sensor number within an
        enclosure."
    ::= { ausEnclosureTemperatureSensorEntry 3 }

ausEnclosureTemperatureSensorOverTemperature OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Specifies whether this temperature sensor has detected
        an over temperature condition."
    ::= { ausEnclosureTemperatureSensorEntry 4 }

ausEnclosureTemperatureSensorDegrees OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Temperature registered by this sensor in degrees
        Fahrenheit."
        -- Report -1 if unknown
    ::= { ausEnclosureTemperatureSensorEntry 5 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Enclosure Slot group

  -- Implementation of the Enclosure Slot group is optional

  -- the Adaptec Universal Storage Enclosure Slot table

  -- The Enclosure Slot table contains information on slots
  -- installed in enclosures.

ausEnclosureSlotTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEnclosureSlotEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of enclosure slots."
    ::= { ausEnclosureSlot 1 }

ausEnclosureSlotEntry OBJECT-TYPE
    SYNTAX  AusEnclosureSlotEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An enclosure slot entry."
    INDEX   { ausEnclosureSlotIndex }
    ::= { ausEnclosureSlotTable 1 }

AusEnclosureSlotEntry ::=
    SEQUENCE
    {
        ausEnclosureSlotIndex
            INTEGER,
        ausEnclosureSlotAusEnclosureDeviceIndex
            INTEGER,
        ausEnclosureSlotOrdinal
            INTEGER,
        ausEnclosureSlotPortId
            DisplayString,
        ausEnclosureSlotInsertions
            INTEGER
    }

ausEnclosureSlotIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each slot."
    ::= { ausEnclosureSlotEntry 1 }

ausEnclosureSlotAusEnclosureDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The index of the ausEnclosureDeviceTable entry housing
        this slot."
    ::= { ausEnclosureSlotEntry 2 }

ausEnclosureSlotOrdinal OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Zero-relative slot number within an enclosure."
    ::= { ausEnclosureSlotEntry 3 }

ausEnclosureSlotPortId OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Port ID number used by the device at this slot.  Meaning
        is dependent on channel type.  For example, SCSI channels
        would report device SCSI ID in this field.  The field is
        a string to allow for a wide range of addressing
        schemes."
        -- Report 'None' if port has no concept of ID.
        -- Report 'Unknown' if port ID unknown.
    ::= { ausEnclosureSlotEntry 4 }

ausEnclosureSlotInsertions OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of device insertions for this slot."
        -- Report -1 if unknown
    ::= { ausEnclosureSlotEntry 5 }

----------------------------------------------------------------------------
-- Logical section of the MIB
----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Array group

  -- Implementation of the Array group is mandatory for all
  -- systems that include RAID controllers.

  -- the Adaptec Universal Storage Array table

  -- The Array table contains information about RAID arrays.

ausArrayTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusArrayEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of arrays."
    ::= { ausArray 1 }

ausArrayEntry OBJECT-TYPE
    SYNTAX  AusArrayEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An array entry."
    INDEX   { ausArrayIndex }
    ::= { ausArrayTable 1 }

AusArrayEntry ::=
    SEQUENCE
    {
        ausArrayIndex
            INTEGER,
        ausArrayName
            DisplayString,
        ausArrayCapacity
            INTEGER,
        ausArrayType
            INTEGER,
        ausArrayStripeSize
            INTEGER,
        ausArrayTaskStatus
            INTEGER,
        ausArrayTaskCompletion
            INTEGER,
        ausArrayTaskPriority
            INTEGER,
        ausArrayHostingControllerType
            INTEGER,
        ausArrayHostingControllerIndex
            INTEGER,
        ausArrayStatus
            ObjectStatus,
        ausArrayState
            INTEGER,
        ausArrayCacheStatus
            INTEGER,
        ausArrayMembership
            INTEGER,
        ausArrayID
            INTEGER,
        ausArrayPMStatus
            INTEGER,
        ausStandbyTimer
            INTEGER,
        ausPowerOffTimer
            INTEGER,
        ausVerifyTimer
            INTEGER,
        ausArrayMaxCachePreferredCacheSetting
            INTEGER,
        ausArrayMaxCacheSetting
            INTEGER
    }

ausArrayIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each array beginning with 1."
    ::= { ausArrayEntry 1 }

ausArrayName OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The name assigned to this array."
        -- Report 'Unknown' if unknown
    ::= { ausArrayEntry 2 }

ausArrayCapacity OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Capacity of this array in megabytes. This is data
        (usable) size, not the sum of all extents."
    -- Report -1 if unknown
    ::= { ausArrayEntry 3 }

ausArrayType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        raid0(3),
        raid1(4),
        raid2(5),
        raid3(6),
        raid4(7),
        raid5(8),
        raid6(9),
        raid10(10),
        raid50(11),
        volume(12),
        volume-of-raid0(13),	-- obsolete, replaced by raid_volume
        volume-of-raid1(14),	-- obsolete, replaced by raid_volume
        volume-of-raid5(15),	-- obsolete, replaced by raid_volume
        raid1e(16),
        raid5ee(17),
        raid-volume(18),
        raid60(19)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "RAID level used by this array."
    ::= { ausArrayEntry 4 }

ausArrayStripeSize OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Stripe size used by this array."
        -- Report -1 if unknown
    ::= { ausArrayEntry 5 }

ausArrayTaskStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        noTaskActive(3),
        reconstruct(4),
        zeroInitialize(5),
        verify(6),
        verifyWithFix(7),
        modification(8),
		copyback(9),
		compaction(10),
		expansion(11),
		snapshotBackup(12)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Task status of this array."
    ::= { ausArrayEntry 6 }

ausArrayTaskCompletion OBJECT-TYPE
    SYNTAX  INTEGER (0..100)
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Percentage completion of running task, if any.  Reports
        as 100 if no task is active."
    ::= { ausArrayEntry 7 }

ausArrayTaskPriority OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        notSupported(3),
        notApplicable(4),
        none(5),
        low(6),
        medium(7),
        high(8)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Priority of the running task (if any)."
    ::= { ausArrayEntry 8 }

ausArrayHostingControllerType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        physicalController(1),
        aggregateController(2),
        externalRaidController(3)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This field tells whether the hosting controller for this
        array is an actual physical controller, an aggregate
        controller (multiple controllers made to look like one
        through software), or an external RAID controller.  This
        field is used to select the meaning of the following
        ausArrayControllerIndex field."
    ::= { ausArrayEntry 9 }

ausArrayHostingControllerIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "This field associates this array with its hosting
        controller.  if the ausArrayControllerType field equals
        physicalController, then this field is an index into the
        ausController table.  If the ausArrayControllerType
        field equals aggregateController, then this field is an
        index into the ausAggregateController table.  If the
        ausArrayControllerType field equal
        externalRaidController, then this field is an index into
        the ausExternalRaidDevice table."
    ::= { ausArrayEntry 10 }

ausArrayStatus OBJECT-TYPE
    SYNTAX  ObjectStatus
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Current health of this array."
    ::= { ausArrayEntry 11 }

ausArrayState OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        optimal(3),
        quickInited(4),
        impacted(5),
        degraded(6),
        failed(7),
        compacted(8)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Current health of this array."
    ::= { ausArrayEntry 12 }

ausArrayCacheStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        unknown(1),
        other(2),
        disabled(3),
        writeBack(4),
        writeThru(5)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Current write cache status of this array."
    ::= { ausArrayEntry 13 }

ausArrayMembership OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "For non-composite arrays (e.g., a straight mirror,
        RAID-1, set) this field is always 0.  For composite
        arrays (e.g.  stripe set of mirrors, RAID-10) this field
        indicates the position in the array hierarchy.  If this
        is the topmost array in the hierarchy, this field will be
        0.  If this is a subordinate array in the hierarchy, this
        field is set to a value equal to the index of the entry
        in the Array Table locating its parent."
    ::= { ausArrayEntry 14 }

ausArrayID OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The ID of this array on its hosting controller."
    ::= { ausArrayEntry 15 }
    
ausArrayPMStatus OBJECT-TYPE
    SYNTAX  INTEGER
    {
        Disabled(0),
        Enabled(1)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       "Power Management Status for the Logical Drive."
    -- Report -1 if unknown
    ::= { ausArrayEntry 16 }

ausStandByTimer OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       "Period of inactivity, from 3 minutes to 3 hours, 
        after which the drives spin rate is lowered. 
        The default is zero."
    -- Report -1 if unknown
    ::= { ausArrayEntry 17 }
    
ausPowerOffTimer OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       "Period of inactivity, from 3 minutes to 3 hours, 
        after which the disk drives are turned off.
        The default is zero."
    -- Report -1 if unknown
    ::= { ausArrayEntry 18 }
  
ausVerifyTimer OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       "Period of inactivity, from 1 hour to 24 hours.
        after which an inactive drive (a drive that is already powered down) 
        is restarted and checked to verify its health. Once the check is 
        completed, the drive is powered down and returns to its inactive state.
        The default is zero."
    -- Report -1 if unknown
    ::= { ausArrayEntry 19 }
    
ausArrayMaxCachePreferredCacheSetting OBJECT-TYPE
    SYNTAX  INTEGER
    {
        NotSupported(0),
        Disabled(1),
        Enabled(2)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       ""
    -- Report -1 if unknown
    ::= { ausArrayEntry 20 }
    
ausArrayMaxCacheSetting OBJECT-TYPE
    SYNTAX  INTEGER
    {
        NotSupported(0),
        Disabled(1),
        Enabled(2)
    }   
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
       ""
    -- Report -1 if unknown
    ::= { ausArrayEntry 21 }

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Disk Extent group

  -- Implementation of the Disk Entent group is mandatory for all
  -- systems that include RAID controllers.

  -- the Adaptec Universal Storage Disk Extent table

  -- The Disk Extent table contains information about disk partitions.
  -- Note that this does not mean partitions as understood by the
  -- operating system, but instead are disk partitions understood by
  -- a RAID controller.  It is possible to describe partitions such
  -- that different pieces of one physical disk drive participate in
  -- different arrays, or even in two different parts of the same
  -- array.

ausExtentTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusExtentEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of disk extents."
    ::= { ausExtent 1 }

ausExtentEntry OBJECT-TYPE
    SYNTAX  AusExtentEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A disk extent entry."
    INDEX   { ausExtentIndex }
    ::= { ausExtentTable 1 }

AusExtentEntry ::=
    SEQUENCE
    {
        ausExtentIndex
            INTEGER,
        ausExtentAusDeviceIndex
            INTEGER,
        ausExtentSize
            INTEGER,
        ausExtentStartingLBALow
            INTEGER,
        ausExtentStartingLBAHigh
            INTEGER,
        ausExtentNumberOfBlocksLow
            INTEGER,
        ausExtentNumberOfBlocksHigh
            INTEGER,
        ausExtentArrayMembership
            INTEGER
    }

ausExtentIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each disk extent beginning with
        1."
    ::= { ausExtentEntry 1 }

ausExtentAusDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage device table
        that describes the physical disk containing this extent."
    ::= { ausExtentEntry 2 }

ausExtentSize OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Size of this extent rounded to nearest megabyte."
        -- Report -1 if unknown
    ::= { ausExtentEntry 3 }

ausExtentStartingLBALow OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Starting disk LBA (logical buffer address) used by this
        extent (least significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausExtentEntry 4 }

ausExtentStartingLBAHigh OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Starting disk LBA (logical buffer address) used by this
        extent (most significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausExtentEntry 5 }

ausExtentNumberOfBlocksLow OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of disk blocks used by this extent (least
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausExtentEntry 6 }

ausExtentNumberOfBlocksHigh OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Number of disk blocks used by this extent (most
        significant 32 bits of 64 bit value)."
        -- Report -1 if unknown
    ::= { ausExtentEntry 7 }

ausExtentArrayMembership OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage array table
        selecting the array of which this extent is a member."
    -- May report 0 for an extent that is visible to the operating system
    -- outside of an array.
    ::= { ausExtentEntry 8 }

-- Note: If the extent size, starting LBA, and number of blocks are
-- all unknown, this table still serves to link a physical disk drive
-- to an array.

----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Spare group

  -- Implementation of the Spare group is mandatory for all
  -- systems that include RAID controllers.

  -- the Adaptec Universal Storage Spare table

  -- The Spare table contains information about sparing relationships
  -- between physical disk drives and arrays or controllers.

ausSpareTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusSpareEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A list of spares."
    ::= { ausSpare 1 }

ausSpareEntry OBJECT-TYPE
    SYNTAX  AusSpareEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A spare entry."
    INDEX   { ausSpareIndex }
    ::= { ausSpareTable 1 }

AusSpareEntry ::=
    SEQUENCE
    {
        ausSpareIndex
            INTEGER,
        ausSpareAusDeviceIndex
            INTEGER,
        ausSpareType
            INTEGER,
        ausSpareAusControllerOrArrayIndex
            INTEGER
    }

ausSpareIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A unique index value for each spare beginning with 1."
    ::= { ausSpareEntry 1 }

ausSpareAusDeviceIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Index into the Adaptec Universal Storage device table
        that describes the physical disk corresponding to this
        spare."
    ::= { ausSpareEntry 2 }

ausSpareType OBJECT-TYPE
    SYNTAX  INTEGER
    {
        global(1),
        dedicated(2),
        externalRaidGlobal(3),
		unknown(4),
		other(5),
		standby(6)
    }
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "Specifies whether this is a global spare (allocated to a
        controller), a dedicated spare (allocated to an array),
        an external RAID global spare (allocated to an
        external RAID controller), or a standby spare (allocated
		to a controller)."
    ::= { ausSpareEntry 3 }

ausSpareAusControllerOrArrayIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "If this is a global spare, this field contains an index
        into the Adaptec Universal Storage controller table
        selecting the controller for which the spare relationship
        exists.  If this is a dedicated spare, this field
        contains an index into the Adaptec Universal Storage
        array table selecting the array for which the spare
        relationship exists.  If this is an external RAID global
        spare, this field contains an index into the Adaptec
        Universal Storage external RAID device table selecting
        the controller for which the spare relationship exists."
    ::= { ausSpareEntry 4 }



----------------------------------------------------------------------------
-- Logging section of the MIB
----------------------------------------------------------------------------

 -- the Adaptec Universal Storage Event Log Count

  -- Implementation of the Event Log Count is mandatory for all
  -- systems.

ausEventLogNumEntries OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The number of entries in the Event Log."
    ::= { ausEventLogCount 1 }

----------------------------------------------------------------------------

  -- the Adaptec Universal Storage Event Log table

  -- Implementation of the Event Log is mandatory for all systems.

  -- The Adaptec Universal Storage Event Log table contains entries for each
  -- event in the log.

  -- The Event Log is not a log of traps generated by the SNMP subagent.
  -- Instead, the Event Log is a log of the events generated by the Adpatec
  -- middleware that the SNMP subagent is a client of.  The Event Log may
  -- be useful for finding additional information not provided via SNMP
  -- traps.

ausEventLogTable OBJECT-TYPE
    SYNTAX  SEQUENCE OF AusEventLogEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A circular list of event log entries.  The number of
        entries is given by the value of eventLogCount.  Current
        maximum event log count is fixed at 256, but could be
        programmable (via MIB variable and/or .INI file) in the
        future."
    ::= { ausEventLog 1 }

ausEventLogEntry OBJECT-TYPE
    SYNTAX  AusEventLogEntry
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "An event log entry."
    INDEX   { ausEventLogIndex }
    ::= { ausEventLogTable 1 }

AusEventLogEntry ::=
    SEQUENCE
    {
      ausEventLogTimeStamp
      	DisplayString,
      ausEventLogString
      	DisplayString,
	ausEventType
		DisplayString,
	ausEvenCode
		INTEGER
    }


ausEventLogTimeStamp OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "The time stamp assigned this event by middleware, in
        UNIX time_t format."
    ::= { ausEventLogEntry 1 }

ausEventLogString OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A text string containing the text of the event as
        generated by middleware."
    ::= { ausEventLogEntry 2 }


ausEventType OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A text string containing the type of the event as
        generated by middleware."
    ::= { ausEventLogEntry 3 }

ausEvenCode OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  read-only
    STATUS  mandatory
    DESCRIPTION
        "A value containing the code of the event as
        generated by middleware."
    ::= { ausEventLogEntry 4 }



----------------------------------------------------------------------------
-- Trap Objects
----------------------------------------------------------------------------

ausTrapObjects   OBJECT IDENTIFIER ::= { ausMIB 9000 }

-- The following are the objects defined for traps

ausTrapMessage OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "Message delivered by the trap."
    ::= { ausTrapObjects 1 }

ausTrapObjectIndex OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"An index into a MIB table specifying the object associated
	 with the trap.  If the index is 0, then an index is not
	 available (for example, for a deleted object)."
    ::= { ausTrapObjects 2 }

ausTrapControllerType OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		aggregateController(1),
		internalController(2),
		externalController(3)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Describes which type of controller generated this trap, and
	 therefore which table is indexed."
    ::= { ausTrapObjects 3 }

ausTrapControllerStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		okay(1),
		noControllersFound(2),
		controllerAdded(3),
		controllerDeleted(4),
		controllerFailover(5),
		commandsNotResponding(6),
		cannotReadControllerInformation(7),
		replaceBattery(8),
		defectiveCache(9),
		firmwareVersionMismatch(10)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the controller that generated this trap."
    ::= { ausTrapObjects 4 }

ausTrapDeviceStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		okay(1),
		deviceAdded(2),
		deviceRemoved(3),
		deviceFailed(4),
		smartEvent(5),
		unsupportedDeviceType(6)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the device that generated this trap."
    ::= { ausTrapObjects 5 }

ausTrapEnclosureStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		enclosureResponding(1),
		enclosureNotResponding(2),
		fanMalfunction(3),
		fanOperational(4),
		fanRemoved(5),
		fanInstalled(6),
		temperatureInRange(7),
		temperatureOutOfRange(8),
		powerSupplyMalfunction(9),
		powerSupplyOperational(10),
		powerSupplyRemoved(11),
		powerSupplyInstalled(12)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the enclosure that generated this trap."
    ::= { ausTrapObjects 6 }

ausTrapEnclosureObjectOrdinal OBJECT-TYPE
    SYNTAX  INTEGER
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Zero relative ordinal number of affected fan, temperature sensor, power supply,
	 slot, etc., in an enclosure.  Field will be -1 if not needed (for example,
	 when the trap refers to the enclosure as a whole rather than a piece
	 of the enclosure)."
    ::= { ausTrapObjects 7 }

ausTrapArrayStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		okay(1),
		critical(2),
		offline(3),
		blocked(4),
		unblocked(5)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the array that generated this trap."
    ::= { ausTrapObjects 8 }

ausTrapArrayTaskStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		rebuilding(1),
		rebuildComplete(2),
		rebuildFailed(3),
		synchronizing(4),
		synchronizationComplete(5),
		synchronizationFailed(6),
		migrating(7),
		migrationComplete(8),
		migrationFailed(9),
		compressing(10),
		compressionComplete(11),
		compressionFailed(12),
		decompressing(13),
		decompressionComplete(14),
		decompressionFailed(15),
		compacting(16),
		compactionComplete(17),
		compactionFailed(18),
		expanding(19),
		expansionComplete(20),
		expansionFailed(21),
		flashCopying(22),
		flashCopyComplete(23),
		flashCopyFailed(24)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the array task that generated this trap."
    ::= { ausTrapObjects 9 }

ausTrapSpareStatus OBJECT-TYPE
    SYNTAX  INTEGER
	    {
		okay(1),
		added(2),
		deleted(3),
		failed(4)
	    }
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
	"Status of the spare that generated this trap."
    ::= { ausTrapObjects 10 }

ausTrapEnumAsText OBJECT-TYPE
    SYNTAX  DisplayString
    ACCESS  not-accessible
    STATUS  mandatory
    DESCRIPTION
        "A string corresponding to a trap enumeration value."
    ::= { ausTrapObjects 11 }

----------------------------------------------------------------------------
-- Trap Definitions
----------------------------------------------------------------------------


-- Any event which does not fall into one of the more specific traps will be
-- handled by the three "other" traps below.
--

ausTrapOtherInformational TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
        ausTrapMessage
    }
    DESCRIPTION
        "Other informational trap message"
--#TYPE "Informational trap message"
--#SUMMARY "%s"
--#ARGUMENTS {0}
--#SEVERITY INFORMATIONAL
    ::= 1001

ausTrapOtherWarning TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
        ausTrapMessage
    }
    DESCRIPTION
        "Other warning trap message"
--#TYPE "Warning trap message"
--#SUMMARY "%s"
--#ARGUMENTS {0}
--#SEVERITY WARNING
    ::= 1002

ausTrapOtherFatal TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
        ausTrapMessage
    }
    DESCRIPTION
        "Other fatal trap message"
--#TYPE "Fatal trap message"
--#SUMMARY "%s"
--#ARGUMENTS {0}
--#SEVERITY FATAL
    ::= 1003

----------------------------------------------------------------------------
-- Device Traps
----------------------------------------------------------------------------

ausTrapDeviceInformation   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapDeviceStatus,
	ausTrapEnumAsText			-- the device status
    }
    DESCRIPTION
        "Informational status of a device"
--#TYPE "Informational status of a device"
--#SUMMARY "A device at row index %d reports: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY INFORMATIONAL
    ::= 1010


ausTrapDeviceWarning   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapDeviceStatus,
	ausTrapEnumAsText			-- the device status
    }
    DESCRIPTION
        "Warning status of a device"
--#TYPE "Warning status of a device"
--#SUMMARY "A device at row index %d warns: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY WARNING
    ::= 1011

ausTrapDeviceFatal     TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapDeviceStatus,
	ausTrapEnumAsText			-- the device status

    }
    DESCRIPTION
        "Fatal status of a device"
--#TYPE "Fatal status of a device"
--#SUMMARY "A device at row index %d has fatal error: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY FATAL
    ::= 1012


----------------------------------------------------------------------------
-- Enclosure Traps
----------------------------------------------------------------------------

ausTrapEnclosureInformation    TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapEnclosureStatus,
	ausTrapEnumAsText,			-- the enclosure status
	ausTrapEnclosureObjectOrdinal
    }
    DESCRIPTION
        "Informational status of an enclosure"
--#TYPE "Informational status of an enclosure"
--#SUMMARY "An enclosure at row index %d reports: %s (enclosure object number: %d)"
--#ARGUMENTS {0, 2, 3}
--#SEVERITY INFORMATIONAL
    ::= 1020

ausTrapEnclosureWarning     TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapEnclosureStatus,
	ausTrapEnumAsText,			-- the enclosure status
	ausTrapEnclosureObjectOrdinal
    }
    DESCRIPTION
        "Warning status of an enclosure"
--#TYPE "Warning status of an enclosure"
--#SUMMARY "An enclosure at row index %d warns: %s (enclosure object number: %d)"
--#ARGUMENTS {0, 2, 3}
--#SEVERITY WARNING
    ::= 1021

ausTrapEnclosureFatal    TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapEnclosureStatus,
	ausTrapEnumAsText,			-- the enclosure status
	ausTrapEnclosureObjectOrdinal
    }
    DESCRIPTION
        "Fatal status of an enclosure"
--#TYPE "Fatal status of an enclosure"
--#SUMMARY "An enclosure at row index %d has fatal error: %s (enclosure object number: %d)"
--#ARGUMENTS {0, 2, 3}
--#SEVERITY FATAL
    ::= 1022

----------------------------------------------------------------------------
-- Array Traps
----------------------------------------------------------------------------


ausTrapArrayInformation   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayStatus,
	ausTrapEnumAsText			-- the array status
    }
    DESCRIPTION
        "Informational status of an array"
--#TYPE "Informational status of an array"
--#SUMMARY "An array at row index %d reports: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY INFORMATIONAL
    ::= 1030

ausTrapArrayWarning   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayStatus,
	ausTrapEnumAsText			-- the array status
    }
    DESCRIPTION
        "Warning status of an array"
--#TYPE "Warning status of an array"
--#SUMMARY "An array at row index %d warns: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY WARNING
    ::= 1031

ausTrapArrayFatal   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayStatus,
	ausTrapEnumAsText			-- the array status
    }
    DESCRIPTION
        "Fatal status of an array"
--#TYPE "Fatal status of an array"
--#SUMMARY "An array at row index %d has fatal error: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY FATAL
    ::= 1032

----------------------------------------------------------------------------
-- Array Task Traps
----------------------------------------------------------------------------

ausTrapArrayTaskInformation   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayTaskStatus,
	ausTrapEnumAsText			-- the array task status
    }
    DESCRIPTION
        "Informational status of an array task"
--#TYPE "Informational status of an array task"
--#SUMMARY "An array at row index %d reports task status: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY INFORMATIONAL
    ::= 1040

ausTrapArrayTaskWarning   TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayTaskStatus,
	ausTrapEnumAsText			-- the array task status
    }
    DESCRIPTION
        "Warning status of an array task"
--#TYPE "Warning status of an array task"
--#SUMMARY "An array at row index %d warns task status: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY WARNING
    ::= 1041

ausTrapArrayTaskFatal    TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapArrayTaskStatus,
	ausTrapEnumAsText			-- the array task status
    }
    DESCRIPTION
        "Fatal status of an array task"
--#TYPE "Fatal status of an array task"
--#SUMMARY "An array at row index %d has fatal task status: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY FATAL
    ::= 1042

----------------------------------------------------------------------------
-- Spare Traps
----------------------------------------------------------------------------

ausTrapSpareInformation  TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapSpareStatus,
	ausTrapEnumAsText			-- the spare status
    }
    DESCRIPTION
        "Informational status of a spare"
--#TYPE "Informational status of a spare"
--#SUMMARY "A spare at row index %d reports: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY INFORMATIONAL
    ::= 1050

ausTrapSpareWarning    TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapSpareStatus,
	ausTrapEnumAsText			-- the spare status
    }
    DESCRIPTION
        "Warning status of a spare"
--#TYPE "Warning status of a spare"
--#SUMMARY "A spare at row index %d warns: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY WARNING
    ::= 1051

ausTrapSpareFatal    TRAP-TYPE
    ENTERPRISE  ausMIB
    VARIABLES
    {
	ausTrapObjectIndex,
	ausTrapSpareStatus,
	ausTrapEnumAsText			-- the spare status
    }
    DESCRIPTION
        "Fatal status of a spare"
--#TYPE "Fatal status of a spare"
--#SUMMARY "A spare at row index %d has fatal error: %s"
--#ARGUMENTS {0, 2}
--#SEVERITY FATAL
    ::= 1052
END
