diff --git a/src/da7219/README.md b/src/da7219/README.md
new file mode 100644
index 0000000..e661a3c
--- /dev/null
+++ b/src/da7219/README.md
@@ -0,0 +1,54 @@
+# Da7219 audio hardware codec driver
+
+This sample project contains a driver component named `da7219` for an audio hardware codec
+device (Dialog da7219) connected to an I2C bus with device address `0x1A`.
+The driver interacts with the device hardware using the `fuchsia.hardware.i2c` protocol,
+and exposes the Codec FIDL protocol (`fuchsia.hardware.audio/Codec`) for other components
+to consume.
+
+The `i2c_controller` driver component emulates an I2C bus controller, creating the child
+device nodes to the sensor device and responding to I2C protocol commands received from
+the child devices.
+
+## Building
+
+To build the `da7219` driver and related components, run the following commands:
+
+```
+tools/bazel build --config=fuchsia_x64 //src/da7219/controller:pkg
+tools/bazel build --config=fuchsia_x64 //src/da7219/driver:pkg
+```
+
+## Running
+
+Use the following commands to load the driver components on Qemu:
+
+1.  Load the `i2c_controller` driver component to create a virtual I2C device node:
+
+    ```
+    tools/bazel run --config=fuchsia_x64 //src/da7219/controller:pkg.component
+    ```
+
+1.  Load the `da7219` driver component to bind to the device node and begin
+    sending requests:
+
+    ```
+    tools/bazel run --config=fuchsia_x64 //src/da7219/driver:pkg.component
+    ```
+
+1.  Open the device log viewer:
+
+    ```
+    tools/ffx log --filter i2c_controller --filter da7219
+    ```
+
+You should see the `da7219` driver log that it is started after the driver has successfully bound.
+
+```
+[da7219,driver][I]: [da7219.cc:139] Started
+```
+
+## Source layout
+
+*   `//src/da7219/controller` — Source code of the `i2c_controller` driver component.
+*   `//src/da7219/driver/` — Source code of the `da7219` driver component.
diff --git a/src/da7219/controller/BUILD.bazel b/src/da7219/controller/BUILD.bazel
new file mode 100644
index 0000000..85152a1
--- /dev/null
+++ b/src/da7219/controller/BUILD.bazel
@@ -0,0 +1,66 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+load(
+    "@rules_fuchsia//fuchsia:defs.bzl",
+    "fuchsia_cc_binary",
+    "fuchsia_component_manifest",
+    "fuchsia_driver_bind_bytecode",
+    "fuchsia_driver_component",
+    "fuchsia_package",
+)
+
+fuchsia_driver_bind_bytecode(
+    name = "bind_bytecode",
+    output = "i2c_controller.bindbc",
+    rules = "i2c_controller.bind",
+    deps = [
+        "@fuchsia_sdk//bind/fuchsia.acpi",
+    ],
+)
+
+cc_binary(
+    name = "i2c_controller",
+    srcs = [
+        "i2c_controller.cc",
+        "i2c_controller.h",
+    ],
+    linkshared = True,
+    deps = [
+        "@fuchsia_sdk//fidl/fuchsia.device.fs:fuchsia.device.fs_llcpp_cc",
+        "@fuchsia_sdk//fidl/fuchsia.driver.compat:fuchsia.driver.compat_llcpp_cc",
+        "@fuchsia_sdk//fidl/fuchsia.hardware.i2c:fuchsia.hardware.i2c_bindlib_cc",
+        "@fuchsia_sdk//fidl/fuchsia.hardware.i2c:fuchsia.hardware.i2c_llcpp_cc",
+        "@fuchsia_sdk//fidl/zx:zx_cc",
+        "@fuchsia_sdk//pkg/async-cpp",
+        "@fuchsia_sdk//pkg/driver2_cpp",
+        "@fuchsia_sdk//pkg/fidl_cpp_wire",
+        "@fuchsia_sdk//pkg/sys_component_cpp",
+        "@fuchsia_sdk//pkg/zx",
+    ],
+)
+
+fuchsia_component_manifest(
+    name = "manifest",
+    src = "meta/i2c_controller.cml",
+    includes = [
+        "@fuchsia_sdk//pkg/syslog:client",
+    ],
+)
+
+fuchsia_driver_component(
+    name = "component",
+    bind_bytecode = ":bind_bytecode",
+    driver_lib = ":i2c_controller",
+    manifest = ":manifest",
+)
+
+fuchsia_package(
+    name = "pkg",
+    package_name = "i2c_controller",
+    visibility = ["//visibility:public"],
+    deps = [
+        ":component",
+    ],
+)
diff --git a/src/da7219/controller/i2c_controller.bind b/src/da7219/controller/i2c_controller.bind
new file mode 100644
index 0000000..df409a0
--- /dev/null
+++ b/src/da7219/controller/i2c_controller.bind
@@ -0,0 +1,11 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+using fuchsia.acpi;
+
+// Bind to an ACPI node in Qemu (unused one) or in Atlas (the specification for this codec).
+accept fuchsia.acpi.hid {
+  "QEMU0002",
+  "DLGS7219",
+}
diff --git a/src/da7219/controller/i2c_controller.cc b/src/da7219/controller/i2c_controller.cc
new file mode 100644
index 0000000..f7245d3
--- /dev/null
+++ b/src/da7219/controller/i2c_controller.cc
@@ -0,0 +1,139 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "i2c_controller.h"
+
+#include <endian.h>
+#include <fidl/fuchsia.component.decl/cpp/wire.h>
+#include <lib/driver2/record_cpp.h>
+
+#include <bind/fuchsia/hardware/i2c/cpp/bind.h>
+
+namespace test_i2c_controller {
+
+zx::status<std::unique_ptr<TestDa7219I2cController>> TestDa7219I2cController::Start(
+    fuchsia_driver_framework::wire::DriverStartArgs& start_args, fdf::UnownedDispatcher dispatcher,
+    fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
+    driver::Logger logger) {
+  auto driver = std::make_unique<TestDa7219I2cController>(
+      dispatcher->async_dispatcher(), std::move(node), std::move(ns), std::move(logger));
+  auto result = driver->Run(std::move(start_args.outgoing_dir()));
+  if (result.is_error()) {
+    return result.take_error();
+  }
+
+  return zx::ok(std::move(driver));
+}
+
+zx::status<> TestDa7219I2cController::Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir) {
+  auto service = [this](fidl::ServerEnd<fuchsia_hardware_i2c::Device> server_end) {
+    fidl::BindServer(dispatcher_, std::move(server_end), this);
+  };
+
+  auto status = outgoing_.AddProtocol<fuchsia_hardware_i2c::Device>(std::move(service));
+  if (status.is_error()) {
+    FDF_SLOG(ERROR, "Failed to add protocol", KV("status", status.status_string()));
+    return status;
+  }
+
+  status = AddChild();
+  if (status.is_error()) {
+    return status;
+  }
+
+  return outgoing_.Serve(std::move(outgoing_dir));
+}
+
+zx::status<> TestDa7219I2cController::AddChild() {
+  fidl::Arena arena;
+
+  // Offer `fuchsia.hardware.i2c.Device` to the driver that binds to the node.
+  auto protocol_offer =
+      fuchsia_component_decl::wire::OfferProtocol::Builder(arena)
+          .source_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_i2c::Device>)
+          .target_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_i2c::Device>)
+          .dependency_type(fuchsia_component_decl::wire::DependencyType::kStrong)
+          .Build();
+  fuchsia_component_decl::wire::Offer offer =
+      fuchsia_component_decl::wire::Offer::WithProtocol(arena, protocol_offer);
+
+  // Set the properties of the node that a driver will bind to.
+  auto properties = fidl::VectorView<fuchsia_driver_framework::wire::NodeProperty>(arena, 2);
+  properties[0] = fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
+                      .key(fuchsia_driver_framework::wire::NodePropertyKey::WithStringValue(
+                          arena, bind_fuchsia_hardware_i2c::DEVICE))
+                      .value(fuchsia_driver_framework::wire::NodePropertyValue::WithEnumValue(
+                          arena, bind_fuchsia_hardware_i2c::DEVICE_ZIRCONTRANSPORT))
+                      .Build();
+  properties[1] = fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
+                      .key(fuchsia_driver_framework::wire::NodePropertyKey::WithIntValue(
+                          0x0A02 /* BIND_I2C_ADDRESS */))
+                      .value(fuchsia_driver_framework::wire::NodePropertyValue::WithIntValue(
+                          0x1a /* I2C address used by the DA7219 codec */))
+                      .Build();
+
+  auto args =
+      fuchsia_driver_framework::wire::NodeAddArgs::Builder(arena)
+          .name(arena, "i2c-child")
+          .offers(fidl::VectorView<fuchsia_component_decl::wire::Offer>::FromExternal(&offer, 1))
+          .properties(properties)
+          .Build();
+
+  // Create endpoints of the `NodeController` for the node.
+  auto endpoints = fidl::CreateEndpoints<fuchsia_driver_framework::NodeController>();
+  if (endpoints.is_error()) {
+    FDF_SLOG(ERROR, "Failed to create endpoint", KV("status", endpoints.status_string()));
+    return zx::error(endpoints.status_value());
+  }
+
+  auto result = node_.sync()->AddChild(args, std::move(endpoints->server), {});
+  if (!result.ok()) {
+    FDF_SLOG(ERROR, "Failed to add child", KV("status", result.status_string()));
+    return zx::error(result.status());
+  }
+
+  return zx::ok();
+}
+
+// Protocol method of `fuchsia.hardware.i2c.Device` to handle data transfer requests.
+void TestDa7219I2cController::Transfer(TransferRequestView request,
+                                       TransferCompleter::Sync& completer) {
+  FDF_SLOG(DEBUG, "Received transfer request");
+
+  // Must be either a write transfer (2 bytes write) or
+  // a read transfer (1 byte write and 1 byte read).
+  if (request->transactions.count() == 1) {  // Write transfer.
+    ZX_ASSERT(request->transactions[0].has_data_transfer());
+    const auto& transfer = request->transactions[0].data_transfer();
+    ZX_ASSERT(transfer.is_write_data() && !transfer.is_read_size());
+    ZX_ASSERT(transfer.write_data().count() == 2);
+    FDF_SLOG(INFO, "Received write", KV("address", static_cast<int>(transfer.write_data()[0])));
+    FDF_SLOG(INFO, "Received write", KV("data", static_cast<int>(transfer.write_data()[1])));
+    completer.ReplySuccess({});
+  } else if (request->transactions.count() == 2) {  // Read transfer.
+    ZX_ASSERT(request->transactions[0].has_data_transfer());
+    const auto& transfer0 = request->transactions[0].data_transfer();
+    ZX_ASSERT(transfer0.is_write_data() && !transfer0.is_read_size());
+    ZX_ASSERT(transfer0.write_data().count() == 1);
+    FDF_SLOG(INFO, "Received write", KV("address", static_cast<int>(transfer0.write_data()[0])));
+    const auto& transfer1 = request->transactions[1].data_transfer();
+    ZX_ASSERT(!transfer1.is_write_data() && transfer1.is_read_size());
+    ZX_ASSERT(transfer1.read_size() == 1);
+    fidl::Arena allocator;
+    auto read_bytes = fidl::VectorView<uint8_t>(allocator, 1);
+    // Test read by sending arbitrary values.
+    constexpr uint8_t kTestArbitraryDataToRead = 12;
+    read_bytes[0] = kTestArbitraryDataToRead;
+    FDF_SLOG(INFO, "Read data to send", KV("data", static_cast<int>(read_bytes[0])));
+    auto read_results = fidl::VectorView<fidl::VectorView<uint8_t>>(allocator, 1);
+    read_results[0] = read_bytes;
+    completer.ReplySuccess(read_results);
+  } else {
+    completer.ReplyError(ZX_ERR_INVALID_ARGS);
+  }
+}
+
+}  // namespace test_i2c_controller
+
+FUCHSIA_DRIVER_RECORD_CPP_V1(test_i2c_controller::TestDa7219I2cController);
diff --git a/src/da7219/controller/i2c_controller.h b/src/da7219/controller/i2c_controller.h
new file mode 100644
index 0000000..6dfc975
--- /dev/null
+++ b/src/da7219/controller/i2c_controller.h
@@ -0,0 +1,60 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FUCHSIA_SDK_EXAMPLES_SRC_DA7219_CONTROLLER_I2C_CONTROLLER_H_
+#define FUCHSIA_SDK_EXAMPLES_SRC_DA7219_CONTROLLER_I2C_CONTROLLER_H_
+
+#include <fidl/fuchsia.driver.framework/cpp/wire.h>
+#include <fidl/fuchsia.hardware.i2c/cpp/wire.h>
+#include <lib/async/cpp/executor.h>
+#include <lib/driver2/namespace.h>
+#include <lib/driver2/structured_logger.h>
+#include <lib/fdf/cpp/dispatcher.h>
+#include <lib/sys/component/cpp/outgoing_directory.h>
+
+namespace test_i2c_controller {
+
+// Sample driver that implements a `fuchsia.hardware.i2c` bus controller and emulates the
+// behavior of an audio hardware codec device to interact with the da7219 driver.
+class TestDa7219I2cController : public fidl::WireServer<fuchsia_hardware_i2c::Device> {
+ public:
+  TestDa7219I2cController(async_dispatcher_t* dispatcher,
+                          fidl::WireSharedClient<fuchsia_driver_framework::Node> node,
+                          driver::Namespace ns, driver::Logger logger)
+      : dispatcher_(dispatcher),
+        outgoing_(component::OutgoingDirectory::Create(dispatcher)),
+        ns_(std::move(ns)),
+        logger_(std::move(logger)),
+        node_(std::move(node)) {}
+
+  virtual ~TestDa7219I2cController() = default;
+
+  static constexpr const char* Name() { return "test-da7219-i2c-controller"; }
+
+  static zx::status<std::unique_ptr<TestDa7219I2cController>> Start(
+      fuchsia_driver_framework::wire::DriverStartArgs& start_args,
+      fdf::UnownedDispatcher dispatcher,
+      fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
+      driver::Logger logger);
+
+  // fuchsia.hardware.i2c/Device:
+  void Transfer(TransferRequestView request, TransferCompleter::Sync& completer);
+
+ private:
+  zx::status<> Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir);
+  zx::status<> AddChild();
+
+  async_dispatcher_t* const dispatcher_;
+
+  component::OutgoingDirectory outgoing_;
+  driver::Namespace ns_;
+  driver::Logger logger_;
+
+  fidl::WireSharedClient<fuchsia_driver_framework::Node> node_;
+  fidl::WireSharedClient<fuchsia_driver_framework::NodeController> controller_;
+};
+
+}  // namespace test_i2c_controller
+
+#endif  // FUCHSIA_SDK_EXAMPLES_SRC_DA7219_CONTROLLER_I2C_CONTROLLER_H_
diff --git a/src/da7219/controller/meta/i2c_controller.cml b/src/da7219/controller/meta/i2c_controller.cml
new file mode 100644
index 0000000..817eeb6
--- /dev/null
+++ b/src/da7219/controller/meta/i2c_controller.cml
@@ -0,0 +1,27 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+{
+    include: [
+        'syslog/client.shard.cml',
+    ],
+    program: {
+        runner: 'driver',
+        binary: 'lib/libi2c_controller.so',
+        bind: 'meta/bind/i2c_controller.bindbc'
+    },
+    use: [
+        { service: 'fuchsia.driver.compat.Service' },
+    ],
+    // Provide the I2C device capability to other components
+    // TODO(fxbug.dev/106665): Route as a service capability from the SDK
+    capabilities: [
+        { protocol: 'fuchsia.hardware.i2c.Device' },
+    ],
+    expose: [
+        {
+            protocol: 'fuchsia.hardware.i2c.Device',
+            from: 'self',
+        },
+    ],
+}
diff --git a/src/da7219/driver/BUILD.bazel b/src/da7219/driver/BUILD.bazel
new file mode 100644
index 0000000..dbda248
--- /dev/null
+++ b/src/da7219/driver/BUILD.bazel
@@ -0,0 +1,66 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+load(
+    "@rules_fuchsia//fuchsia:defs.bzl",
+    "fuchsia_cc_binary",
+    "fuchsia_component_manifest",
+    "fuchsia_driver_bind_bytecode",
+    "fuchsia_driver_component",
+    "fuchsia_package",
+)
+
+fuchsia_component_manifest(
+    name = "manifest",
+    src = "meta/da7219.cml",
+    includes = [
+        "@fuchsia_sdk//pkg/syslog:client",
+    ],
+)
+
+fuchsia_driver_bind_bytecode(
+    name = "bind_bytecode",
+    output = "da7219.bindbc",
+    rules = "da7219.bind",
+    deps = [
+        "@fuchsia_sdk//fidl/fuchsia.hardware.i2c:fuchsia.hardware.i2c_bindlib",
+    ],
+)
+
+cc_binary(
+    name = "da7219",
+    srcs = [
+        "da7219.cc",
+        "da7219.h",
+        "i2c_channel.cc",
+        "i2c_channel.h",
+    ],
+    linkshared = True,
+    deps = [
+        "@fuchsia_sdk//fidl/fuchsia.hardware.audio:fuchsia.hardware.audio_llcpp_cc",
+        "@fuchsia_sdk//fidl/fuchsia.hardware.i2c:fuchsia.hardware.i2c_llcpp_cc",
+        "@fuchsia_sdk//fidl/zx:zx_cc",
+        "@fuchsia_sdk//pkg/async-cpp",
+        "@fuchsia_sdk//pkg/driver2_cpp",
+        "@fuchsia_sdk//pkg/fidl_cpp_wire",
+        "@fuchsia_sdk//pkg/sys_component_cpp",
+        "@fuchsia_sdk//pkg/zx",
+    ],
+)
+
+fuchsia_driver_component(
+    name = "component",
+    bind_bytecode = ":bind_bytecode",
+    driver_lib = ":da7219",
+    manifest = ":manifest",
+)
+
+fuchsia_package(
+    name = "pkg",
+    package_name = "da7219",
+    visibility = ["//visibility:public"],
+    deps = [
+        ":component",
+    ],
+)
diff --git a/src/da7219/driver/da7219.bind b/src/da7219/driver/da7219.bind
new file mode 100644
index 0000000..c39457c
--- /dev/null
+++ b/src/da7219/driver/da7219.bind
@@ -0,0 +1,8 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+using fuchsia.hardware.i2c;
+
+fuchsia.hardware.i2c.Device == fuchsia.hardware.i2c.Device.ZirconTransport;
+fuchsia.BIND_I2C_ADDRESS == 0x1a;
diff --git a/src/da7219/driver/da7219.cc b/src/da7219/driver/da7219.cc
new file mode 100644
index 0000000..a1fdf15
--- /dev/null
+++ b/src/da7219/driver/da7219.cc
@@ -0,0 +1,145 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "da7219.h"
+
+namespace {
+
+// FIDL server implementation for the `fuchsia.examples.audio/Device` protocol
+class Da7219Server : public fidl::WireServer<fuchsia_hardware_audio::Codec> {
+ public:
+  explicit Da7219Server(driver::Namespace& ns, async_dispatcher_t* dispatcher,
+                        std::weak_ptr<I2cChannel> i2c_channel)
+      : i2c_channel_(i2c_channel) {
+    auto logger_result = driver::Logger::Create(ns, dispatcher, "da7219-server");
+    ZX_ASSERT(logger_result.is_ok());
+    logger_ = std::move(*logger_result);
+  }
+
+  // Handle incoming connection requests from FIDL clients
+  static fidl::ServerBindingRef<fuchsia_hardware_audio::Codec> BindDeviceClient(
+      driver::Namespace& ns, async_dispatcher_t* dispatcher, std::weak_ptr<I2cChannel> i2c_channel,
+      fidl::ServerEnd<fuchsia_hardware_audio::Codec> request) {
+    // Bind each connection request to a unique FIDL server instance
+    auto server_impl = std::make_unique<Da7219Server>(ns, dispatcher, i2c_channel);
+    return fidl::BindServer(dispatcher, std::move(request), std::move(server_impl),
+                            std::mem_fn(&Da7219Server::OnUnbound));
+  }
+
+  // This method is called when a server connection is torn down.
+  void OnUnbound(fidl::UnbindInfo info, fidl::ServerEnd<fuchsia_hardware_audio::Codec> server_end) {
+    if (info.is_peer_closed()) {
+      FDF_LOG(DEBUG, "Client disconnected");
+    } else if (!info.is_user_initiated()) {
+      FDF_LOG(ERROR, "Client connection unbound: %s", info.status_string());
+    }
+  }
+
+  // LLCPP implementation for the Codec API.
+  void Reset(ResetCompleter::Sync& completer) override {}
+  void Stop(StopCompleter::Sync& completer) override {}
+  void Start(StartCompleter::Sync& completer) override {}
+  void GetInfo(GetInfoCompleter::Sync& completer) override {}
+  void GetHealthState(GetHealthStateCompleter::Sync& completer) override {}
+  void IsBridgeable(IsBridgeableCompleter::Sync& completer) override {}
+  void SetBridgedMode(SetBridgedModeRequestView request,
+                      SetBridgedModeCompleter::Sync& completer) override {}
+  void GetDaiFormats(GetDaiFormatsCompleter::Sync& completer) override {}
+  void SetDaiFormat(SetDaiFormatRequestView request,
+                    SetDaiFormatCompleter::Sync& completer) override {}
+  void GetPlugDetectCapabilities(GetPlugDetectCapabilitiesCompleter::Sync& completer) override {}
+  void WatchPlugState(WatchPlugStateCompleter::Sync& completer) override {}
+  void SignalProcessingConnect(SignalProcessingConnectRequestView request,
+                               SignalProcessingConnectCompleter::Sync& completer) override {}
+
+ private:
+  driver::Logger logger_;
+  std::weak_ptr<I2cChannel> i2c_channel_;
+};
+
+}  // namespace
+
+namespace audio {
+
+// static
+zx::status<std::unique_ptr<Da7219Driver>> Da7219Driver::Start(
+    fuchsia_driver_framework::wire::DriverStartArgs& start_args, fdf::UnownedDispatcher dispatcher,
+    fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
+    driver::Logger logger) {
+  auto driver = std::make_unique<Da7219Driver>(dispatcher->async_dispatcher(), std::move(node),
+                                               std::move(ns), std::move(logger));
+  auto result = driver->Run(std::move(start_args.outgoing_dir()));
+  if (result.is_error()) {
+    return result.take_error();
+  }
+
+  return zx::ok(std::move(driver));
+}
+
+zx::status<> Da7219Driver::Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir) {
+  auto channel_result = SetupI2cChannel();
+  if (channel_result.is_error()) {
+    return channel_result.take_error();
+  }
+
+  // Serve the fuchsia.hardware.audio/Codec protocol to clients through the
+  // fuchsia.hardware.audio/CodecService wrapper.
+  component::ServiceHandler handler;
+  fuchsia_hardware_audio::CodecService::Handler service(&handler);
+
+  auto result =
+      service.add_codec([this](fidl::ServerEnd<fuchsia_hardware_audio::Codec> request) -> void {
+        Da7219Server::BindDeviceClient(ns_, dispatcher_, i2c_channel_, std::move(request));
+      });
+  ZX_ASSERT(result.is_ok());
+
+  result = outgoing_.AddService<fuchsia_hardware_audio::CodecService>(std::move(handler));
+  if (result.is_error()) {
+    FDF_SLOG(ERROR, "Failed to add service", KV("status", result.status_string()));
+    return result.take_error();
+  }
+
+  auto status = outgoing_.Serve(std::move(outgoing_dir));
+  if (status.is_error()) {
+    FDF_SLOG(ERROR, "Failed to serve outgoing directory", KV("status", status.status_string()));
+    return status.take_error();
+  }
+
+  // Test write and read by sending arbitrary values.
+  constexpr uint8_t kTestArbitraryAddress0 = 34;
+  constexpr uint8_t kTestArbitraryDataToWrite0 = 56;
+  constexpr uint8_t kTestArbitraryAddress1 = 78;
+  auto write_status = i2c_channel_->Write(kTestArbitraryAddress0, kTestArbitraryDataToWrite0);
+  if (write_status.is_error()) {
+    FDF_SLOG(ERROR, "Failed to write to I2C", KV("status", write_status.status_string()));
+    return write_status.take_error();
+  }
+  auto i2c_read = i2c_channel_->Read(kTestArbitraryAddress1);
+  if (i2c_read.is_error()) {
+    FDF_SLOG(ERROR, "Failed to read from I2C", KV("status", i2c_read.status_string()));
+    return i2c_read.take_error();
+  }
+  FDF_SLOG(INFO, "Read", KV("byte", static_cast<int>(i2c_read.value())));
+
+  FDF_SLOG(INFO, "Started");
+
+  return zx::ok();
+}
+
+// Connect to the `fuchsia.hardware.i2c/Device` protocol offered by the parent device node.
+zx::status<> Da7219Driver::SetupI2cChannel() {
+  auto client_endpoint = ns_.Connect<fuchsia_hardware_i2c::Device>();
+  if (client_endpoint.status_value() != ZX_OK) {
+    FDF_SLOG(ERROR, "Failed to setup I2cChannel", KV("status", client_endpoint.status_string()));
+    return client_endpoint.take_error();
+  }
+
+  auto i2c_client = fidl::WireClient(std::move(*client_endpoint), dispatcher_);
+  i2c_channel_ = std::make_shared<I2cChannel>(std::move(i2c_client));
+  return zx::ok();
+}
+
+}  // namespace audio
+
+FUCHSIA_DRIVER_RECORD_CPP_V1(audio::Da7219Driver);
diff --git a/src/da7219/driver/da7219.h b/src/da7219/driver/da7219.h
new file mode 100644
index 0000000..5a53c00
--- /dev/null
+++ b/src/da7219/driver/da7219.h
@@ -0,0 +1,57 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_DA7219_H_
+#define FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_DA7219_H_
+
+#include <fidl/fuchsia.driver.framework/cpp/wire.h>
+#include <fidl/fuchsia.hardware.audio/cpp/wire.h>
+#include <fidl/fuchsia.hardware.i2c/cpp/wire.h>
+#include <lib/driver2/namespace.h>
+#include <lib/driver2/record_cpp.h>
+#include <lib/driver2/structured_logger.h>
+#include <lib/fdf/cpp/dispatcher.h>
+#include <lib/sys/component/cpp/outgoing_directory.h>
+#include <lib/zx/status.h>
+
+#include "i2c_channel.h"
+
+namespace audio {
+
+class Da7219Driver {
+ public:
+  Da7219Driver(async_dispatcher_t* dispatcher,
+               fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
+               driver::Logger logger)
+      : dispatcher_(dispatcher),
+        outgoing_(component::OutgoingDirectory::Create(dispatcher)),
+        node_(std::move(node)),
+        ns_(std::move(ns)),
+        logger_(std::move(logger)) {}
+
+  virtual ~Da7219Driver() = default;
+
+  static constexpr const char* Name() { return "da7219"; }
+
+  static zx::status<std::unique_ptr<Da7219Driver>> Start(
+      fuchsia_driver_framework::wire::DriverStartArgs& start_args,
+      fdf::UnownedDispatcher dispatcher,
+      fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
+      driver::Logger logger);
+
+ private:
+  zx::status<> Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir);
+  zx::status<> SetupI2cChannel();
+
+  async_dispatcher_t* const dispatcher_;
+  component::OutgoingDirectory outgoing_;
+  fidl::WireSharedClient<fuchsia_driver_framework::Node> node_;
+  driver::Namespace ns_;
+  driver::Logger logger_;
+  std::shared_ptr<I2cChannel> i2c_channel_;
+};
+
+}  // namespace audio
+
+#endif  // FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_DA7219_H_
diff --git a/src/da7219/driver/i2c_channel.cc b/src/da7219/driver/i2c_channel.cc
new file mode 100644
index 0000000..2b2e7ec
--- /dev/null
+++ b/src/da7219/driver/i2c_channel.cc
@@ -0,0 +1,82 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "i2c_channel.h"
+
+#include <endian.h>
+
+zx::status<uint8_t> I2cChannel::Read(uint8_t address) {
+  uint8_t value;
+  auto status = WriteReadSync(&address, sizeof(address), &value, sizeof(value));
+
+  if (status.is_error()) {
+    return status.take_error();
+  }
+
+  return zx::ok(value);
+}
+
+zx::status<> I2cChannel::Write(uint8_t address, uint8_t value) {
+  uint8_t data[2];
+  data[0] = address;
+  data[1] = value;
+  return WriteReadSync(reinterpret_cast<uint8_t*>(&data), sizeof(data), nullptr, 0);
+}
+
+zx::status<> I2cChannel::WriteReadSync(const uint8_t* tx_buf, size_t tx_len, uint8_t* rx_buf,
+                                       size_t rx_len) {
+  if (tx_len > fuchsia_hardware_i2c::wire::kMaxTransferSize ||
+      rx_len > fuchsia_hardware_i2c::wire::kMaxTransferSize) {
+    return zx::error(ZX_ERR_OUT_OF_RANGE);
+  }
+
+  fidl::Arena arena;
+  fidl::VectorView<uint8_t> write_data(arena, tx_len);
+  if (tx_len) {
+    memcpy(write_data.data(), tx_buf, tx_len);
+  }
+
+  auto write_transfer = fuchsia_hardware_i2c::wire::DataTransfer::WithWriteData(arena, write_data);
+  auto read_transfer =
+      fuchsia_hardware_i2c::wire::DataTransfer::WithReadSize(static_cast<uint32_t>(rx_len));
+
+  fuchsia_hardware_i2c::wire::Transaction transactions[2];
+  size_t index = 0;
+  if (tx_len > 0) {
+    transactions[index++] = fuchsia_hardware_i2c::wire::Transaction::Builder(arena)
+                                .data_transfer(write_transfer)
+                                .Build();
+  }
+
+  if (rx_len > 0) {
+    transactions[index++] = fuchsia_hardware_i2c::wire::Transaction::Builder(arena)
+                                .data_transfer(read_transfer)
+                                .Build();
+  }
+
+  if (index == 0) {
+    return zx::error(ZX_ERR_INVALID_ARGS);
+  }
+
+  const auto reply = fidl_client_.sync()->Transfer(
+      fidl::VectorView<fuchsia_hardware_i2c::wire::Transaction>::FromExternal(transactions, index));
+  if (!reply.ok()) {
+    return zx::error(reply.status());
+  }
+  if (reply->is_error()) {
+    return zx::error(reply->error_value());
+  }
+
+  if (rx_len > 0) {
+    const auto& read_data = reply->value()->read_data;
+    // Truncate the returned buffer to match the behavior of the Banjo version.
+    if (read_data.count() != 1) {
+      return zx::error(ZX_ERR_IO);
+    }
+
+    memcpy(rx_buf, read_data[0].data(), std::min(rx_len, read_data[0].count()));
+  }
+
+  return zx::ok();
+}
diff --git a/src/da7219/driver/i2c_channel.h b/src/da7219/driver/i2c_channel.h
new file mode 100644
index 0000000..7b866bc
--- /dev/null
+++ b/src/da7219/driver/i2c_channel.h
@@ -0,0 +1,31 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_I2C_CHANNEL_H_
+#define FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_I2C_CHANNEL_H_
+
+#include <fidl/fuchsia.hardware.i2c/cpp/wire.h>
+
+// Sends read and write transactions through a fuchsia.hardware.i2c client.
+class I2cChannel {
+ public:
+  explicit I2cChannel(fidl::WireClient<fuchsia_hardware_i2c::Device> client_end)
+      : fidl_client_(std::move(client_end)) {}
+
+  I2cChannel(I2cChannel&& other) noexcept = default;
+  I2cChannel& operator=(I2cChannel&& other) noexcept = default;
+
+  ~I2cChannel() = default;
+
+  // Functions that perform read/write transactions through the client.
+  zx::status<uint8_t> Read(uint8_t address);
+  zx::status<> Write(uint8_t address, uint8_t value);
+
+ private:
+  zx::status<> WriteReadSync(const uint8_t* tx_buf, size_t tx_len, uint8_t* rx_buf, size_t rx_len);
+
+  fidl::WireClient<fuchsia_hardware_i2c::Device> fidl_client_;
+};
+
+#endif  // FUCHSIA_SDK_EXAMPLES_SRC_DA7219_DRIVER_I2C_CHANNEL_H_
diff --git a/src/da7219/driver/meta/da7219.cml b/src/da7219/driver/meta/da7219.cml
new file mode 100644
index 0000000..61218c5
--- /dev/null
+++ b/src/da7219/driver/meta/da7219.cml
@@ -0,0 +1,18 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+{
+    include: [
+        'syslog/client.shard.cml',
+    ],
+    program: {
+        runner: 'driver',
+        binary: 'lib/libda7219.so',
+        bind: 'meta/bind/da7219.bindbc'
+    },
+    // Consume the I2C device capability from the parent
+    use: [
+        { protocol: 'fuchsia.hardware.i2c.Device' },
+        { service: 'fuchsia.driver.compat.Service' },
+    ],
+}
\ No newline at end of file