diff --git a/garnet/drivers/audio/virtual_audio/README.md b/garnet/drivers/audio/virtual_audio/README.md
index 797121e..2b55007 100644
--- a/garnet/drivers/audio/virtual_audio/README.md
+++ b/garnet/drivers/audio/virtual_audio/README.md
@@ -55,9 +55,10 @@
 ### virtualaudio.Input and virtualaudio.Output
 
 These FIDL interfaces are used to configure and add virtual audio input and
-output devices. virtualaudio.Config is a subset of the top-level input and
-output interfaces, and includes methods to statically configure these virtual
-devices before they are created, specifically to set the following properties:
+output devices. virtualaudio.Configuration is a subset of the top-level input
+and output interfaces, and includes methods to statically configure these
+virtual devices before they are created, specifically to set the following
+properties:
 * Device name
 * Manufacturer name
 * Product name
@@ -86,8 +87,9 @@
   - Plugged
   - Plug time
 Together, these properties comprise a virtual audio device _config_. Finally,
-the virtualaudio.Config interface contains a method to:
+the virtualaudio.Configuration interface contains methods to:
 * Reset the device configuration, returning it to a default state.
+* Clear the previously-added format ranges, retaining other configuration state.
 
 The virtualaudio.Device interface (another subset of Input and Output) contains
 methods to make the following dynamic changes:
diff --git a/garnet/drivers/audio/virtual_audio/virtual_audio_control_impl.cpp b/garnet/drivers/audio/virtual_audio/virtual_audio_control_impl.cpp
index a6cb674..43737aa 100644
--- a/garnet/drivers/audio/virtual_audio/virtual_audio_control_impl.cpp
+++ b/garnet/drivers/audio/virtual_audio/virtual_audio_control_impl.cpp
@@ -120,6 +120,9 @@
       fidl::InterfaceRequest<fuchsia::virtualaudio::Input>(
           std::move(input_request_channel)));
 
+  auto* binding = input_bindings_.bindings().back().get();
+  binding->impl()->SetBinding(binding);
+
   return ZX_OK;
 }
 
@@ -139,6 +142,9 @@
       fidl::InterfaceRequest<fuchsia::virtualaudio::Output>(
           std::move(output_request_channel)));
 
+  auto* binding = output_bindings_.bindings().back().get();
+  binding->impl()->SetBinding(binding);
+
   return ZX_OK;
 }
 
diff --git a/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.cpp b/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.cpp
index 7e8feb4..36d20e8 100644
--- a/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.cpp
+++ b/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.cpp
@@ -28,12 +28,38 @@
 }
 
 // If we have not already destroyed our child stream, do so now.
-VirtualAudioDeviceImpl::~VirtualAudioDeviceImpl() { RemoveStream(); }
+VirtualAudioDeviceImpl::~VirtualAudioDeviceImpl() {
+  RemoveStream();
+  input_binding_ = nullptr;
+  output_binding_ = nullptr;
+}
 
 void VirtualAudioDeviceImpl::PostToDispatcher(fit::closure task_to_post) {
   owner_->PostToDispatcher(std::move(task_to_post));
 }
 
+void VirtualAudioDeviceImpl::SetBinding(
+    fidl::Binding<fuchsia::virtualaudio::Input,
+                  fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+        binding) {
+  ZX_ASSERT(is_input_);
+  ZX_DEBUG_ASSERT(output_binding_ == nullptr);
+
+  input_binding_ = binding;
+  ZX_DEBUG_ASSERT(input_binding_->is_bound());
+}
+
+void VirtualAudioDeviceImpl::SetBinding(
+    fidl::Binding<fuchsia::virtualaudio::Output,
+                  fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+        binding) {
+  ZX_ASSERT(!is_input_);
+  ZX_DEBUG_ASSERT(input_binding_ == nullptr);
+
+  output_binding_ = binding;
+  ZX_DEBUG_ASSERT(output_binding_->is_bound());
+}
+
 bool VirtualAudioDeviceImpl::CreateStream(zx_device_t* devnode) {
   stream_ = VirtualAudioStream::CreateStream(this, devnode, is_input_);
   return (stream_ != nullptr);
@@ -66,13 +92,12 @@
 }
 
 void VirtualAudioDeviceImpl::Init() {
-  snprintf(device_name_, sizeof(device_name_), kDefaultDeviceName);
-  snprintf(mfr_name_, sizeof(mfr_name_), kDefaultManufacturerName);
-  snprintf(prod_name_, sizeof(prod_name_), kDefaultProductName);
+  device_name_ = kDefaultDeviceName;
+  mfr_name_ = kDefaultManufacturerName;
+  prod_name_ = kDefaultProductName;
   memcpy(unique_id_, kDefaultUniqueId, sizeof(unique_id_));
 
   // By default, we support one basic format range (stereo 16-bit 48kHz)
-  default_range_ = true;
   supported_formats_.clear();
   supported_formats_.push_back(kDefaultFormatRange);
 
@@ -96,15 +121,15 @@
 // virtualaudio::Configuration implementation
 //
 void VirtualAudioDeviceImpl::SetDeviceName(std::string device_name) {
-  strlcpy(device_name_, device_name.c_str(), sizeof(device_name_));
+  device_name_ = device_name;
 };
 
 void VirtualAudioDeviceImpl::SetManufacturer(std::string manufacturer_name) {
-  strlcpy(mfr_name_, manufacturer_name.c_str(), sizeof(mfr_name_));
+  mfr_name_ = manufacturer_name;
 };
 
 void VirtualAudioDeviceImpl::SetProduct(std::string product_name) {
-  strlcpy(prod_name_, product_name.c_str(), sizeof(prod_name_));
+  prod_name_ = product_name;
 };
 
 void VirtualAudioDeviceImpl::SetUniqueId(fidl::Array<uint8_t, 16> unique_id) {
@@ -116,11 +141,6 @@
 void VirtualAudioDeviceImpl::AddFormatRange(
     uint32_t format_flags, uint32_t min_rate, uint32_t max_rate,
     uint8_t min_chans, uint8_t max_chans, uint16_t rate_family_flags) {
-  if (default_range_) {
-    supported_formats_.clear();
-    default_range_ = false;
-  }
-
   audio_stream_format_range_t range = {.sample_formats = format_flags,
                                        .min_frames_per_second = min_rate,
                                        .max_frames_per_second = max_rate,
@@ -131,6 +151,8 @@
   supported_formats_.push_back(range);
 };
 
+void VirtualAudioDeviceImpl::ClearFormatRanges() { supported_formats_.clear(); }
+
 void VirtualAudioDeviceImpl::SetFifoDepth(uint32_t fifo_depth_bytes) {
   fifo_depth_ = fifo_depth_bytes;
 }
@@ -225,6 +247,136 @@
   RemoveStream();
 }
 
+void VirtualAudioDeviceImpl::GetFormat(
+    fuchsia::virtualaudio::Device::GetFormatCallback format_callback) {
+  if (stream_ == nullptr) {
+    zxlogf(TRACE, "%s: %p has no stream for this request\n",
+           __PRETTY_FUNCTION__, this);
+    return;
+  }
+
+  stream_->EnqueueFormatRequest(std::move(format_callback));
+}
+
+// Deliver SetFormat notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifySetFormat(uint32_t frames_per_second,
+                                             uint32_t sample_format,
+                                             uint32_t num_channels,
+                                             zx_duration_t external_delay) {
+  PostToDispatcher(
+      [this, frames_per_second, sample_format, num_channels, external_delay]() {
+        if (input_binding_ && input_binding_->is_bound()) {
+          input_binding_->events().OnSetFormat(frames_per_second, sample_format,
+                                               num_channels, external_delay);
+        } else if (output_binding_ && output_binding_->is_bound()) {
+          output_binding_->events().OnSetFormat(
+              frames_per_second, sample_format, num_channels, external_delay);
+        }
+      });
+}
+
+void VirtualAudioDeviceImpl::GetGain(
+    fuchsia::virtualaudio::Device::GetGainCallback gain_callback) {
+  if (stream_ == nullptr) {
+    zxlogf(TRACE, "%s: %p has no stream for this request\n",
+           __PRETTY_FUNCTION__, this);
+    return;
+  }
+
+  stream_->EnqueueGainRequest(std::move(gain_callback));
+}
+
+// Deliver SetGain notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifySetGain(bool current_mute, bool current_agc,
+                                           float current_gain_db) {
+  PostToDispatcher([this, current_mute, current_agc, current_gain_db]() {
+    if (input_binding_ && input_binding_->is_bound()) {
+      input_binding_->events().OnSetGain(current_mute, current_agc,
+                                         current_gain_db);
+    } else if (output_binding_ && output_binding_->is_bound()) {
+      output_binding_->events().OnSetGain(current_mute, current_agc,
+                                          current_gain_db);
+    }
+  });
+}
+
+void VirtualAudioDeviceImpl::GetBuffer(
+    fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback) {
+  if (stream_ == nullptr) {
+    zxlogf(TRACE, "%s: %p has no stream for this request\n",
+           __PRETTY_FUNCTION__, this);
+    return;
+  }
+
+  stream_->EnqueueBufferRequest(std::move(buffer_callback));
+}
+
+// Deliver SetBuffer notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifyBufferCreated(
+    zx::vmo ring_buffer_vmo, uint32_t num_ring_buffer_frames,
+    uint32_t notifications_per_ring) {
+  PostToDispatcher([this, ring_buffer_vmo = std::move(ring_buffer_vmo),
+                    num_ring_buffer_frames, notifications_per_ring]() mutable {
+    if (input_binding_ && input_binding_->is_bound()) {
+      input_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo),
+                                               num_ring_buffer_frames,
+                                               notifications_per_ring);
+    } else if (output_binding_ && output_binding_->is_bound()) {
+      output_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo),
+                                                num_ring_buffer_frames,
+                                                notifications_per_ring);
+    }
+  });
+}
+
+// Deliver Start notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifyStart(zx_time_t start_time) {
+  PostToDispatcher([this, start_time]() {
+    if (input_binding_ && input_binding_->is_bound()) {
+      input_binding_->events().OnStart(start_time);
+    } else if (output_binding_ && output_binding_->is_bound()) {
+      output_binding_->events().OnStart(start_time);
+    }
+  });
+}
+
+// Deliver Stop notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifyStop(zx_time_t stop_time,
+                                        uint32_t ring_buffer_position) {
+  PostToDispatcher([this, stop_time, ring_buffer_position]() {
+    if (input_binding_ && input_binding_->is_bound()) {
+      input_binding_->events().OnStop(stop_time, ring_buffer_position);
+    } else if (output_binding_ && output_binding_->is_bound()) {
+      output_binding_->events().OnStop(stop_time, ring_buffer_position);
+    }
+  });
+}
+
+void VirtualAudioDeviceImpl::GetPosition(
+    fuchsia::virtualaudio::Device::GetPositionCallback position_callback) {
+  if (stream_ == nullptr) {
+    zxlogf(TRACE, "%s: %p has no stream for this request\n",
+           __PRETTY_FUNCTION__, this);
+    return;
+  }
+
+  stream_->EnqueuePositionRequest(std::move(position_callback));
+}
+
+// Deliver Position notification on binding's thread, if binding is valid.
+void VirtualAudioDeviceImpl::NotifyPosition(uint32_t ring_buffer_position,
+                                            zx_time_t time_for_position) {
+  PostToDispatcher([this, ring_buffer_position, time_for_position]() {
+    if (input_binding_ && input_binding_->is_bound()) {
+      input_binding_->events().OnPositionNotify(ring_buffer_position,
+                                                time_for_position);
+    } else if (output_binding_ && output_binding_->is_bound()) {
+      output_binding_->events().OnPositionNotify(ring_buffer_position,
+                                                 time_for_position);
+    }
+  });
+}
+
 // Change the plug state on-the-fly for this active virtual audio device.
 void VirtualAudioDeviceImpl::ChangePlugState(zx_time_t plug_change_time,
                                              bool plugged) {
diff --git a/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.h b/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.h
index 1ac19e8..35caa57 100644
--- a/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.h
+++ b/garnet/drivers/audio/virtual_audio/virtual_audio_device_impl.h
@@ -67,6 +67,15 @@
   // Used to deliver callbacks or events, from the driver execution domain.
   void PostToDispatcher(fit::closure task_to_post);
 
+  void SetBinding(
+      fidl::Binding<fuchsia::virtualaudio::Input,
+                    fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+          binding);
+  void SetBinding(
+      fidl::Binding<fuchsia::virtualaudio::Output,
+                    fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+          binding);
+
   virtual bool CreateStream(zx_device_t* devnode);
   void RemoveStream();
   void ClearStream();
@@ -84,11 +93,13 @@
   void AddFormatRange(uint32_t format_flags, uint32_t min_rate,
                       uint32_t max_rate, uint8_t min_chans, uint8_t max_chans,
                       uint16_t rate_family_flags) override;
+  void ClearFormatRanges() override;
 
   void SetFifoDepth(uint32_t fifo_depth_bytes) override;
   void SetExternalDelay(zx_duration_t external_delay) override;
   void SetRingBufferRestrictions(uint32_t min_frames, uint32_t max_frames,
                                  uint32_t modulo_frames) override;
+
   void SetGainProperties(float min_gain_db, float max_gain_db,
                          float gain_step_db, float current_gain_db,
                          bool can_mute, bool current_mute, bool can_agc,
@@ -104,6 +115,32 @@
   //
   void Add() override;
   void Remove() override;
+
+  void GetFormat(
+      fuchsia::virtualaudio::Device::GetFormatCallback callback) override;
+  virtual void NotifySetFormat(uint32_t frames_per_second,
+                               uint32_t sample_format, uint32_t num_channels,
+                               zx_duration_t external_delay);
+
+  void GetGain(
+      fuchsia::virtualaudio::Device::GetGainCallback callback) override;
+  virtual void NotifySetGain(bool current_mute, bool current_agc,
+                             float current_gain_db);
+
+  void GetBuffer(
+      fuchsia::virtualaudio::Device::GetBufferCallback callback) override;
+  virtual void NotifyBufferCreated(zx::vmo ring_buffer_vmo,
+                                   uint32_t num_ring_buffer_frames,
+                                   uint32_t notifications_per_ring);
+
+  virtual void NotifyStart(zx_time_t start_time);
+  virtual void NotifyStop(zx_time_t stop_time, uint32_t ring_buffer_position);
+
+  void GetPosition(
+      fuchsia::virtualaudio::Device::GetPositionCallback callback) override;
+  virtual void NotifyPosition(uint32_t ring_buffer_position,
+                              zx_time_t start_time);
+
   void ChangePlugState(zx_time_t plug_change_time, bool plugged) override;
 
  protected:
@@ -117,9 +154,21 @@
   fbl::RefPtr<VirtualAudioStream> stream_;
   bool is_input_;
 
-  char device_name_[32];
-  char mfr_name_[64];
-  char prod_name_[64];
+  // When the binding is closed, it is removed from the (ControlImpl-owned)
+  // BindingSet that contains it, which in turn deletes the associated impl
+  // (since the binding holds a unique_ptr<impl>, not an impl*). Something might
+  // get dispatched from another thread at around this time, so we always check
+  // the binding __once we get to our main thread__, wherever these are used.
+  fidl::Binding<fuchsia::virtualaudio::Input,
+                fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+      input_binding_ = nullptr;
+  fidl::Binding<fuchsia::virtualaudio::Output,
+                fbl::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>*
+      output_binding_ = nullptr;
+
+  std::string device_name_;
+  std::string mfr_name_;
+  std::string prod_name_;
   uint8_t unique_id_[16];
 
   std::vector<audio_stream_format_range_t> supported_formats_;
@@ -137,8 +186,6 @@
   bool plugged_;
   bool hardwired_;
   bool async_plug_notify_;
-
-  bool default_range_ = true;
 };
 
 }  // namespace virtual_audio
diff --git a/garnet/drivers/audio/virtual_audio/virtual_audio_stream.cpp b/garnet/drivers/audio/virtual_audio/virtual_audio_stream.cpp
index 5836631..628606f 100644
--- a/garnet/drivers/audio/virtual_audio/virtual_audio_stream.cpp
+++ b/garnet/drivers/audio/virtual_audio/virtual_audio_stream.cpp
@@ -32,15 +32,16 @@
 }
 
 zx_status_t VirtualAudioStream::Init() {
-  if (!strlcpy(device_name_, parent_->device_name_, sizeof(device_name_))) {
+  if (!strlcpy(device_name_, parent_->device_name_.c_str(),
+               sizeof(device_name_))) {
     return ZX_ERR_INTERNAL;
   }
 
-  if (!strlcpy(mfr_name_, parent_->mfr_name_, sizeof(mfr_name_))) {
+  if (!strlcpy(mfr_name_, parent_->mfr_name_.c_str(), sizeof(mfr_name_))) {
     return ZX_ERR_INTERNAL;
   }
 
-  if (!strlcpy(prod_name_, parent_->prod_name_, sizeof(prod_name_))) {
+  if (!strlcpy(prod_name_, parent_->prod_name_.c_str(), sizeof(prod_name_))) {
     return ZX_ERR_INTERNAL;
   }
 
@@ -93,6 +94,74 @@
     return status;
   }
 
+  gain_request_wakeup_ = dispatcher::WakeupEvent::Create();
+  if (gain_request_wakeup_ == nullptr) {
+    return ZX_ERR_NO_MEMORY;
+  }
+  dispatcher::WakeupEvent::ProcessHandler gain_wake_handler(
+      [this](dispatcher::WakeupEvent* event) -> zx_status_t {
+        OBTAIN_EXECUTION_DOMAIN_TOKEN(t, domain_);
+        HandleGainRequests();
+        return ZX_OK;
+      });
+  status =
+      gain_request_wakeup_->Activate(domain_, std::move(gain_wake_handler));
+  if (status != ZX_OK) {
+    zxlogf(ERROR, "GetGain WakeupEvent activate failed (%d)\n", status);
+    return status;
+  }
+
+  format_request_wakeup_ = dispatcher::WakeupEvent::Create();
+  if (format_request_wakeup_ == nullptr) {
+    return ZX_ERR_NO_MEMORY;
+  }
+  dispatcher::WakeupEvent::ProcessHandler format_wake_handler(
+      [this](dispatcher::WakeupEvent* event) -> zx_status_t {
+        OBTAIN_EXECUTION_DOMAIN_TOKEN(t, domain_);
+        HandleFormatRequests();
+        return ZX_OK;
+      });
+  status =
+      format_request_wakeup_->Activate(domain_, std::move(format_wake_handler));
+  if (status != ZX_OK) {
+    zxlogf(ERROR, "GetFormat WakeupEvent activate failed (%d)\n", status);
+    return status;
+  }
+
+  buffer_request_wakeup_ = dispatcher::WakeupEvent::Create();
+  if (buffer_request_wakeup_ == nullptr) {
+    return ZX_ERR_NO_MEMORY;
+  }
+  dispatcher::WakeupEvent::ProcessHandler buffer_wake_handler(
+      [this](dispatcher::WakeupEvent* event) -> zx_status_t {
+        OBTAIN_EXECUTION_DOMAIN_TOKEN(t, domain_);
+        HandleBufferRequests();
+        return ZX_OK;
+      });
+  status =
+      buffer_request_wakeup_->Activate(domain_, std::move(buffer_wake_handler));
+  if (status != ZX_OK) {
+    zxlogf(ERROR, "GetBuffer WakeupEvent activate failed (%d)\n", status);
+    return status;
+  }
+
+  position_request_wakeup_ = dispatcher::WakeupEvent::Create();
+  if (position_request_wakeup_ == nullptr) {
+    return ZX_ERR_NO_MEMORY;
+  }
+  dispatcher::WakeupEvent::ProcessHandler position_wake_handler(
+      [this](dispatcher::WakeupEvent* event) -> zx_status_t {
+        OBTAIN_EXECUTION_DOMAIN_TOKEN(t, domain_);
+        HandlePositionRequests();
+        return ZX_OK;
+      });
+  status = position_request_wakeup_->Activate(domain_,
+                                              std::move(position_wake_handler));
+  if (status != ZX_OK) {
+    zxlogf(ERROR, "GetPosition WakeupEvent activate failed (%d)\n", status);
+    return status;
+  }
+
   notify_timer_ = dispatcher::Timer::Create();
   if (notify_timer_ == nullptr) {
     return ZX_ERR_NO_MEMORY;
@@ -111,6 +180,56 @@
   return ZX_OK;
 }
 
+void VirtualAudioStream::EnqueuePlugChange(bool plugged) {
+  {
+    fbl::AutoLock lock(&wakeup_queue_lock_);
+    PlugType plug_change = (plugged ? PlugType::Plug : PlugType::Unplug);
+    plug_queue_.push_back(plug_change);
+  }
+
+  plug_change_wakeup_->Signal();
+}
+
+void VirtualAudioStream::EnqueueGainRequest(
+    fuchsia::virtualaudio::Device::GetGainCallback gain_callback) {
+  {
+    fbl::AutoLock lock(&wakeup_queue_lock_);
+    gain_queue_.push_back(std::move(gain_callback));
+  }
+
+  gain_request_wakeup_->Signal();
+}
+
+void VirtualAudioStream::EnqueueFormatRequest(
+    fuchsia::virtualaudio::Device::GetFormatCallback format_callback) {
+  {
+    fbl::AutoLock lock(&wakeup_queue_lock_);
+    format_queue_.push_back(std::move(format_callback));
+  }
+
+  format_request_wakeup_->Signal();
+}
+
+void VirtualAudioStream::EnqueueBufferRequest(
+    fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback) {
+  {
+    fbl::AutoLock lock(&wakeup_queue_lock_);
+    buffer_queue_.push_back(std::move(buffer_callback));
+  }
+
+  buffer_request_wakeup_->Signal();
+}
+
+void VirtualAudioStream::EnqueuePositionRequest(
+    fuchsia::virtualaudio::Device::GetPositionCallback position_callback) {
+  {
+    fbl::AutoLock lock(&wakeup_queue_lock_);
+    position_queue_.push_back(std::move(position_callback));
+  }
+
+  position_request_wakeup_->Signal();
+}
+
 void VirtualAudioStream::HandlePlugChanges() {
   while (true) {
     PlugType plug_change;
@@ -138,14 +257,139 @@
   }
 }
 
-void VirtualAudioStream::EnqueuePlugChange(bool plugged) {
-  {
-    fbl::AutoLock lock(&wakeup_queue_lock_);
-    PlugType plug_change = (plugged ? PlugType::Plug : PlugType::Unplug);
-    plug_queue_.push_back(plug_change);
-  }
+void VirtualAudioStream::HandleGainRequests() {
+  while (true) {
+    bool current_mute, current_agc;
+    float current_gain_db;
+    fuchsia::virtualaudio::Device::GetGainCallback gain_callback;
 
-  plug_change_wakeup_->Signal();
+    if (fbl::AutoLock lock(&wakeup_queue_lock_); !gain_queue_.empty()) {
+      current_mute = cur_gain_state_.cur_mute;
+      current_agc = cur_gain_state_.cur_agc;
+      current_gain_db = cur_gain_state_.cur_gain;
+
+      gain_callback = std::move(gain_queue_.front());
+      gain_queue_.pop_front();
+    } else {
+      break;
+    }
+
+    parent_->PostToDispatcher([gain_callback = std::move(gain_callback),
+                               current_mute, current_agc, current_gain_db]() {
+      gain_callback(current_mute, current_agc, current_gain_db);
+    });
+  }
+}
+
+void VirtualAudioStream::HandleFormatRequests() {
+  while (true) {
+    uint32_t frames_per_second, sample_format, num_channels;
+    zx_duration_t external_delay;
+    fuchsia::virtualaudio::Device::GetFormatCallback format_callback;
+
+    if (fbl::AutoLock lock(&wakeup_queue_lock_); !format_queue_.empty()) {
+      frames_per_second = frame_rate_;
+      sample_format = sample_format_;
+      num_channels = num_channels_;
+      external_delay = external_delay_nsec_;
+
+      format_callback = std::move(format_queue_.front());
+      format_queue_.pop_front();
+    } else {
+      break;
+    }
+
+    if (frames_per_second == 0) {
+      zxlogf(TRACE, "Format is not set - should not be calling GetFormat\n");
+      return;
+    }
+
+    parent_->PostToDispatcher([format_callback = std::move(format_callback),
+                               frames_per_second, sample_format, num_channels,
+                               external_delay]() {
+      format_callback(frames_per_second, sample_format, num_channels,
+                      external_delay);
+    });
+  }
+}
+
+void VirtualAudioStream::HandleBufferRequests() {
+  while (true) {
+    zx_status_t status;
+    zx::vmo ring_buffer_vmo;
+    uint32_t num_ring_buffer_frames;
+    uint32_t notifications_per_ring;
+    fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback;
+
+    if (fbl::AutoLock lock(&wakeup_queue_lock_); !buffer_queue_.empty()) {
+      status = ring_buffer_vmo_.duplicate(
+          ZX_RIGHT_TRANSFER | ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_MAP,
+          &ring_buffer_vmo);
+      num_ring_buffer_frames = num_ring_buffer_frames_;
+      notifications_per_ring = notifications_per_ring_;
+
+      buffer_callback = std::move(buffer_queue_.front());
+      buffer_queue_.pop_front();
+    } else {
+      break;
+    }
+
+    if (status != ZX_OK) {
+      zxlogf(ERROR, "%s failed to duplicate VMO handle - %d\n", __func__,
+             status);
+      return;
+    }
+    if (!ring_buffer_vmo.is_valid()) {
+      zxlogf(TRACE,
+             "Buffer is not set - should not be retrieving ring buffer\n");
+      return;
+    }
+
+    parent_->PostToDispatcher([buffer_callback = std::move(buffer_callback),
+                               rb_vmo = std::move(ring_buffer_vmo),
+                               num_ring_buffer_frames,
+                               notifications_per_ring]() mutable {
+      buffer_callback(std::move(rb_vmo), num_ring_buffer_frames,
+                      notifications_per_ring);
+    });
+  }
+}
+
+void VirtualAudioStream::HandlePositionRequests() {
+  while (true) {
+    zx::time start_time;
+    uint32_t num_rb_frames, frame_size, frame_rate;
+    fuchsia::virtualaudio::Device::GetPositionCallback position_callback;
+
+    if (fbl::AutoLock lock(&wakeup_queue_lock_); !position_queue_.empty()) {
+      start_time = start_time_;
+      num_rb_frames = num_ring_buffer_frames_;
+      frame_size = frame_size_;
+      frame_rate = frame_rate_;
+
+      position_callback = std::move(position_queue_.front());
+      position_queue_.pop_front();
+    } else {
+      break;
+    }
+
+    if (start_time.get() == 0) {
+      zxlogf(TRACE,
+             "Stream is not started -- should not be calling GetPosition\n");
+      return;
+    }
+
+    zx::time now = zx::clock::get_monotonic();
+    zx::duration duration_ns = now - start_time;
+    uint64_t frames = (duration_ns.get() * frame_rate) / ZX_SEC(1);
+    uint32_t ring_buffer_position = (frames % num_rb_frames) * frame_size;
+    zx_time_t time_for_position = now.get();
+
+    parent_->PostToDispatcher([position_callback = std::move(position_callback),
+                               ring_buffer_position, time_for_position]() {
+      position_callback(ring_buffer_position, time_for_position);
+    });
+  }
 }
 
 // Upon success, drivers should return a valid VMO with appropriate
@@ -223,6 +467,19 @@
 
   *out_num_rb_frames = num_ring_buffer_frames_;
 
+  zx::vmo duplicate_vmo;
+  status = ring_buffer_vmo_.duplicate(
+      ZX_RIGHT_TRANSFER | ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_MAP,
+      &duplicate_vmo);
+  if (status != ZX_OK) {
+    zxlogf(ERROR, "%s failed to duplicate VMO handle for notification - %d\n",
+           __func__, status);
+    return status;
+  }
+  parent_->NotifyBufferCreated(std::move(duplicate_vmo),
+                               num_ring_buffer_frames_,
+                               notifications_per_ring_);
+
   return ZX_OK;
 }
 
@@ -240,6 +497,10 @@
   bytes_per_sec_ = frame_rate_ * frame_size_;
 
   // (Re)set external_delay_nsec_ and fifo_depth_ before leaving, if needed.
+
+  parent_->NotifySetFormat(frame_rate_, sample_format_, num_channels_,
+                           external_delay_nsec_);
+
   return ZX_OK;
 }
 
@@ -258,6 +519,9 @@
     cur_gain_state_.cur_agc = req.flags & AUDIO_SGF_AGC;
   }
 
+  parent_->NotifySetGain(cur_gain_state_.cur_mute, cur_gain_state_.cur_agc,
+                         cur_gain_state_.cur_gain);
+
   return ZX_OK;
 }
 
@@ -280,14 +544,19 @@
     notify_timer_->Arm(*out_start_time);
   }
 
+  parent_->NotifyStart(*out_start_time);
+
   return ZX_OK;
 }
 
 // Timer handler for sending out position notifications
+// TODO(mpuryear): Establish a notification cadence at the requested ring
+// positions, such as 0, 1000, 0, 1000,... instead of 4, 1006, 8, 1010, 12,...
 zx_status_t VirtualAudioStream::ProcessRingNotification() {
   ZX_DEBUG_ASSERT(us_per_notification_ > 0);
 
   zx::time now = zx::clock::get_monotonic();
+
   notify_timer_->Arm(now.get() + ZX_USEC(us_per_notification_));
 
   ::audio::audio_proto::RingBufPositionNotify resp = {};
@@ -305,16 +574,27 @@
            resp.ring_buffer_pos, now.get());
   }
 
-  return NotifyPosition(resp);
+  zx_status_t status = NotifyPosition(resp);
+
+  parent_->NotifyPosition(ring_buffer_position, now.get());
+
+  return status;
 }
 
 zx_status_t VirtualAudioStream::Stop() {
+  auto stop_time = zx::clock::get_monotonic();
+
   if (kTestPosition) {
-    zxlogf(TRACE, "%s at %ld\n", __PRETTY_FUNCTION__,
-           zx_clock_get(ZX_CLOCK_MONOTONIC));
+    zxlogf(TRACE, "%s at %ld\n", __PRETTY_FUNCTION__, stop_time.get());
   }
 
   notify_timer_->Cancel();
+
+  zx::duration duration_ns = stop_time - start_time_;
+  uint64_t frames = (duration_ns.get() * frame_rate_) / ZX_SEC(1);
+  uint32_t ring_buf_position = (frames % num_ring_buffer_frames_) * frame_size_;
+  parent_->NotifyStop(stop_time.get(), ring_buf_position);
+
   start_time_ = zx::time(0);
 
   return ZX_OK;
diff --git a/garnet/drivers/audio/virtual_audio/virtual_audio_stream.h b/garnet/drivers/audio/virtual_audio/virtual_audio_stream.h
index 30b36ce..bfb5fbb 100644
--- a/garnet/drivers/audio/virtual_audio/virtual_audio_stream.h
+++ b/garnet/drivers/audio/virtual_audio/virtual_audio_stream.h
@@ -21,6 +21,18 @@
 class VirtualAudioStream : public ::audio::SimpleAudioStream {
  public:
   void EnqueuePlugChange(bool plugged) __TA_EXCLUDES(wakeup_queue_lock_);
+  void EnqueueGainRequest(
+      fuchsia::virtualaudio::Device::GetGainCallback gain_callback)
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void EnqueueFormatRequest(
+      fuchsia::virtualaudio::Device::GetFormatCallback format_callback)
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void EnqueueBufferRequest(
+      fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback)
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void EnqueuePositionRequest(
+      fuchsia::virtualaudio::Device::GetPositionCallback position_callback)
+      __TA_EXCLUDES(wakeup_queue_lock_);
 
   static fbl::RefPtr<VirtualAudioStream> CreateStream(
       VirtualAudioDeviceImpl* owner, zx_device_t* devnode, bool is_input);
@@ -64,6 +76,15 @@
       __TA_EXCLUDES(wakeup_queue_lock_);
   void HandlePlugChange(PlugType plug_change) __TA_REQUIRES(domain_->token());
 
+  void HandleGainRequests() __TA_REQUIRES(domain_->token())
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void HandleFormatRequests() __TA_REQUIRES(domain_->token())
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void HandleBufferRequests() __TA_REQUIRES(domain_->token())
+      __TA_EXCLUDES(wakeup_queue_lock_);
+  void HandlePositionRequests() __TA_REQUIRES(domain_->token())
+      __TA_EXCLUDES(wakeup_queue_lock_);
+
   // Accessed in GetBuffer, defended by token.
   fzl::VmoMapper ring_buffer_mapper_ __TA_GUARDED(domain_->token());
   zx::vmo ring_buffer_vmo_ __TA_GUARDED(domain_->token());
@@ -87,8 +108,25 @@
 
   fbl::Mutex wakeup_queue_lock_ __TA_ACQUIRED_AFTER(domain_->token());
 
+  // TODO(mpuryear): Refactor to a single queue of lambdas to dedupe this code.
   fbl::RefPtr<::dispatcher::WakeupEvent> plug_change_wakeup_;
   std::deque<PlugType> plug_queue_ __TA_GUARDED(wakeup_queue_lock_);
+
+  fbl::RefPtr<::dispatcher::WakeupEvent> gain_request_wakeup_;
+  std::deque<fuchsia::virtualaudio::Device::GetGainCallback> gain_queue_
+      __TA_GUARDED(wakeup_queue_lock_);
+
+  fbl::RefPtr<::dispatcher::WakeupEvent> format_request_wakeup_;
+  std::deque<fuchsia::virtualaudio::Device::GetFormatCallback> format_queue_
+      __TA_GUARDED(wakeup_queue_lock_);
+
+  fbl::RefPtr<::dispatcher::WakeupEvent> buffer_request_wakeup_;
+  std::deque<fuchsia::virtualaudio::Device::GetBufferCallback> buffer_queue_
+      __TA_GUARDED(wakeup_queue_lock_);
+
+  fbl::RefPtr<::dispatcher::WakeupEvent> position_request_wakeup_;
+  std::deque<fuchsia::virtualaudio::Device::GetPositionCallback> position_queue_
+      __TA_GUARDED(wakeup_queue_lock_);
 };
 
 }  // namespace virtual_audio
diff --git a/sdk/fidl/fuchsia.virtualaudio/virtual_audio.fidl b/sdk/fidl/fuchsia.virtualaudio/virtual_audio.fidl
index b20bb8d..8ded15d 100644
--- a/sdk/fidl/fuchsia.virtualaudio/virtual_audio.fidl
+++ b/sdk/fidl/fuchsia.virtualaudio/virtual_audio.fidl
@@ -9,10 +9,10 @@
 // fuchsia.virtualaudio.Forwarder
 //
 
-/// Using this Simple Layout (C-bound) interface, an intermediary (such as the
-/// virtual audio service) forwards FIDL interface requests to the virtual audio
+/// Using this Simple Layout (C-bound) protocol, an intermediary (such as the
+/// virtual audio service) forwards FIDL protocol requests to the virtual audio
 /// driver, which enables clients to use more full-featured (C++ based) bindings
-/// with this driver -- specifically the Control, Input and Output interfaces.
+/// with this driver -- specifically the Control, Input and Output protocols.
 [Layout = "Simple"]
 protocol Forwarder {
     SendControl(request<Control> control);
@@ -95,7 +95,7 @@
     /// device node will be published and detected by the AudioDeviceManager,
     /// and a driver for the virtual device will be loaded and queried. Device
     /// arrivals are exposed to clients by the
-    /// `fuchsia.media.AudioDeviceEnumerator` interface, in `GetDevices()` and
+    /// `fuchsia.media.AudioDeviceEnumerator` protocol, in `GetDevices()` and
     /// the `->OnDeviceAdded()` event.
     Add();
 
@@ -106,6 +106,58 @@
     /// `GetDevices()` and `->OnDeviceRemoved()`.
     Remove();
 
+    /// Return the format selected by the client, when that client issued an
+    /// `AUDIO_STREAM_CMD_SET_FORMAT` command. This can only occur after a
+    /// device has been added, and is only allowed to occur before the device's
+    /// ring buffer has been returned (i.e., before an
+    /// `AUDIO_RB_CMD_GET_BUFFER` command).
+    GetFormat() -> (uint32 frames_per_second, uint32 sample_format,
+                    uint32 num_channels, zx.duration external_delay);
+
+    /// Notify all listeners, when the above format is set or changed.
+    -> OnSetFormat(uint32 frames_per_second, uint32 sample_format,
+                   uint32 num_channels, zx.duration external_delay);
+
+    /// Return the current gain state for this device. After a device has been
+    /// added, a client can call this at any time -- even before the ring buffer
+    /// has been established, or before the format has been set.
+    GetGain() -> (bool current_mute, bool current_agc, float32 current_gain_db);
+
+    /// Notify all listeners, when the above gain is set or changed.
+    -> OnSetGain(bool current_mute, bool current_agc, float32 current_gain_db);
+
+    /// Return details about the ring buffer that was established in response
+    /// to a client `AUDIO_RB_CMD_GET_BUFFER` command. This will only occur
+    /// after the format is set and other information is retrieved from the
+    /// driver.
+    GetBuffer() -> (handle<vmo> ring_buffer, uint32 num_ring_buffer_frames,
+                    uint32 notifications_per_ring);
+
+    /// Notify all listeners, when the above buffer has been requested (and
+    /// thus at that time has been established).
+    -> OnBufferCreated(handle<vmo> ring_buffer, uint32 num_ring_buffer_frames,
+                       uint32 notifications_per_ring);
+
+    /// Notify a test client when the device is commanded to Start streaming.
+    /// This can only occur after a device is fully configured (format is set;
+    /// ring buffer is established and fetched).
+    -> OnStart(zx.time start_time);
+
+    /// Notify a test client when the device is commanded to Stop streaming.
+    /// This can only occur when the device is currently Started. Stop returns
+    /// the device to a fully-configured state. Restated, upon this command,
+    /// the already-set format and ring buffer are retained without change.
+    -> OnStop(zx.time stop_time, uint32 ring_position);
+
+    /// Return the current position (in bytes) within the ring buffer. This can
+    /// only be called after the ring buffer is established. If the device has
+    /// not yet Started streaming, then zero will always be returned.
+    GetPosition() -> (uint32 ring_position, zx.time clock_time);
+
+    /// Notify all listeners, when any `AUDIO_RB_POSITION_NOTIFY` position
+    /// notification is proactively issued to the client.
+    -> OnPositionNotify(uint32 ring_position, zx.time clock_time);
+
     /// Hot-plug or hot-unplug an active virtual device, at the specified time.
     /// For devices marked as capable of asynchronously notifying the system of
     /// plug changes, the driver will now send the values using
@@ -113,7 +165,7 @@
     /// the driver is next sent an `AUDIO_STREAM_CMD_PLUG_DETECT` command. This
     /// information is used by the system when determining which device is
     /// default. This, in turn, is exposed to clients by the
-    /// `fuchsia.media.AudioDeviceEnumerator` interface: in `GetDevices()`,
+    /// `fuchsia.media.AudioDeviceEnumerator` protocol: in `GetDevices()`,
     /// `GetDefaultInputDevice()`/`GetDefaultOutputDevice()` and the
     /// `->OnDefaultDeviceChanged()` event.
     ChangePlugState(zx.time plug_change_time, bool plugged);
@@ -125,7 +177,7 @@
 /// This protocol is conceptually a base protocol to Device. It exposes the
 /// methods used to specify the properties of a virtual audio device (its
 /// configuration), before the virtual device is instantiated by the call to
-/// `Add()`. Although the non-Add methods on this interface can be called after
+/// `Add()`. Although the non-Add methods on this protocol can be called after
 /// calling `Add()` (i.e., after Configuration has been converted into active
 /// Device), this only changes how future Devices will be created; it has no
 /// effect on already-created Devices.
@@ -141,7 +193,7 @@
     /// this value is returned by the driver in response to an
     /// `AUDIO_STREAM_CMD_GET_STRING` command of string ID
     /// `AUDIO_STREAM_STR_ID_MANUFACTURER`. This information is exposed to
-    /// clients by the `fuchsia.media.AudioDeviceEnumerator` interface: returned
+    /// clients by the `fuchsia.media.AudioDeviceEnumerator` protocol: returned
     /// in an `AudioDeviceInfo` struct by `GetDevices()` and the
     /// `->OnDeviceAdded()` event.
     SetManufacturer(string manufacturer_name);
@@ -151,7 +203,7 @@
     /// value is returned by the driver in response to an
     /// `AUDIO_STREAM_CMD_GET_STRING` command of string ID
     /// `AUDIO_STREAM_STR_ID_PRODUCT`. This information is exposed to clients by
-    /// the `fuchsia.media.AudioDeviceEnumerator` interface: returned in an
+    /// the `fuchsia.media.AudioDeviceEnumerator` protocol: returned in an
     /// `AudioDeviceInfo` struct by `GetDevices()` and the `->OnDeviceAdded()`
     /// event.
     SetProduct(string product_name);
@@ -160,7 +212,7 @@
     /// must be called before calling `Add()`, or after `Remove()`. Once the
     /// device is activated, this value is returned by the driver in response
     /// to an `AUDIO_STREAM_CMD_GET_UNIQUE_ID` command. This value is exposed
-    /// to clients by the `fuchsia.media.AudioDeviceEnumerator` interface:
+    /// to clients by the `fuchsia.media.AudioDeviceEnumerator` protocol:
     /// returned in an `AudioDeviceInfo` struct by `GetDevices()` or
     /// `->OnDeviceAdded()`.
     SetUniqueId(array<uint8>:16 unique_id);
@@ -175,6 +227,11 @@
                    uint32 max_frame_rate, uint8 min_channels,
                    uint8 max_channels, uint16 rate_family_flags);
 
+    /// Remove the minimal format range that is added by default to all
+    /// configurations. As with `AddFormatRange()`, this method must be called
+    /// before calling `Add()`, or after `Remove()`.
+    ClearFormatRanges();
+
     /// Set the virtual audio device's fifo depth, in bytes. This must be called
     /// before calling `Add()`, or after `Remove()`. Once the device is
     /// activated, the depth of its FIFO is returned by the driver in response
@@ -203,7 +260,7 @@
     /// information is returned by the driver in an
     /// `audio_stream_cmd_get_gain_resp` struct, in response to an
     /// `AUDIO_STREAM_CMD_GET_GAIN` command. This information is exposed to
-    /// clients by the `fuchsia.media.AudioDeviceEnumerator` interface: returned
+    /// clients by the `fuchsia.media.AudioDeviceEnumerator` protocol: returned
     /// in an `AudioGainInfo` struct by `GetDeviceGain()` and the
     /// `->OnDeviceGainChanged()` event.
     SetGainProperties(float32 min_gain_db, float32 max_gain_db,
@@ -216,7 +273,7 @@
     /// information is returned by the driver in response to an
     /// `AUDIO_STREAM_CMD_PLUG_DETECT `command. This information is used by the
     /// system when determining which device is default. This in turn is exposed
-    /// to clients by the `fuchsia.media.AudioDeviceEnumerator` interface: in
+    /// to clients by the `fuchsia.media.AudioDeviceEnumerator` protocol: in
     /// `GetDevices()`, `GetDefaultInputDevice()`/`GetDefaultOutputDevice()` and
     /// the `->OnDefaultDeviceChanged()` event.
     SetPlugProperties(zx.time plug_change_time, bool plugged, bool hardwired,