diff --git a/src/main/scala/uncore/tilelink2/Buffer.scala b/src/main/scala/uncore/tilelink2/Buffer.scala
index 8a864ec3..b7a51c4d 100644
--- a/src/main/scala/uncore/tilelink2/Buffer.scala
+++ b/src/main/scala/uncore/tilelink2/Buffer.scala
@@ -8,33 +8,60 @@ import config._
 import diplomacy._
 import scala.math.{min,max}
 
-// pipe is only used if a queue has depth = 1
-class TLBuffer(a: Int = 2, b: Int = 2, c: Int = 2, d: Int = 2, e: Int = 2, pipe: Boolean = true)(implicit p: Parameters) extends LazyModule
+case class TLBufferParams(depth: Int, flow: Boolean, pipe: Boolean)
 {
-  require (a >= 0)
-  require (b >= 0)
-  require (c >= 0)
-  require (d >= 0)
-  require (e >= 0)
+  require (depth >= 0)
+  def isDefined = depth > 0
+  def latency = if (isDefined && !flow) 1 else 0
+}
+
+object TLBufferParams
+{
+  implicit def apply(depth: Int): TLBufferParams = TLBufferParams(depth, false, false)
+
+  val default = TLBufferParams(2)
+  val none    = TLBufferParams(0)
+  val flow    = TLBufferParams(1, true, false)
+  val pipe    = TLBufferParams(1, false, true)
+}
+
+class TLBuffer(
+  a: TLBufferParams,
+  b: TLBufferParams,
+  c: TLBufferParams,
+  d: TLBufferParams,
+  e: TLBufferParams)(implicit p: Parameters) extends LazyModule
+{
+  def this(ace: TLBufferParams, bd: TLBufferParams)(implicit p: Parameters) = this(ace, bd, ace, bd, ace)
+  def this(abcde: TLBufferParams)(implicit p: Parameters) = this(abcde, abcde)
+  def this()(implicit p: Parameters) = this(TLBufferParams.default)
 
   val node = TLAdapterNode(
-    clientFn  = { p => p.copy(minLatency = p.minLatency + min(1,b) + min(1,c)) },
-    managerFn = { p => p.copy(minLatency = p.minLatency + min(1,a) + min(1,d)) })
+    clientFn  = { p => p.copy(minLatency = p.minLatency + b.latency + c.latency) },
+    managerFn = { p => p.copy(minLatency = p.minLatency + a.latency + d.latency) })
 
   lazy val module = new LazyModuleImp(this) {
     val io = new Bundle {
       val in  = node.bundleIn
       val out = node.bundleOut
     }
-    
+
+    def buffer[T <: Data](config: TLBufferParams, data: DecoupledIO[T]): DecoupledIO[T] = {
+      if (config.isDefined) {
+        Queue(data, config.depth, pipe=config.pipe, flow=config.flow)
+      } else {
+        data
+      }
+    }
+
     ((io.in zip io.out) zip (node.edgesIn zip node.edgesOut)) foreach { case ((in, out), (edgeIn, edgeOut)) =>
-      if (a>0) { out.a <> Queue(in .a, a, pipe && a<2) } else { out.a <> in.a }
-      if (d>0) { in .d <> Queue(out.d, d, pipe && d<2) } else { in.d <> out.d }
+      out.a <> buffer(a, in .a)
+      in .d <> buffer(d, out.d)
 
       if (edgeOut.manager.anySupportAcquireB && edgeOut.client.anySupportProbe) {
-        if (b>0) { in .b <> Queue(out.b, b, pipe && b<2) } else { in.b <> out.b }
-        if (c>0) { out.c <> Queue(in .c, c, pipe && c<2) } else { out.c <> in.c }
-        if (e>0) { out.e <> Queue(in .e, e, pipe && e<2) } else { out.e <> in.e }
+        in .b <> buffer(b, out.b)
+        out.c <> buffer(c, in .c)
+        out.e <> buffer(e, in .e)
       } else {
         in.b.valid := Bool(false)
         in.c.ready := Bool(true)
@@ -50,13 +77,16 @@ class TLBuffer(a: Int = 2, b: Int = 2, c: Int = 2, d: Int = 2, e: Int = 2, pipe:
 object TLBuffer
 {
   // applied to the TL source node; y.node := TLBuffer(x.node)
-  def apply()                                (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(2)(x)
-  def apply(entries: Int)                    (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(entries, true)(x)
-  def apply(entries: Int, pipe: Boolean)     (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(entries, entries, pipe)(x)
-  def apply(ace: Int, bd: Int)               (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, true)(x)
-  def apply(ace: Int, bd: Int, pipe: Boolean)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, ace, bd, ace, pipe)(x)
-  def apply(a: Int, b: Int, c: Int, d: Int, e: Int, pipe: Boolean = true)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = {
-    val buffer = LazyModule(new TLBuffer(a, b, c, d, e, pipe))
+  def apply()                                       (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(TLBufferParams.default)(x)
+  def apply(abcde: TLBufferParams)                  (x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(abcde, abcde)(x)
+  def apply(ace: TLBufferParams, bd: TLBufferParams)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = apply(ace, bd, ace, bd, ace)(x)
+  def apply(
+      a: TLBufferParams,
+      b: TLBufferParams,
+      c: TLBufferParams,
+      d: TLBufferParams,
+      e: TLBufferParams)(x: TLOutwardNode)(implicit p: Parameters, sourceInfo: SourceInfo): TLOutwardNode = {
+    val buffer = LazyModule(new TLBuffer(a, b, c, d, e))
     buffer.node := x
     buffer.node
   }