From 2acff8d21f4adc0e7b328d414eb900fdd058d20f Mon Sep 17 00:00:00 2001
From: "Wesley W. Terpstra" <wesley@sifive.com>
Date: Thu, 26 Oct 2017 13:08:09 -0700
Subject: [PATCH] util: delete old long-deprecated crossing code

---
 src/main/scala/util/Crossing.scala | 115 -----------------------------
 1 file changed, 115 deletions(-)

diff --git a/src/main/scala/util/Crossing.scala b/src/main/scala/util/Crossing.scala
index f6bab310..7d238ab5 100644
--- a/src/main/scala/util/Crossing.scala
+++ b/src/main/scala/util/Crossing.scala
@@ -19,118 +19,3 @@ class CrossingIO[T <: Data](gen: T) extends Bundle {
 abstract class Crossing[T <: Data] extends Module {
   val io: CrossingIO[T]
 }
-
-class AsyncScope extends Module { val io = new Bundle }
-object AsyncScope { def apply() = Module(new AsyncScope) }
-
-object AsyncDecoupledCrossing
-{
-  // takes from_source from the 'from' clock domain and puts it into the 'to' clock domain
-  def apply[T <: Data](from_clock: Clock, from_reset: Bool, from_source: ReadyValidIO[T], to_clock: Clock, to_reset: Bool, depth: Int = 8, sync: Int = 3): DecoupledIO[T] = {
-    val crossing = Module(new AsyncQueue(from_source.bits, depth, sync)).io
-    crossing.enq_clock := from_clock
-    crossing.enq_reset := from_reset
-    crossing.enq       <> from_source
-    crossing.deq_clock := to_clock
-    crossing.deq_reset := to_reset
-    crossing.deq
-  }
-}
-
-object AsyncDecoupledTo
-{
-  // takes source from your clock domain and puts it into the 'to' clock domain
-  def apply[T <: Data](to_clock: Clock, to_reset: Bool, source: ReadyValidIO[T], depth: Int = 8, sync: Int = 3): DecoupledIO[T] = {
-    val scope = AsyncScope()
-    AsyncDecoupledCrossing(scope.clock, scope.reset, source, to_clock, to_reset, depth, sync)
-  }
-}
-
-object AsyncDecoupledFrom
-{
-  // takes from_source from the 'from' clock domain and puts it into your clock domain
-  def apply[T <: Data](from_clock: Clock, from_reset: Bool, from_source: ReadyValidIO[T], depth: Int = 8, sync: Int = 3): DecoupledIO[T] = {
-    val scope = AsyncScope()
-    AsyncDecoupledCrossing(from_clock, from_reset, from_source, scope.clock, scope.reset, depth, sync)
-  }
-}
-
-object PostQueueIrrevocablize
-{
-  def apply[T <: Data](deq: DecoupledIO[T]): IrrevocableIO[T] = {
-    val irr = Wire(new IrrevocableIO(deq.bits))
-    irr.bits := deq.bits
-    irr.valid := deq.valid
-    deq.ready := irr.ready
-    irr
-  }
-}
-
-object AsyncIrrevocableCrossing {
-  def apply[T <: Data](from_clock: Clock, from_reset: Bool, from_source: ReadyValidIO[T], to_clock: Clock, to_reset: Bool, depth: Int = 8, sync: Int = 3): IrrevocableIO[T] = {
-    PostQueueIrrevocablize(AsyncDecoupledCrossing(from_clock, from_reset, from_source, to_clock, to_reset, depth, sync))
-  }
-}
-
-object AsyncIrrevocableTo
-{
-  // takes source from your clock domain and puts it into the 'to' clock domain
-  def apply[T <: Data](to_clock: Clock, to_reset: Bool, source: ReadyValidIO[T], depth: Int = 8, sync: Int = 3): IrrevocableIO[T] = {
-    PostQueueIrrevocablize(AsyncDecoupledTo(to_clock, to_reset, source, depth, sync))
-  }
-}
-
-object AsyncIrrevocableFrom
-{
-  // takes from_source from the 'from' clock domain and puts it into your clock domain
-  def apply[T <: Data](from_clock: Clock, from_reset: Bool, from_source: ReadyValidIO[T], depth: Int = 8, sync: Int = 3): IrrevocableIO[T] = {
-    PostQueueIrrevocablize(AsyncDecoupledFrom(from_clock, from_reset, from_source, depth, sync))
-  }
-}
-
-/**
- * This helper object synchronizes a level-sensitive signal from one
- * clock domain to another.
- */
-object LevelSyncCrossing {
-  class SynchronizerBackend(sync: Int, _clock: Clock) extends Module(Some(_clock)) {
-    val io = new Bundle {
-      val in = Bool(INPUT)
-      val out = Bool(OUTPUT)
-    }
-
-    io.out := SynchronizerShiftReg(io.in, sync)
-  }
-
-  class SynchronizerFrontend(_clock: Clock) extends Module(Some(_clock)) {
-    val io = new Bundle {
-      val in = Bool(INPUT)
-      val out = Bool(OUTPUT)
-    }
-
-    io.out := RegNext(io.in)
-  }
-
-  def apply(from_clock: Clock, to_clock: Clock, in: Bool, sync: Int = 2): Bool = {
-    val front = Module(new SynchronizerFrontend(from_clock))
-    val back = Module(new SynchronizerBackend(sync, to_clock))
-
-    front.io.in := in
-    back.io.in := front.io.out
-    back.io.out
-  }
-}
-
-object LevelSyncTo {
-  def apply(to_clock: Clock, in: Bool, sync: Int = 2): Bool = {
-    val scope = AsyncScope()
-    LevelSyncCrossing(scope.clock, to_clock, in, sync)
-  }
-}
-
-object LevelSyncFrom {
-  def apply(from_clock: Clock, in: Bool, sync: Int = 2): Bool = {
-    val scope = AsyncScope()
-    LevelSyncCrossing(from_clock, scope.clock, in, sync)
-  }
-}