// ========== 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); }