Subversion Repositories openmsp430

//----------------------------------------------------------------------------

// Copyright (C) 2009 , Olivier Girard

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions

// are met:

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright

//       notice, this list of conditions and the following disclaimer in the

//       documentation and/or other materials provided with the distribution.

//     * Neither the name of the authors nor the names of its contributors

//       may be used to endorse or promote products derived from this software

//       without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,

// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

// THE POSSIBILITY OF SUCH DAMAGE

//

//----------------------------------------------------------------------------

//

// *File Name: omsp_clock_module.v

//

// *Module Description:

//                       Basic clock module implementation.

//

// *Author(s):

//              - Olivier Girard,    olgirard@gmail.com

//

//----------------------------------------------------------------------------

// $Rev$

// $LastChangedBy$

// $LastChangedDate$

//----------------------------------------------------------------------------

`ifdef OMSP_NO_INCLUDE

`else

`include "openMSP430_defines.v"

`endif

module  omsp_clock_module (

// OUTPUTs

    aclk,                             // ACLK

    aclk_en,                          // ACLK enable

    cpu_en_s,                         // Enable CPU code execution (synchronous)

    cpu_mclk,                         // Main system CPU only clock

    dma_mclk,                         // Main system DMA and/or CPU clock

    dbg_clk,                          // Debug unit clock

    dbg_en_s,                         // Debug interface enable (synchronous)

    dbg_rst,                          // Debug unit reset

    dco_enable,                       // Fast oscillator enable

    dco_wkup,                         // Fast oscillator wake-up (asynchronous)

    lfxt_enable,                      // Low frequency oscillator enable

    lfxt_wkup,                        // Low frequency oscillator wake-up (asynchronous)

    per_dout,                         // Peripheral data output

    por,                              // Power-on reset

    puc_pnd_set,                      // PUC pending set for the serial debug interface

    puc_rst,                          // Main system reset

    smclk,                            // SMCLK

    smclk_en,                         // SMCLK enable

// INPUTs

    cpu_en,                           // Enable CPU code execution (asynchronous)

    cpuoff,                           // Turns off the CPU

    dbg_cpu_reset,                    // Reset CPU from debug interface

    dbg_en,                           // Debug interface enable (asynchronous)

    dco_clk,                          // Fast oscillator (fast clock)

    lfxt_clk,                         // Low frequency oscillator (typ 32kHz)

    mclk_dma_enable,                  // DMA Sub-System Clock enable

    mclk_dma_wkup,                    // DMA Sub-System Clock wake-up (asynchronous)

    mclk_enable,                      // Main System Clock enable

    mclk_wkup,                        // Main System Clock wake-up (asynchronous)

    oscoff,                           // Turns off LFXT1 clock input

    per_addr,                         // Peripheral address

    per_din,                          // Peripheral data input

    per_en,                           // Peripheral enable (high active)

    per_we,                           // Peripheral write enable (high active)

    reset_n,                          // Reset Pin (low active, asynchronous)

    scan_enable,                      // Scan enable (active during scan shifting)

    scan_mode,                        // Scan mode

    scg0,                             // System clock generator 1. Turns off the DCO

    scg1,                             // System clock generator 1. Turns off the SMCLK

    wdt_reset                         // Watchdog-timer reset

);

// OUTPUTs

//=========

output              aclk;             // ACLK

output              aclk_en;          // ACLK enable

output              cpu_en_s;         // Enable CPU code execution (synchronous)

output              cpu_mclk;         // Main system CPU only clock

output              dma_mclk;         // Main system DMA and/or CPU clock

output              dbg_clk;          // Debug unit clock

output              dbg_en_s;         // Debug unit enable (synchronous)

output              dbg_rst;          // Debug unit reset

output              dco_enable;       // Fast oscillator enable

output              dco_wkup;         // Fast oscillator wake-up (asynchronous)

output              lfxt_enable;      // Low frequency oscillator enable

output              lfxt_wkup;        // Low frequency oscillator wake-up (asynchronous)

output       [15:0] per_dout;         // Peripheral data output

output              por;              // Power-on reset

output              puc_pnd_set;      // PUC pending set for the serial debug interface

output              puc_rst;          // Main system reset

output              smclk;            // SMCLK

output              smclk_en;         // SMCLK enable

// INPUTs

//=========

input               cpu_en;           // Enable CPU code execution (asynchronous)

input               cpuoff;           // Turns off the CPU

input               dbg_cpu_reset;    // Reset CPU from debug interface

input               dbg_en;           // Debug interface enable (asynchronous)

input               dco_clk;          // Fast oscillator (fast clock)

input               lfxt_clk;         // Low frequency oscillator (typ 32kHz)

input               mclk_dma_enable;  // DMA Sub-System Clock enable

input               mclk_dma_wkup;    // DMA Sub-System Clock wake-up (asynchronous)

input               mclk_enable;      // Main System Clock enable

input               mclk_wkup;        // Main System Clock wake-up (asynchronous)

input               oscoff;           // Turns off LFXT1 clock input

input        [13:0] per_addr;         // Peripheral address

input        [15:0] per_din;          // Peripheral data input

input               per_en;           // Peripheral enable (high active)

input         [1:0] per_we;           // Peripheral write enable (high active)

input               reset_n;          // Reset Pin (low active, asynchronous)

input               scan_enable;      // Scan enable (active during scan shifting)

input               scan_mode;        // Scan mode

input               scg0;             // System clock generator 1. Turns off the DCO

input               scg1;             // System clock generator 1. Turns off the SMCLK

input               wdt_reset;        // Watchdog-timer reset

//=============================================================================

// 1)  WIRES & PARAMETER DECLARATION

//=============================================================================

// Register base address (must be aligned to decoder bit width)

parameter       [14:0] BASE_ADDR   = 15'h0050;

// Decoder bit width (defines how many bits are considered for address decoding)

parameter              DEC_WD      =  4;

// Register addresses offset

parameter [DEC_WD-1:0] BCSCTL1     =  'h7,

                       BCSCTL2     =  'h8;

// Register one-hot decoder utilities

parameter              DEC_SZ      =  (1 << DEC_WD);

parameter [DEC_SZ-1:0] BASE_REG    =  {{DEC_SZ-1{1'b0}}, 1'b1};

// Register one-hot decoder

parameter [DEC_SZ-1:0] BCSCTL1_D   = (BASE_REG << BCSCTL1),

                       BCSCTL2_D   = (BASE_REG << BCSCTL2);

// Local wire declarations

wire nodiv_mclk;

wire nodiv_smclk;

//============================================================================

// 2)  REGISTER DECODER

//============================================================================

// Local register selection

wire              reg_sel      =  per_en & (per_addr[13:DEC_WD-1]==BASE_ADDR[14:DEC_WD]);

// Register local address

wire [DEC_WD-1:0] reg_addr     =  {1'b0, per_addr[DEC_WD-2:0]};

// Register address decode

wire [DEC_SZ-1:0] reg_dec      = (BCSCTL1_D  &  {DEC_SZ{(reg_addr==(BCSCTL1 >>1))}}) |

                                 (BCSCTL2_D  &  {DEC_SZ{(reg_addr==(BCSCTL2 >>1))}});

// Read/Write probes

wire              reg_lo_write =  per_we[0] & reg_sel;

wire              reg_hi_write =  per_we[1] & reg_sel;

wire              reg_read     = ~|per_we   & reg_sel;

// Read/Write vectors

wire [DEC_SZ-1:0] reg_hi_wr    = reg_dec & {DEC_SZ{reg_hi_write}};

wire [DEC_SZ-1:0] reg_lo_wr    = reg_dec & {DEC_SZ{reg_lo_write}};

wire [DEC_SZ-1:0] reg_rd       = reg_dec & {DEC_SZ{reg_read}};

//============================================================================

// 3) REGISTERS

//============================================================================

// BCSCTL1 Register

//--------------

reg  [7:0] bcsctl1;

wire       bcsctl1_wr  = BCSCTL1[0] ? reg_hi_wr[BCSCTL1] : reg_lo_wr[BCSCTL1];

wire [7:0] bcsctl1_nxt = BCSCTL1[0] ? per_din[15:8]      : per_din[7:0];

`ifdef ASIC_CLOCKING

  `ifdef ACLK_DIVIDER

wire [7:0] divax_mask      = 8'h30;

  `else

wire [7:0] divax_mask      = 8'h00;

  `endif

  `ifdef DMA_IF_EN

    `ifdef CPUOFF_EN

wire [7:0] dma_cpuoff_mask = 8'h01;

    `else

wire [7:0] dma_cpuoff_mask = 8'h00;

    `endif

    `ifdef OSCOFF_EN

wire [7:0] dma_oscoff_mask = 8'h02;

    `else

wire [7:0] dma_oscoff_mask = 8'h00;

    `endif

    `ifdef SCG0_EN

wire [7:0] dma_scg0_mask   = 8'h04;

    `else

wire [7:0] dma_scg0_mask   = 8'h00;

    `endif

    `ifdef SCG1_EN

wire [7:0] dma_scg1_mask   = 8'h08;

    `else

wire [7:0] dma_scg1_mask   = 8'h00;

    `endif

  `else

wire [7:0] dma_cpuoff_mask = 8'h00;

wire [7:0] dma_scg0_mask   = 8'h00;

wire [7:0] dma_scg1_mask   = 8'h00;

wire [7:0] dma_oscoff_mask = 8'h00;

  `endif

`else

wire [7:0] divax_mask      = 8'h30;

wire [7:0] dma_cpuoff_mask = 8'h00;

wire [7:0] dma_scg0_mask   = 8'h00;

  `ifdef DMA_IF_EN

wire [7:0] dma_oscoff_mask = 8'h02;

wire [7:0] dma_scg1_mask   = 8'h08;

  `else

wire [7:0] dma_oscoff_mask = 8'h00;

wire [7:0] dma_scg1_mask   = 8'h00;

  `endif

`endif

always @ (posedge dma_mclk or posedge puc_rst)

  if (puc_rst)          bcsctl1  <=  8'h00;

  else if (bcsctl1_wr)  bcsctl1  <=  bcsctl1_nxt & (divax_mask      |

                                                    dma_cpuoff_mask | dma_oscoff_mask |

                                                    dma_scg0_mask   | dma_scg1_mask   ); // Mask unused bits

// BCSCTL2 Register

//--------------

reg  [7:0] bcsctl2;

wire       bcsctl2_wr    = BCSCTL2[0] ? reg_hi_wr[BCSCTL2] : reg_lo_wr[BCSCTL2];

wire [7:0] bcsctl2_nxt   = BCSCTL2[0] ? per_din[15:8]      : per_din[7:0];

`ifdef MCLK_MUX

wire [7:0] selmx_mask = 8'h80;

`else

wire [7:0] selmx_mask = 8'h00;

`endif

`ifdef MCLK_DIVIDER

wire [7:0] divmx_mask = 8'h30;

`else

wire [7:0] divmx_mask = 8'h00;

`endif

`ifdef ASIC_CLOCKING

  `ifdef SMCLK_MUX

wire [7:0] sels_mask  = 8'h08;

  `else

wire [7:0] sels_mask  = 8'h00;

  `endif

  `ifdef SMCLK_DIVIDER

wire [7:0] divsx_mask = 8'h06;

  `else

wire [7:0] divsx_mask = 8'h00;

  `endif

`else

wire [7:0] sels_mask  = 8'h08;

wire [7:0] divsx_mask = 8'h06;

`endif

always @ (posedge dma_mclk or posedge puc_rst)

  if (puc_rst)          bcsctl2  <=  8'h00;

  else if (bcsctl2_wr)  bcsctl2  <=  bcsctl2_nxt & ( sels_mask  | divsx_mask |

                                                     selmx_mask | divmx_mask); // Mask unused bits

//============================================================================

// 4) DATA OUTPUT GENERATION

//============================================================================

// Data output mux

wire [15:0] bcsctl1_rd   = {8'h00, (bcsctl1  & {8{reg_rd[BCSCTL1]}})}  << (8 & {4{BCSCTL1[0]}});

wire [15:0] bcsctl2_rd   = {8'h00, (bcsctl2  & {8{reg_rd[BCSCTL2]}})}  << (8 & {4{BCSCTL2[0]}});

wire [15:0] per_dout =  bcsctl1_rd   |

                        bcsctl2_rd;

//=============================================================================

// 5)  DCO_CLK / LFXT_CLK INTERFACES (WAKEUP, ENABLE, ...)

//=============================================================================

`ifdef ASIC_CLOCKING

   wire cpuoff_and_mclk_enable;

   wire cpuoff_and_mclk_dma_enable;

   wire cpuoff_and_mclk_dma_wkup;

  `ifdef CPUOFF_EN

   omsp_and_gate and_cpuoff_mclk_en       (.y(cpuoff_and_mclk_enable),     .a(cpuoff),               .b(mclk_enable));

    `ifdef DMA_IF_EN

   omsp_and_gate and_cpuoff_mclk_dma_en   (.y(cpuoff_and_mclk_dma_enable), .a(bcsctl1[`DMA_CPUOFF]), .b(mclk_dma_enable));

   omsp_and_gate and_cpuoff_mclk_dma_wkup (.y(cpuoff_and_mclk_dma_wkup),   .a(bcsctl1[`DMA_CPUOFF]), .b(mclk_dma_wkup));

    `else

   assign cpuoff_and_mclk_dma_enable  = 1'b0;

   assign cpuoff_and_mclk_dma_wkup    = 1'b0;

    `endif

  `else

   assign cpuoff_and_mclk_enable      = 1'b0;

   assign cpuoff_and_mclk_dma_enable  = 1'b0;

   assign cpuoff_and_mclk_dma_wkup    = 1'b0;

   wire   UNUSED_cpuoff               = cpuoff;

  `endif

   wire scg0_and_mclk_dma_enable;

   wire scg0_and_mclk_dma_wkup;

  `ifdef DMA_IF_EN

    `ifdef SCG0_EN

   omsp_and_gate and_scg0_mclk_dma_en     (.y(scg0_and_mclk_dma_enable),   .a(bcsctl1[`DMA_SCG0]),   .b(mclk_dma_enable));

   omsp_and_gate and_scg0_mclk_dma_wkup   (.y(scg0_and_mclk_dma_wkup),     .a(bcsctl1[`DMA_SCG0]),   .b(mclk_dma_wkup));

    `else

   assign scg0_and_mclk_dma_enable    = 1'b0;

   assign scg0_and_mclk_dma_wkup      = 1'b0;

   wire   UNUSED_scg0_mclk_dma_wkup   = mclk_dma_wkup;

    `endif

  `else

   assign scg0_and_mclk_dma_enable    = 1'b0;

   assign scg0_and_mclk_dma_wkup      = 1'b0;

  `endif

   wire scg1_and_mclk_dma_enable;

   wire scg1_and_mclk_dma_wkup;

  `ifdef DMA_IF_EN

    `ifdef SCG1_EN

   omsp_and_gate and_scg1_mclk_dma_en     (.y(scg1_and_mclk_dma_enable),   .a(bcsctl1[`DMA_SCG1]),   .b(mclk_dma_enable));

   omsp_and_gate and_scg1_mclk_dma_wkup   (.y(scg1_and_mclk_dma_wkup),     .a(bcsctl1[`DMA_SCG1]),   .b(mclk_dma_wkup));

    `else

   assign scg1_and_mclk_dma_enable    = 1'b0;

   assign scg1_and_mclk_dma_wkup      = 1'b0;

   wire   UNUSED_scg1_mclk_dma_wkup   = mclk_dma_wkup;

    `endif

  `else

   assign scg1_and_mclk_dma_enable    = 1'b0;

   assign scg1_and_mclk_dma_wkup      = 1'b0;

  `endif

   wire oscoff_and_mclk_dma_enable;

   wire oscoff_and_mclk_dma_wkup;

  `ifdef DMA_IF_EN

    `ifdef OSCOFF_EN

   omsp_and_gate and_oscoff_mclk_dma_en   (.y(oscoff_and_mclk_dma_enable), .a(bcsctl1[`DMA_OSCOFF]), .b(mclk_dma_enable));

   omsp_and_gate and_oscoff_mclk_dma_wkup (.y(oscoff_and_mclk_dma_wkup),   .a(bcsctl1[`DMA_OSCOFF]), .b(mclk_dma_wkup));

    `else

   assign oscoff_and_mclk_dma_enable  = 1'b0;

   assign oscoff_and_mclk_dma_wkup    = 1'b0;

   wire   UNUSED_oscoff_mclk_dma_wkup = mclk_dma_wkup;

    `endif

  `else

   assign oscoff_and_mclk_dma_enable  = 1'b0;

   assign oscoff_and_mclk_dma_wkup    = 1'b0;

  wire  UNUSED_mclk_dma_wkup          = mclk_dma_wkup;

  `endif

`else

  wire  UNUSED_cpuoff                 = cpuoff;

  wire  UNUSED_mclk_enable            = mclk_enable;

  wire  UNUSED_mclk_dma_wkup          = mclk_dma_wkup;

`endif

//-----------------------------------------------------------

// 5.1) HIGH SPEED SYSTEM CLOCK GENERATOR (DCO_CLK)

//-----------------------------------------------------------

// Note1: switching off the DCO osillator is only

//        supported in ASIC mode with SCG0 low power mode

//

// Note2: unlike the original MSP430 specification,

//        we allow to switch off the DCO even

//        if it is selected by MCLK or SMCLK.

wire por_a;

wire dco_wkup;

wire cpu_en_wkup;

`ifdef SCG0_EN

   // The DCO oscillator is synchronously disabled if:

   //      - the cpu pin is disabled (in that case, wait for mclk_enable==0)

   //      - the debug interface is disabled

   //      - SCG0 is set (in that case, wait for the mclk_enable==0 if selected by SELMx)

   //

   // Note that we make extensive use of the AND gate module in order

   // to prevent glitch propagation on the wakeup logic cone.

   wire cpu_enabled_with_dco;

   wire dco_not_enabled_by_dbg;

   wire dco_disable_by_scg0;

   wire dco_disable_by_cpu_en;

   wire dco_enable_nxt;

   omsp_and_gate and_dco_dis1 (.y(cpu_enabled_with_dco),   .a(~bcsctl2[`SELMx]),     .b(cpuoff_and_mclk_enable));

   omsp_and_gate and_dco_dis2 (.y(dco_not_enabled_by_dbg), .a(~dbg_en_s),            .b(~(cpu_enabled_with_dco | scg0_and_mclk_dma_enable)));

   omsp_and_gate and_dco_dis3 (.y(dco_disable_by_scg0),    .a(scg0),                 .b(dco_not_enabled_by_dbg));

   omsp_and_gate and_dco_dis4 (.y(dco_disable_by_cpu_en),  .a(~cpu_en_s),            .b(~mclk_enable));

   omsp_and_gate and_dco_dis5 (.y(dco_enable_nxt),         .a(~dco_disable_by_scg0), .b(~dco_disable_by_cpu_en));

   // Register to prevent glitch propagation

   reg  dco_disable;

   wire dco_wkup_set_scan_observe;

   always @(posedge nodiv_mclk or posedge por)

   if (por) dco_disable <= 1'b1;

   else     dco_disable <= ~dco_enable_nxt | dco_wkup_set_scan_observe;

   // Optional scan repair

   wire dco_clk_n;

   `ifdef SCAN_REPAIR_INV_CLOCKS

      omsp_scan_mux scan_mux_repair_dco_clk_n (

                                               .scan_mode    (scan_mode),

                                               .data_in_scan ( dco_clk),

                                               .data_in_func (~dco_clk),

                                               .data_out     ( dco_clk_n)

                                              );

   `else

      assign dco_clk_n = ~dco_clk;

   `endif

   // Note that a synchronizer is required if the MCLK mux is included

   `ifdef MCLK_MUX

      omsp_sync_cell sync_cell_dco_disable (

         .data_out  (dco_enable),

         .data_in   (~dco_disable),

         .clk       (dco_clk_n),

         .rst       (por)

      );

   `else

      // Optional scan repair

      wire nodiv_mclk_n;

      `ifdef SCAN_REPAIR_INV_CLOCKS

         omsp_scan_mux scan_mux_repair_nodiv_mclk_n (

                                                     .scan_mode    (scan_mode),

                                                     .data_in_scan ( nodiv_mclk),

                                                     .data_in_func (~nodiv_mclk),

                                                     .data_out     ( nodiv_mclk_n)

                                                    );

      `else

         assign nodiv_mclk_n = ~nodiv_mclk;

      `endif

      // Re-time DCO enable with MCLK falling edge

      reg  dco_enable;

      always @(posedge nodiv_mclk_n or posedge por)

      if (por) dco_enable <= 1'b0;

      else     dco_enable <= ~dco_disable;

   `endif

   // The DCO oscillator will get an asynchronous wakeup if:

   //      - the MCLK  generates a wakeup (only if the MCLK mux selects dco_clk)

   //      - if the DCO wants to be synchronously enabled (i.e dco_enable_nxt=1)

   wire dco_mclk_wkup;

   wire dco_en_wkup;

   omsp_and_gate and_dco_mclk_wkup (.y(dco_mclk_wkup), .a(mclk_wkup),   .b(~bcsctl2[`SELMx]));

   omsp_and_gate and_dco_en_wkup   (.y(dco_en_wkup),   .a(~dco_enable), .b(dco_enable_nxt));

   wire dco_wkup_set = dco_mclk_wkup | scg0_and_mclk_dma_wkup | dco_en_wkup | cpu_en_wkup;

   // Scan MUX for the asynchronous SET

   wire dco_wkup_set_scan;

   omsp_scan_mux scan_mux_dco_wkup (

                                    .scan_mode    (scan_mode),

                                    .data_in_scan (por_a),

                                    .data_in_func (dco_wkup_set | por),

                                    .data_out     (dco_wkup_set_scan)

                                   );

   // Scan MUX to increase coverage

   omsp_scan_mux scan_mux_dco_wkup_observe (

                                            .scan_mode    (scan_mode),

                                            .data_in_scan (dco_wkup_set),

                                            .data_in_func (1'b0),

                                            .data_out     (dco_wkup_set_scan_observe)

                                           );

   // The wakeup is asynchronously set, synchronously released

   wire dco_wkup_n;

   omsp_sync_cell sync_cell_dco_wkup (

       .data_out  (dco_wkup_n),

       .data_in   (1'b1),

       .clk       (dco_clk_n),

       .rst       (dco_wkup_set_scan)

   );

   omsp_and_gate and_dco_wkup (.y(dco_wkup), .a(~dco_wkup_n), .b(cpu_en));

`else

   assign dco_enable          = 1'b1;

   assign dco_wkup            = 1'b1;

   wire   UNUSED_scg0         = scg0;

   wire   UNUSED_cpu_en_wkup1 = cpu_en_wkup;

`endif

//-----------------------------------------------------------

// 5.2) LOW FREQUENCY CRYSTAL CLOCK GENERATOR (LFXT_CLK)

//-----------------------------------------------------------

// ASIC MODE

//------------------------------------------------

// Note: unlike the original MSP430 specification,

//       we allow to switch off the LFXT even

//       if it is selected by MCLK or SMCLK.

`ifdef ASIC_CLOCKING

`ifdef OSCOFF_EN

   // The LFXT is synchronously disabled if:

   //      - the cpu pin is disabled (in that case, wait for mclk_enable==0)

   //      - the debug interface is disabled

   //      - OSCOFF is set (in that case, wait for the mclk_enable==0 if selected by SELMx)

   wire cpu_enabled_with_lfxt;

   wire lfxt_not_enabled_by_dbg;

   wire lfxt_disable_by_oscoff;

   wire lfxt_disable_by_cpu_en;

   wire lfxt_enable_nxt;

   omsp_and_gate and_lfxt_dis1 (.y(cpu_enabled_with_lfxt),   .a(bcsctl2[`SELMx]),         .b(cpuoff_and_mclk_enable));

   omsp_and_gate and_lfxt_dis2 (.y(lfxt_not_enabled_by_dbg), .a(~dbg_en_s),               .b(~(cpu_enabled_with_lfxt | oscoff_and_mclk_dma_enable)));

   omsp_and_gate and_lfxt_dis3 (.y(lfxt_disable_by_oscoff),  .a(oscoff),                  .b(lfxt_not_enabled_by_dbg));

   omsp_and_gate and_lfxt_dis4 (.y(lfxt_disable_by_cpu_en),  .a(~cpu_en_s),               .b(~mclk_enable));

   omsp_and_gate and_lfxt_dis5 (.y(lfxt_enable_nxt),         .a(~lfxt_disable_by_oscoff), .b(~lfxt_disable_by_cpu_en));

   // Register to prevent glitch propagation

   reg  lfxt_disable;

   wire lfxt_wkup_set_scan_observe;

   always @(posedge nodiv_mclk or posedge por)

   if (por) lfxt_disable <= 1'b1;

   else     lfxt_disable <= ~lfxt_enable_nxt | lfxt_wkup_set_scan_observe;

   // Optional scan repair

   wire lfxt_clk_n;

   `ifdef SCAN_REPAIR_INV_CLOCKS

      omsp_scan_mux scan_mux_repair_lfxt_clk_n (

                                                  .scan_mode    (scan_mode),

                                                  .data_in_scan ( lfxt_clk),

                                                  .data_in_func (~lfxt_clk),

                                                  .data_out     ( lfxt_clk_n)

                                                 );

   `else

      assign lfxt_clk_n = ~lfxt_clk;

   `endif

   // Synchronize the OSCOFF control signal to the LFXT clock domain

   omsp_sync_cell sync_cell_lfxt_disable (

      .data_out  (lfxt_enable),

      .data_in   (~lfxt_disable),

      .clk       (lfxt_clk_n),

      .rst       (por)

   );

   // The LFXT will get an asynchronous wakeup if:

   //      - the MCLK  generates a wakeup (only if the MCLK  mux selects lfxt_clk)

   //      - if the LFXT wants to be synchronously enabled (i.e lfxt_enable_nxt=1)

   wire lfxt_mclk_wkup;

   wire lfxt_en_wkup;

   omsp_and_gate and_lfxt_mclk_wkup (.y(lfxt_mclk_wkup), .a(mclk_wkup),    .b(bcsctl2[`SELMx]));

   omsp_and_gate and_lfxt_en_wkup   (.y(lfxt_en_wkup),   .a(~lfxt_enable), .b(lfxt_enable_nxt));

   wire   lfxt_wkup_set  = lfxt_mclk_wkup | oscoff_and_mclk_dma_wkup | lfxt_en_wkup | cpu_en_wkup;

   // Scan MUX for the asynchronous SET

   wire lfxt_wkup_set_scan;

   omsp_scan_mux scan_mux_lfxt_wkup (

                                     .scan_mode    (scan_mode),

                                     .data_in_scan (por_a),

                                     .data_in_func (lfxt_wkup_set | por),

                                     .data_out     (lfxt_wkup_set_scan)

                                    );

   // Scan MUX to increase coverage

   omsp_scan_mux scan_mux_lfxt_wkup_observe (

                                             .scan_mode    (scan_mode),

                                             .data_in_scan (lfxt_wkup_set),

                                             .data_in_func (1'b0),

                                             .data_out     (lfxt_wkup_set_scan_observe)

                                            );

   // The wakeup is asynchronously set, synchronously released

   wire lfxt_wkup_n;

   omsp_sync_cell sync_cell_lfxt_wkup (

       .data_out  (lfxt_wkup_n),

       .data_in   (1'b1),

       .clk       (lfxt_clk_n),

       .rst       (lfxt_wkup_set_scan)

   );

   omsp_and_gate and_lfxt_wkup (.y(lfxt_wkup), .a(~lfxt_wkup_n), .b(cpu_en));

`else

   assign lfxt_enable                   = 1'b1;

   assign lfxt_wkup                     = 1'b0;

   wire   UNUSED_oscoff                 = oscoff;

  wire    UNUSED_cpuoff_and_mclk_enable = cpuoff_and_mclk_enable;

   wire   UNUSED_cpu_en_wkup2           = cpu_en_wkup;

`endif

// FPGA MODE

//---------------------------------------

// Synchronize LFXT_CLK & edge detection

`else

wire lfxt_clk_s;

omsp_sync_cell sync_cell_lfxt_clk (

    .data_out  (lfxt_clk_s),

    .data_in   (lfxt_clk),

    .clk       (nodiv_mclk),

    .rst       (por)

);

reg  lfxt_clk_dly;

always @ (posedge nodiv_mclk or posedge por)

  if (por) lfxt_clk_dly <=  1'b0;

  else     lfxt_clk_dly <=  lfxt_clk_s;

wire   lfxt_clk_en = (lfxt_clk_s & ~lfxt_clk_dly) & (~oscoff | (mclk_dma_enable & bcsctl1[`DMA_OSCOFF]));

assign lfxt_enable = 1'b1;

assign lfxt_wkup   = 1'b0;

`endif

//=============================================================================

// 6)  CLOCK GENERATION

//=============================================================================

//-----------------------------------------------------------

// 6.1) GLOBAL CPU ENABLE