PTI-SWITCH-MIB DEFINITIONS ::= BEGIN

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

        -- "MacAddress"
        --    A 6 octet address in the "canonical" order defined by IEEE
        --    802.1a, i.e., as if it were transmitted least significant
        --    bit first.

        MacAddress ::= OCTET STRING (SIZE (6))

        ptiRowStatus ::=  INTEGER
               {
                  valid(1),
                  notInService(2),
                  notReady(3),
                  createAndGo(4),
                  createAndWait(5),
                  destroy(6)
               }



        PortMirrorState ::= INTEGER
                {
                  enabled(1),
                disabled(2)
              }

        PortMirrorModes ::= INTEGER
                {
                  bcmMirrorDisable(1),
                bcmMirrorL2(2),
                  bcmMirrorL3(3)
                }


        pti             OBJECT IDENTIFIER ::= { enterprises 1556 }
        ptiMgmt  	      OBJECT IDENTIFIER ::= { pti 1 }
        --
		  ptiSwitchManagement   OBJECT IDENTIFIER ::= { ptiMgmt 2 }
		  ptiSwitchSWManagement OBJECT IDENTIFIER ::= { ptiSwitchManagement 1 }
		  ptiSwitchHWManagement OBJECT IDENTIFIER ::= { ptiSwitchManagement 2 }
		  ptiPortMirrorGroup    OBJECT IDENTIFIER ::= { ptiSwitchSWManagement 1 }
        ptiCoSGroup           OBJECT IDENTIFIER ::= { ptiSwitchSWManagement 2 }
        ptiStpGroup           OBJECT IDENTIFIER ::= { ptiSwitchSWManagement 4 }
        ptiIntegrityTestGroup OBJECT IDENTIFIER ::= { ptiSwitchSWManagement 5 }
        ptiArpGroup           OBJECT IDENTIFIER ::= { ptiSwitchSWManagement 6 }

--

--
-- Port Mirroring 
--
--	 This group provides the SNMP user the capabilites to enable/disable
--	 Port Mirroring feature and to set up the mirrored port(s) and mirror-to port
--  and the bcm transfer mode type.
--
--

        ptiPortMirrorPortTable OBJECT-TYPE
            SYNTAX SEQUENCE OF ptiPortMirrorPortTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A table of ports on this system. If ingress/egress traffic
					is to be captured from this port and mirrored to the mirrored-to
               port, then this port will be enabled(1), else it will 
               be disabled (2)."
            ::= { ptiPortMirrorGroup 1 }

        ptiPortMirrorPortTableEntry OBJECT-TYPE
            SYNTAX ptiPortMirrorPortTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of Ingress/Egress ports that are either enabled or disabled."
            INDEX { ptiPortMirrorPortIndex }
            ::= { ptiPortMirrorPortTable 1 }

        ptiPortMirrorPortTableEntry ::= SEQUENCE {
            ptiPortMirrorPortIndex   INTEGER,
            ptiPortMirrorEgressPortState   PortMirrorState,
            ptiPortMirrorIngressPortState   PortMirrorState
        }

        ptiPortMirrorPortIndex OBJECT-TYPE
            SYNTAX INTEGER 
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
                "An index that uniquely identifies this Ingress/Egress port."
            ::= { ptiPortMirrorPortTableEntry 1 }

        ptiPortMirrorEgressPortState OBJECT-TYPE
            SYNTAX PortMirrorState
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
              "DURABLE: { default:disable:all }
               The state enabled(1)/disabled(2) of this port whose 
					out going packets will be sent to the mirrored-to port."
            ::= { ptiPortMirrorPortTableEntry 2 }

        ptiPortMirrorIngressPortState OBJECT-TYPE
            SYNTAX PortMirrorState
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
              "DURABLE: { default:disable:all }
               The state enabled(1)/disabled(2) of this port whose 
					in coming packets will be sent to the mirrored-to port."
            ::= { ptiPortMirrorPortTableEntry 3 }

        ptiPortMirrorMirroredToPort OBJECT-TYPE
            SYNTAX INTEGER
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { 1 }
                 The mirror-to port, that receives the traffic from 
                 mirrored egress and ingress port(s) specified."
            ::= { ptiPortMirrorGroup 3 }

        ptiPortMirrorTransferMode OBJECT-TYPE
            SYNTAX PortMirrorModes
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { 1 }
                 The mode of transfer of this port mirroring entry."
            ::= { ptiPortMirrorGroup 4 }

        ptiPortMirrorCPU OBJECT-TYPE
            SYNTAX INTEGER (0..26)
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { 0 }
					  This value when set to a zero means the feature is disabled.
					  When set to a port number, causes packets sent by the CPU to
					  also be sent to the port number."
            ::= { ptiPortMirrorGroup 5 }



-- 
-- Class of Service MIB objects
--


        ptiCOStype OBJECT-TYPE
            SYNTAX INTEGER {
                   strictPriority(1),
                   weightedRoundRobin(2),
                   roundRobinBoundedDelay(3)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { 1 }
						These are the possible scheduling algorithm types used
                   in Class of Service egress port priority queues. If the 
                   user sets this object to strictPriority(1), then the 
                   highest priority queue is serviced first. Low priority 
                   queues could be starved of service if there are always
                   non-empty high priority queues in this scheme. Setting this
                   object to weightedRoundRobin(2), has the queues serviced
                   in a round robin fashion, servicing each in turn by weight.
                   And setting this object to roundRobinBoundedDelay(3) is a
                   scheduling algorithm which supports real time applications."
            ::= { ptiCoSGroup 1 }


        ptiCOSBoundedDelay OBJECT-TYPE
            SYNTAX INTEGER
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                  "DURABLE: { 0 }
						Set this object in usec for the roundRobinBoundedDelay value."
            ::= { ptiCoSGroup 2 }

        ptiCOSqueueWeightTable OBJECT-TYPE
            SYNTAX SEQUENCE OF ptiCOSqueueWeightEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                  " A list of priority queues for Class of Service"
            ::= { ptiCoSGroup 3 }

        ptiCOSqueueWeightEntry OBJECT-TYPE
            SYNTAX ptiCOSqueueWeightEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "An index of priority queues for Class of Service."
            INDEX { ptiCOSqueueWeightIndex }
            ::= { ptiCOSqueueWeightTable 1 }

        ptiCOSqueueWeightEntry ::= SEQUENCE {
            ptiCOSqueueWeightIndex     INTEGER,
            ptiCOSqueueWeightValue     INTEGER
        }

        ptiCOSqueueWeightIndex OBJECT-TYPE
            SYNTAX INTEGER
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
                "An index that uniquely identifies this queue."
            ::= { ptiCOSqueueWeightEntry 1 }

        ptiCOSqueueWeightValue OBJECT-TYPE
            SYNTAX INTEGER
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					"DURABLE: { 0:all }
                 The weight applied to this priority queue entry." 
            ::= { ptiCOSqueueWeightEntry 2 }



-- Packet Threshold setting requries 4 scalars be set the value rate and the type.  MOVED TO ptiPktThresholdGroup MIB --- not supported in cpc6400
   
                
--
--  STP Group Begins  
--
--	 This group provides the SNMP user the capabilites to enable/disable
--	 Fast Uplink and Fast Port Spanning Tree features.
--
--
        ptiFastUplink OBJECT-TYPE
            SYNTAX INTEGER {  
                enable(1),
                disable(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { disable }
                 This object is used to enable/disable the Fast Uplink
					  option. "
            ::= { ptiStpGroup 1 }

        ptiStpFastPortTable OBJECT-TYPE
            SYNTAX SEQUENCE OF ptiStpFastPortEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of valid port entries and their fast port state."
            ::= { ptiStpGroup 2 }

        ptiStpFastPortEntry OBJECT-TYPE
            SYNTAX ptiStpFastPortEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of ports."
            INDEX { ptiStpFastPortIndex }
            ::= { ptiStpFastPortTable 1 }

        ptiStpFastPortEntry ::= SEQUENCE {
            ptiStpFastPortIndex             INTEGER,
            ptiStpFastPort                  INTEGER
        }

        ptiStpFastPortIndex OBJECT-TYPE
            SYNTAX INTEGER 
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
                "An index that uniquely identifies the port entry in
                 the Stp Fast Port Table."
            ::= { ptiStpFastPortEntry 1 }

        ptiStpFastPort OBJECT-TYPE
            SYNTAX INTEGER{
                enable(1),
                disable(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { default=disable:all }
                 The state of the fast port for this port entry."
            ::= { ptiStpFastPortEntry 2 }


        --
        -- Integrity Test Group 
        --
        -- This group is meant to be a collection of controls and data 
        -- that configure the integrity testing features of this device
        --

        ptiIntegrityTestTable OBJECT-TYPE
            SYNTAX SEQUENCE OF ptiIntegrityTestTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of integrity test entries."
            ::= { ptiIntegrityTestGroup 1 }

        ptiIntegrityTestTableEntry OBJECT-TYPE
            SYNTAX ptiIntegrityTestTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of integrity tests."
            INDEX { ptiIntegrityTestID }
            ::= { ptiIntegrityTestTable 1 }

        ptiIntegrityTestTableEntry ::= SEQUENCE {
            ptiIntegrityTestID			INTEGER,
            ptiIntegrityTestLevel		INTEGER,
            ptiIntegrityTestName		DisplayString,
            ptiIntegrityTestOnOff		INTEGER
        }

        ptiIntegrityTestID OBJECT-TYPE
            SYNTAX INTEGER 
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
                "An index that uniquely identifies this entry in
					the integrity test table."
            ::= { ptiIntegrityTestTableEntry 1 }


        ptiIntegrityTestLevel OBJECT-TYPE
            SYNTAX INTEGER {
                 levelOne(1),
                 levelTwo(2)
            }
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
					"This integrity test is a member of the set of integrity tests
					 within this level. Level one tests run more frequently than 
					 level two tests. "
            ::= { ptiIntegrityTestTableEntry 2 }

        ptiIntegrityTestName OBJECT-TYPE
            SYNTAX DisplayString (SIZE (1..128))
            ACCESS read-only
            STATUS mandatory
            DESCRIPTION
                 "The name of this integrity test."
            ::= { ptiIntegrityTestTableEntry 3 }

        ptiIntegrityTestOnOff OBJECT-TYPE
            SYNTAX INTEGER {
                 on(1),
                 off(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					"DURABLE: { on }
					Turn this test on or off."
            ::= { ptiIntegrityTestTableEntry 4 }


        ptiIntegrityTestActionTable OBJECT-TYPE
            SYNTAX SEQUENCE OF ptiIntegrityTestActionTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of integrity test ids entries."
            ::= { ptiIntegrityTestGroup 2 }

        ptiIntegrityTestActionTableEntry OBJECT-TYPE
            SYNTAX ptiIntegrityTestActionTableEntry
            ACCESS not-accessible
            STATUS mandatory
            DESCRIPTION
                "A list of integrity test actions."
            INDEX { ptiIntegrityTestID }
            ::= { ptiIntegrityTestActionTable 1 }

        ptiIntegrityTestActionTableEntry ::= SEQUENCE {
            ptiIntegrityTestActionIgnore INTEGER,
            ptiIntegrityTestActionLogErrorMsg INTEGER,
            ptiIntegrityTestActionRebootSwitch INTEGER,
            ptiIntegrityTestActionSendTrap INTEGER,
            ptiIntegrityTestActionHaltSystem INTEGER,
            ptiIntegrityTestActionSysOffline INTEGER
        }

        ptiIntegrityTestActionIgnore OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					 "DURABLE: { off }
                 If this object is on(1), then the action to take upon
					  the agent receiving an error event from this integrity test
					  entry, would be to ignore the event."
            ::= { ptiIntegrityTestActionTableEntry 1 }

        ptiIntegrityTestActionLogErrorMsg OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					  "DURABLE: { on }
                  If this object is on(1), then the action to take upon
						the agent receiving an error event from this integrity test
						entry, would be to log an error message."
            ::= { ptiIntegrityTestActionTableEntry 2 }


        ptiIntegrityTestActionRebootSwitch OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                 "DURABLE: { off }
                  If this object is on(1), then the action to take upon
						the agent receiving an error event from this integrity test
						entry, would be to reboot the switch."
            ::= { ptiIntegrityTestActionTableEntry 3 }

        ptiIntegrityTestActionSendTrap OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					  "DURABLE: { off }	
                  If this object is on(1), then the action to take upon
						the agent receiving an error event from this integrity test
						entry, would be to send an SNMP trap."
            ::= { ptiIntegrityTestActionTableEntry 4 }

        ptiIntegrityTestActionHaltSystem OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                 "If this object is on(1), then the action to take upon
						the agent receiving an error event from this integrity test
						entry, would be to halt the system."
            ::= { ptiIntegrityTestActionTableEntry 5 }

        ptiIntegrityTestActionSysOffline OBJECT-TYPE
            SYNTAX INTEGER {
					on(1),
					off(2)
				}
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                 "DURABLE: { off }
                  If this object is on(1), then the action to take upon
						the agent receiving an error event from this integrity test
						entry, would be to take the system offline."
            ::= { ptiIntegrityTestActionTableEntry 6 }


        ptiIntegrityTestLevelOneOnOff OBJECT-TYPE
            SYNTAX INTEGER {
                 on(1),
                 off(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                 "DURABLE: { on }
					   Turn on/off all LevelOne integrity tests."
            ::= { ptiIntegrityTestGroup 3 }

        ptiIntegrityTestLevelTwoOnOff OBJECT-TYPE
            SYNTAX INTEGER {
                 on(1),
                 off(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
					"DURABLE : { off }
					Turn on/off all LevelTwo integrity tests."
            ::= { ptiIntegrityTestGroup 4 }
		
        ptiIntegrityTestLevelOneTimer OBJECT-TYPE
            SYNTAX INTEGER 
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
               "DURABLE: { 200 }
               The time in 100 milli-seconds that is sleeps 
					between the level one integrity tests."
            ::= { ptiIntegrityTestGroup 5 }

-- -------------------------------------------------------------
--  Arp Control objects
-- -------------------------------------------------------------

        ptiArpFlush OBJECT-TYPE
            SYNTAX INTEGER {
                 noop(1),
                 set(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "The administrative control of flushing the ARP table.
                 To flush table entries set(2). When queried this object
                 always reads noop(1)."
            ::= { ptiArpGroup 1 }

        ptiArpVerifyPriorToDelete OBJECT-TYPE
            SYNTAX INTEGER {
                 enable(1),
                 disable(2)
            }
            ACCESS read-write
            STATUS mandatory
            DESCRIPTION
                "DURABLE: { disable }
                 If this object is set to enable(1), the ARP table entries
                 will be verified prior to deletion, otherwise when
                 set disable(2), there entry will just be deleted."
            ::= { ptiArpGroup 2 }


END