verif/env/common/coverage/ilu_peu/ilu_peu_ltssm_state_sample.vrh

// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: ilu_peu_ltssm_state_sample.vrh
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
//
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// For the avoidance of doubt, and except that if any non-GPL license
// choice is available it will apply instead, Sun elects to use only
// the General Public License version 2 (GPLv2) at this time for any
// software where a choice of GPL license versions is made
// available with the language indicating that GPLv2 or any later version
// may be used, or where a choice of which version of the GPL is applied is
// otherwise unspecified.
//
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
// CA 95054 USA or visit www.sun.com if you need additional information or
// have any questions.
//
// ========== Copyright Header End ============================================
#define    DETECT_QUIET          5'h00
#define    DETECT_ACT            5'h01
#define    POLL_ACTIVE           5'h02
#define    POLL_COMPLIANCE       5'h03
#define    POLL_CONFIG           5'h04
#define    PRE_DETECT_QUIET      5'h05
#define    DETECT_WAIT           5'h06
#define    CFG_LINKWD_START      5'h07
#define    CFG_LINKWD_ACEPT      5'h08
#define    CFG_LANENUM_WAIT      5'h09
#define    CFG_LANENUM_ACEPT     5'h0A
#define    CFG_COMPLETE          5'h0B
#define    CFG_IDLE              5'h0C
#define    RCVRY_LOCK            5'h0D
#define    RCVRY_RCVRCFG         5'h0E
#define    RCVRY_IDLE            5'h0F
#define    L0                    5'h10
#define    L0S                   5'h11
#define    L123_SEND_EIDLE       5'h12
#define    L1_IDLE               5'h13
#define    L2_IDLE               5'h14
// #define    L2_WAKE               5'h15
#define    DISABLED_ENTRY        5'h16
#define    DISABLED_IDLE         5'h17
#define    DISABLED              5'h18
#define    LPBK_ENTRY            5'h19
#define    LPBK_ACTIVE           5'h1A
#define    LPBK_EXIT             5'h1B
#define    LPBK_EXIT_TIMEOUT     5'h1C
#define    HOT_RESET_ENTRY       5'h1D
#define    HOT_RESET             5'h1F


sample ilu_peu_coverage_ltssm_state_coverage_group.lts_state


{
        state S_DETECT_QUIET             (DETECT_QUIET);
        state s_DETECT_ACT               (DETECT_ACT);
        state s_POLL_ACTIVE              (POLL_ACTIVE);
        state s_POLL_COMPLIANCE          (POLL_COMPLIANCE);
        state s_POLL_CONFIG              (POLL_CONFIG);
        state s_PRE_DETECT_QUIET         (PRE_DETECT_QUIET);
        state s_DETECT_WAIT              (DETECT_WAIT);
        state s_CFG_LINKWD_START         (CFG_LINKWD_START);
        state s_CFG_LINKWD_ACEPT         (CFG_LINKWD_ACEPT);
        state s_CFG_LANENUM_WAIT         (CFG_LANENUM_WAIT);
        state s_CFG_LANENUM_ACEPT        (CFG_LANENUM_ACEPT);
        state s_CFG_COMPLETE             (CFG_COMPLETE);
        state s_CFG_IDLE                 (CFG_IDLE);
        state s_RCVRY_LOCK               (RCVRY_LOCK);
        state s_RCVRY_RCVRCFG            (RCVRY_RCVRCFG);
        state s_RCVRY_IDLE               (RCVRY_IDLE);
        state s_L0                       (L0);
        state s_L0S                      (L0S);
        state s_L123_SEND_EIDLE          (L123_SEND_EIDLE);
        state s_L1_IDLE                  (L1_IDLE);
        state s_L2_IDLE                  (L2_IDLE);
//         state s_L2_WAKE                  (L2_WAKE);
        state s_DISABLED_ENTRY           (DISABLED_ENTRY);
        state s_DISABLED_IDLE            (DISABLED_IDLE);
        state s_DISABLED                 (DISABLED);
        state s_LPBK_ENTRY               (LPBK_ENTRY);
        state s_LPBK_ACTIVE              (LPBK_ACTIVE);
        state s_LPBK_EXIT                (LPBK_EXIT);
        state s_LPBK_EXIT_TIMEOUT        (LPBK_EXIT_TIMEOUT);
        state s_HOT_RESET_ENTRY          (HOT_RESET_ENTRY);
        state s_HOT_RESET              (HOT_RESET);

//        trans    t_DETECT_QUIET_DETECT_QUIET_01           (DETECT_QUIET      ->  DETECT_QUIET);
        trans    t_DETECT_QUIET_DETECT_ACT_02             (DETECT_QUIET      ->  DETECT_ACT);
        trans    t_DETECT_ACT_POLL_ACTIVE_03              (DETECT_ACT        ->  POLL_ACTIVE);
        trans    t_DETECT_ACT_DETECT_QUIET_04             (DETECT_ACT        ->  DETECT_QUIET);
        trans    t_DETECT_ACT_DETECT_WAIT_05              (DETECT_ACT        ->  DETECT_WAIT);
//        trans    t_DETECT_ACT_DETECT_ACT_06               (DETECT_ACT        ->  DETECT_ACT);
        trans    t_POLL_ACTIVE_POLL_CONFIG_07             (POLL_ACTIVE       ->  POLL_CONFIG);
        trans    t_POLL_ACTIVE_POLL_COMPLIANCE_08         (POLL_ACTIVE       ->  POLL_COMPLIANCE);
        trans    t_POLL_ACTIVE_PRE_DETECT_QUIET_09        (POLL_ACTIVE       ->  PRE_DETECT_QUIET);
//        trans    t_POLL_ACTIVE_POLL_ACTIVE_10             (POLL_ACTIVE       ->  POLL_ACTIVE);
        trans    t_POLL_COMPLIANCE_POLL_ACTIVE_11         (POLL_COMPLIANCE   ->  POLL_ACTIVE);
//        trans    t_POLL_COMPLIANCE_POLL_COMPLIANCE_12     (POLL_COMPLIANCE   ->  POLL_COMPLIANCE);
        trans    t_POLL_CONFIG_CFG_LINKWD_START_13        (POLL_CONFIG       ->  CFG_LINKWD_START);
        trans    t_POLL_CONFIG_PRE_DETECT_QUIET_14        (POLL_CONFIG       ->  PRE_DETECT_QUIET);
//        trans    t_POLL_CONFIG_POLL_CONFIG_15             (POLL_CONFIG       ->  POLL_CONFIG);
        trans    t_PRE_DETECT_QUIET_DETECT_QUIET_16       (PRE_DETECT_QUIET  ->  DETECT_QUIET);
//        trans    t_PRE_DETECT_QUIET_PRE_DETECT_QUIET_17   (PRE_DETECT_QUIET  ->  PRE_DETECT_QUIET);
        trans    t_DETECT_WAIT_DETECT_ACT_18              (DETECT_WAIT       ->  DETECT_ACT);
//        trans    t_DETECT_WAIT_DETECT_WAIT_19             (DETECT_WAIT       ->  DETECT_WAIT);
        trans    t_CFG_LINKWD_START_DISABLED_ENTRY_20     (CFG_LINKWD_START  ->  DISABLED_ENTRY);
        trans    t_CFG_LINKWD_START_LPBK_ENTRY_21         (CFG_LINKWD_START  ->  LPBK_ENTRY);
        trans    t_CFG_LINKWD_START_CFG_LINKWD_ACEPT_22   (CFG_LINKWD_START  ->  CFG_LINKWD_ACEPT);
        trans    t_CFG_LINKWD_START_PRE_DETECT_QUIET_23   (CFG_LINKWD_START  ->  PRE_DETECT_QUIET);
//        trans    t_CFG_LINKWD_START_CFG_LINKWD_START_24   (CFG_LINKWD_START  ->  CFG_LINKWD_START);
        trans    t_CFG_LINKWD_ACEPT_CFG_LANENUM_WAIT_25   (CFG_LINKWD_ACEPT  ->  CFG_LANENUM_WAIT);
        trans    t_CFG_LINKWD_ACEPT_PRE_DETECT_QUIET_26   (CFG_LINKWD_ACEPT  ->  PRE_DETECT_QUIET);
//        trans    t_CFG_LINKWD_ACEPT_CFG_LINKWD_ACEPT_27   (CFG_LINKWD_ACEPT  ->  CFG_LINKWD_ACEPT);
//        trans    t_CFG_LANENUM_WAIT_CFG_LINKWD_ACEPT_28   (CFG_LANENUM_WAIT  ->  CFG_LINKWD_ACEPT);
        trans    t_CFG_LANENUM_WAIT_PRE_DETECT_QUIET_29   (CFG_LANENUM_WAIT  ->  PRE_DETECT_QUIET);
//        trans    t_CFG_LANENUM_WAIT_CFG_LANENUM_WAIT_30   (CFG_LANENUM_WAIT  ->  CFG_LANENUM_WAIT);
        trans    t_CFG_LANENUM_ACEPT_CFG_COMPLETE_31      (CFG_LANENUM_ACEPT ->  CFG_COMPLETE);
        trans    t_CFG_LANENUM_ACEPT_CFG_LANENUM_WAIT_32  (CFG_LANENUM_ACEPT ->  CFG_LANENUM_WAIT);
        trans    t_CFG_LANENUM_ACEPT_PRE_DETECT_QUIET_33  (CFG_LANENUM_ACEPT ->  PRE_DETECT_QUIET);
        trans    t_CFG_LANENUM_ACEPT_CFG_LINKWD_ACEPT_34  (CFG_LANENUM_ACEPT ->  CFG_LINKWD_ACEPT);
        trans    t_CFG_COMPLETE_CFG_IDLE_35               (CFG_COMPLETE      ->  CFG_IDLE);
        trans    t_CFG_COMPLETE_PRE_DETECT_QUIET_36       (CFG_COMPLETE      ->  PRE_DETECT_QUIET);
//        trans    t_CFG_COMPLETE_CFG_COMPLETE_37           (CFG_COMPLETE      ->  CFG_COMPLETE);
        trans    t_CFG_IDLE_L0_38                         (CFG_IDLE          ->  L0);
        trans    t_CFG_IDLE_PRE_DETECT_QUIET_39           (CFG_IDLE          ->  PRE_DETECT_QUIET);
//        trans    t_CFG_IDLE_CFG_IDLE_40                   (CFG_IDLE          ->  CFG_IDLE);
        trans    t_RCVRY_LOCK_RCVRY_RCVRCFG_41            (RCVRY_LOCK        ->  RCVRY_RCVRCFG);
        trans    t_RCVRY_LOCK_CFG_LINKWD_START_42         (RCVRY_LOCK        ->  CFG_LINKWD_START);
        trans    t_RCVRY_LOCK_PRE_DETECT_QUIET_43         (RCVRY_LOCK        ->  PRE_DETECT_QUIET);
//        trans    t_RCVRY_LOCK_RCVRY_LOCK_44               (RCVRY_LOCK        ->  RCVRY_LOCK);
        trans    t_RCVRY_RCVRCFG_RCVRY_IDLE_45            (RCVRY_RCVRCFG     ->  RCVRY_IDLE);
        trans    t_RCVRY_RCVRCFG_CFG_LINKWD_START_46      (RCVRY_RCVRCFG     ->  CFG_LINKWD_START);
        trans    t_RCVRY_RCVRCFG_PRE_DETECT_QUIET_47      (RCVRY_RCVRCFG     ->  PRE_DETECT_QUIET);
//        trans    t_RCVRY_RCVRCFG_RCVRY_RCVRCFG_48         (RCVRY_RCVRCFG     ->  RCVRY_RCVRCFG);
        trans    t_RCVRY_IDLE_HOT_RESET_ENTRY_49          (RCVRY_IDLE        ->  HOT_RESET_ENTRY);
        trans    t_RCVRY_IDLE_LPBK_ENTRY_50               (RCVRY_IDLE        ->  LPBK_ENTRY);
        trans    t_RCVRY_IDLE_DISABLED_ENTRY_51           (RCVRY_IDLE        ->  DISABLED_ENTRY);
        trans    t_RCVRY_IDLE_CFG_LINKWD_START_52         (RCVRY_IDLE        ->  CFG_LINKWD_START);
        trans    t_RCVRY_IDLE_PRE_DETECT_QUIET_53         (RCVRY_IDLE        ->  PRE_DETECT_QUIET);
//        trans    t_RCVRY_IDLE_RCVRY_IDLE_53               (RCVRY_IDLE        ->  RCVRY_IDLE);
        trans    t_L0_RCVRY_LOCK_54                       (L0                ->  RCVRY_LOCK);
        trans    t_L0_L123_SEND_EIDLE_55                  (L0                ->  L123_SEND_EIDLE);
        trans    t_L0_L0S_56                              (L0                ->  L0S);
//        trans    t_L0_L0_57                               (L0                ->  L0);
        trans    t_L0S_L0_58                              (L0S               ->  L0);
        trans    t_L0S_RCVRY_LOCK_59                      (L0S               ->  RCVRY_LOCK);
//        trans    t_L0S_L0S_60                             (L0S               ->  L0S);
        trans    t_L123_SEND_EIDLE_L1_IDLE_61             (L123_SEND_EIDLE   ->  L1_IDLE);
        trans    t_L123_SEND_EIDLE_L2_IDLE_62             (L123_SEND_EIDLE   ->  L2_IDLE);
//        trans    t_L123_SEND_EIDLE_L123_SEND_EIDLE_63     (L123_SEND_EIDLE   ->  L123_SEND_EIDLE);
        trans    t_L1_IDLE_RCVRY_LOCK_64                  (L1_IDLE           ->  RCVRY_LOCK);
//        trans    t_L1_IDLE_L1_IDLE_65                     (L1_IDLE           ->  L1_IDLE);
//        trans    t_L2_IDLE_DETECT_QUIET_66                (L2_IDLE           ->  DETECT_QUIET);
//         trans    t_L2_IDLE_L2_WAKE_67                     (L2_IDLE           ->  L2_WAKE);
//        trans    t_L2_IDLE_L2_IDLE_68                     (L2_IDLE           ->  L2_IDLE);
//         trans    t_L2_WAKE_DETECT_QUIET_69                (L2_WAKE           ->  DETECT_QUIET);
//         trans    t_L2_WAKE_L2_WAKE_70                     (L2_WAKE           ->  L2_WAKE);
        trans    t_DISABLED_ENTRY_DISABLED_IDLE_71        (DISABLED_ENTRY    ->  DISABLED_IDLE);
//        trans    t_DISABLED_ENTRY_DISABLED_ENTRY_72       (DISABLED_ENTRY    ->  DISABLED_ENTRY);
        trans    t_DISABLED_IDLE_DISABLED_73              (DISABLED_IDLE     ->  DISABLED);
        trans    t_DISABLED_IDLE_DETECT_QUIET_74          (DISABLED_IDLE     ->  DETECT_QUIET);
//        trans    t_DISABLED_IDLE_DISABLED_IDLE_75         (DISABLED_IDLE     ->  DISABLED_IDLE);
        trans    t_DISABLED_DETECT_QUIET_76               (DISABLED          ->  DETECT_QUIET);
//        trans    t_DISABLED_DISABLED_77                   (DISABLED          ->  DISABLED_IDLE);
        trans    t_LPBK_ENTRY_LPBK_ACTIVE_78              (LPBK_ENTRY        ->  LPBK_ACTIVE);
//        trans    t_LPBK_ENTRY_LPBK_EXIT_79                (LPBK_ENTRY        ->  LPBK_EXIT);
        trans    t_LPBK_ENTRY_PRE_DETECT_QUIET_80         (LPBK_ENTRY        ->  PRE_DETECT_QUIET);
//        trans    t_LPBK_ENTRY_LPBK_ENTRY_81               (LPBK_ENTRY        ->  LPBK_ENTRY);
        trans    t_LPBK_ACTIVE_LPBK_EXIT_82               (LPBK_ACTIVE       ->  LPBK_EXIT);
//        trans    t_LPBK_ACTIVE_LPBK_ACTIVE_83             (LPBK_ACTIVE       ->  LPBK_ACTIVE);
        trans    t_LPBK_EXIT_LPBK_EXIT_TIMEOUT_84         (LPBK_EXIT         ->  LPBK_EXIT_TIMEOUT);
//        trans    t_LPBK_EXIT_LPBK_EXIT_85                 (LPBK_EXIT         ->  LPBK_EXIT);
        trans    t_LPBK_EXIT_TIMEOUT_DETECT_QUIET_86      (LPBK_EXIT_TIMEOUT ->  DETECT_QUIET);
//        trans    t_LPBK_EXIT_TIMEOUT_LPBK_EXIT_TIMEOUT_87 (LPBK_EXIT_TIMEOUT ->  LPBK_EXIT_TIMEOUT);
        trans    t_HOT_RESET_ENTRY_HOT_RESET_88           (HOT_RESET_ENTRY   ->  HOT_RESET);
//        trans    t_HOT_RESET_ENTRY_HOT_RESET_ENTRY_89     (HOT_RESET_ENTRY   ->  HOT_RESET_ENTRY);
        trans    t_HOT_RESET_PRE_DETECT_QUIET_90          (HOT_RESET         ->  PRE_DETECT_QUIET);
//        trans    t_HOT_RESET_HOT_RESET_91                 (HOT_RESET         ->  HOT_RESET);


}