diff --git a/crates/virtio-drivers/.android-checksum.json b/crates/virtio-drivers/.android-checksum.json
index ee40c06..14f1d79 100644
--- a/crates/virtio-drivers/.android-checksum.json
+++ b/crates/virtio-drivers/.android-checksum.json
@@ -1 +1 @@
-{"package":null,"files":{".cargo-checksum.json":"bb4cc152b51bcfd22685477bf28097cf86d45ed301ccf5ae70d8c9f64c5ecf00","Android.bp":"98827eb2ea6b361ddf7caf7fa0e5d8fb013c50d28d9164e0c7ea6135ebfcae0f","Cargo.toml":"9e1deaf88347c0ac121d9722f0fc8f9be91524bdbe36597735610fc8ec52347b","LICENSE":"ac7199d689b436833681f33b881e0b619be2053c06b122327caabb5a6bdb59f1","METADATA":"be4464e3027ab217d498625cb98dc4707f0e316b9aab0eea5b17de5abfe868ac","MODULE_LICENSE_MIT":"0d6f8afa3940b7f06bebee651376d43bc8b0d5b437337be2696d30377451e93a","README.md":"83f78247138f308184c7b9a649d1183d51d6c56c47cb0a8a7bc1e354d9a347c9","TEST_MAPPING":"7ffa0bced5a01703c33b82d5cfc6feebe888778bbffda68e4c1ecb9c142708ee","cargo_embargo.json":"8e1419c87a07e3391cc5da4d80c695e906b42c95874ff968f4be7a453faf756b","patches/mmio.patch":"67246832486c93662c4e604ff2c7bd4f0d4e7ca420eda6892e4eef0a958fec50","patches/rules.mk.diff":"afdb592f46d323d0e04ec3c033fb272fe7f79c28c5ad544f462bdac4c01f661b","rules.mk":"4db4d73612f66672ccbc2955979d99831fe195239e6ea51179b7ad7bb32d33f3","rust-toolchain.toml":"e29f2ad5748c6738b191d46ca6a4204014c51626eca5c106ab575225d8c915db","src/device/blk.rs":"7e63907d7653595dc9bb900c1b996c61ad1a09226b5a8ecbbea437c0ad57a7f1","src/device/common.rs":"090d853e88b893aebe01606fafcd9cab96d4601f3b7ce3cb6721975801616e0d","src/device/console.rs":"aa400f9035041f3c6bde186401466dec88785d6e0d03989cebe97224eedffb66","src/device/gpu.rs":"720ee5ccf00d4360897a14367964ccf7e3d0f75fb5f95fdb69ec1ec23212432a","src/device/input.rs":"44fb2d8866eadb5622b7495a05e96e1b5039a54249f175c3f258384a82d1c6c5","src/device/mod.rs":"2d7ff4b17e85539c2405aa62c6a007314f6a8b94ca1033fb6af158f8217f1d06","src/device/net/dev.rs":"9279bf99a856e20a58869403b82e463a05ab4c1e41591f06da6f9f1b9e6c6b99","src/device/net/dev_raw.rs":"041d333e1a38f9d6d7273c0ab9de59198f1ac6a387704c4e2cbf10cf05b47023","src/device/net/mod.rs":"89ce8151b27a93c2bbe958fe5b95c070b4edcbcc7c6fb9a691b1d9dc353e2fbd","src/device/net/net_buf.rs":"367b6d53840b1128659234796848e2808482c2a36c995960b0c41b4e92bf949b","src/device/socket/connectionmanager.rs":"6273d60f4894f87ab86e6e1340fa4feaa5a56654bb248b1ec44d7dd8a2fe0a72","src/device/socket/error.rs":"de5b97fc2d3b38e5980ab242a52d0b778500d5869758d6a32756b4cef0b61f86","src/device/socket/mod.rs":"46ba478462b1c003acf42d449763f0a7457d853ee282f9b9349a6749caa19d2b","src/device/socket/protocol.rs":"4de57579bbfeb219e8068bc7416522f3dc85f9519ddc768bf05a7ae2800cdd17","src/device/socket/vsock.rs":"9705585f4250f5ed54322149a85120ec8b77ae0bfd5ca29d89bd69b2c643987f","src/hal.rs":"f2d413f8924bfe50dbd2705f3febffd111a1ae17f160cdb5d9f12159ca3dc803","src/hal/fake.rs":"4c3ea7153f5627270041a42afe60256bdb52772923e6fdbc864f858c5346e368","src/lib.rs":"c9a768e1cf95a6027fd5da07c782681c2da6d1e5a96873e5ad7a878bf93097da","src/queue.rs":"bd3ab087263a9a30a8d4f319cfe4b3e0a78704296a29d363282cd6a785d73e95","src/transport/fake.rs":"0507bfc5203392ff0b430652787f8f19905ee0307d9e4f97ac32a049f7c4a493","src/transport/mmio.rs":"294e0a32cfb1daeb8be904061652db3465413c14aaaca43155f55d7325c66756","src/transport/mod.rs":"6412c72655e9807ce4a5539be38d350115d8c4c62fb8c75f465a9a7bef718765","src/transport/pci.rs":"42fbb0d2fe021f6dcc8490d5f168b900f1e2a75e5b39a6d8f97750857720eb5e","src/transport/pci/bus.rs":"fab9e0a81895becf29b1d482a9aba697a787188061032c286a5a84ca36dac99d","src/volatile.rs":"0b759bd807893075242115aa0f461fe5052e008b2022839e95a7602ce93cdd31"}}
\ No newline at end of file
+{"package":null,"files":{".cargo-checksum.json":"33715e646066334cbd3f9dc86080ec9075378fe91582612b3607d177e093b74f","Android.bp":"809904cc6a7c14b1055c0102751ae7b10fc523d87454fc4ae786ced34bd91238","Cargo.toml":"6d280212b0658d988e61b05a6e4eb1066034266b9b563804730fb4837d628bab","LICENSE":"ac7199d689b436833681f33b881e0b619be2053c06b122327caabb5a6bdb59f1","METADATA":"694e7c4911f26d49733e917267fec9b1f59aac272c5959bf22f3650bc65eed52","MODULE_LICENSE_MIT":"0d6f8afa3940b7f06bebee651376d43bc8b0d5b437337be2696d30377451e93a","README.md":"73fed1c071994c075530feb1dea1c0eca8b8a1959ff81a178530727ffaa4636f","TEST_MAPPING":"7ffa0bced5a01703c33b82d5cfc6feebe888778bbffda68e4c1ecb9c142708ee","cargo_embargo.json":"8e1419c87a07e3391cc5da4d80c695e906b42c95874ff968f4be7a453faf756b","patches/mmio.patch":"67246832486c93662c4e604ff2c7bd4f0d4e7ca420eda6892e4eef0a958fec50","patches/rules.mk.diff":"afdb592f46d323d0e04ec3c033fb272fe7f79c28c5ad544f462bdac4c01f661b","rules.mk":"ab5ae6f7e11b0b2845ee696180c6b68b4f32ba869d3fb16c6ccf650b9cfa8976","rust-toolchain.toml":"e29f2ad5748c6738b191d46ca6a4204014c51626eca5c106ab575225d8c915db","src/device/blk.rs":"cf2ec4daf867d9178ebbd3f284eb678819e99649c710332024f89be35b2930a6","src/device/common.rs":"090d853e88b893aebe01606fafcd9cab96d4601f3b7ce3cb6721975801616e0d","src/device/console.rs":"aa400f9035041f3c6bde186401466dec88785d6e0d03989cebe97224eedffb66","src/device/gpu.rs":"720ee5ccf00d4360897a14367964ccf7e3d0f75fb5f95fdb69ec1ec23212432a","src/device/input.rs":"44fb2d8866eadb5622b7495a05e96e1b5039a54249f175c3f258384a82d1c6c5","src/device/mod.rs":"84c2e13a08d50b7ba647b256a747acbe9cc5da5a15781f94084bf3e5e4be5a34","src/device/net/dev.rs":"9279bf99a856e20a58869403b82e463a05ab4c1e41591f06da6f9f1b9e6c6b99","src/device/net/dev_raw.rs":"9a9706113673beee0b1d63724abd160468997679044dc54152e415cdfabf1a32","src/device/net/mod.rs":"89ce8151b27a93c2bbe958fe5b95c070b4edcbcc7c6fb9a691b1d9dc353e2fbd","src/device/net/net_buf.rs":"367b6d53840b1128659234796848e2808482c2a36c995960b0c41b4e92bf949b","src/device/socket/connectionmanager.rs":"6273d60f4894f87ab86e6e1340fa4feaa5a56654bb248b1ec44d7dd8a2fe0a72","src/device/socket/error.rs":"de5b97fc2d3b38e5980ab242a52d0b778500d5869758d6a32756b4cef0b61f86","src/device/socket/mod.rs":"46ba478462b1c003acf42d449763f0a7457d853ee282f9b9349a6749caa19d2b","src/device/socket/protocol.rs":"4de57579bbfeb219e8068bc7416522f3dc85f9519ddc768bf05a7ae2800cdd17","src/device/socket/vsock.rs":"b169a876414ce10b5715306f7658e8fcecf577e9e59632ad52b21e15c32950eb","src/device/sound.rs":"cc40eff5af3562bff9662196af8018e84ef1cfce6a858a501dec4f4ab03b5a6f","src/device/sound/fake.rs":"bd7a01b7d08291c1ce6830f6720d44454d7021ebe8c36b83798faf5fe656fb6c","src/hal.rs":"f2d413f8924bfe50dbd2705f3febffd111a1ae17f160cdb5d9f12159ca3dc803","src/hal/fake.rs":"4c3ea7153f5627270041a42afe60256bdb52772923e6fdbc864f858c5346e368","src/lib.rs":"c9a768e1cf95a6027fd5da07c782681c2da6d1e5a96873e5ad7a878bf93097da","src/queue.rs":"8d9eabfd29203911883ea26ff8cbc5da6a20b181f2c05e82fe9ac2f7df9bdbd4","src/queue/owning.rs":"e293cfaa34dbe411e7a31079e013e05f11d5cf6a4100ae06979c0b7653fea3c0","src/transport/fake.rs":"4fa75709f281a37440fba484b3e3db27f8286fc2b576951bb9d0c8b0a25645f3","src/transport/mmio.rs":"294e0a32cfb1daeb8be904061652db3465413c14aaaca43155f55d7325c66756","src/transport/mod.rs":"f409a98810767e3623cc6a3b0e4aec9ec48f1102629d48056a81f722384067f2","src/transport/pci.rs":"25b887e554907bcd5038384498225ddbd52771ef614198fcc020f537cbdb268a","src/transport/pci/bus.rs":"7734960260150e0d928ae34be1aca37837cd2b74615aebfc757d18c7c15b825e","src/volatile.rs":"0b759bd807893075242115aa0f461fe5052e008b2022839e95a7602ce93cdd31"}}
\ No newline at end of file
diff --git a/crates/virtio-drivers/.cargo-checksum.json b/crates/virtio-drivers/.cargo-checksum.json
index 5513933..5879c40 100644
--- a/crates/virtio-drivers/.cargo-checksum.json
+++ b/crates/virtio-drivers/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"d3042da40785f988887a5372d639a30e2478cf42d423837374e2ed27abb36b41","LICENSE":"bf2a1b2f68528d6cb47939394b181236858d3e9c6c5e43b3af0650976567f152","README.md":"4ffd7b59f10a299ef4aec75a31a6c2631917ae45b1b44c11551d45896da05aca","rust-toolchain.toml":"3e18e70208ee460635e239a91c142cf67371feafb718b05617ff06f388bf96df","src/device/blk.rs":"ba2b090d15657285d4d97839fa906776c490b3935258c8749b705c3716e3f4f7","src/device/common.rs":"24277c9fba38a2c87fa6f12863e6e003d911cc2fedad2b6a053d869e26be0813","src/device/console.rs":"ef69c28c4759615ca47eddd844f6720113c3b504872c2de4ac9f0ac933618273","src/device/gpu.rs":"6feb344a18ec34bd4cc82a331befee6aefd56f07df63a5b19ffc3d34e69f7f9a","src/device/input.rs":"1d78997a21ec03f014f42ecd8ec6b5df43b482660c222212e85931da932af44d","src/device/mod.rs":"9e71cb1d3c43dca92f00969bc3af6a25fdf42efcdfa03418e9013360d9f47e6f","src/device/net/dev.rs":"1cd4d08e64fb112d2e24c9a6985d1914f9848ba61984c8fe6d9b4c1798554749","src/device/net/dev_raw.rs":"f737395c5e63f2440e54ac6f8382c6e77397dc42f4e23462d75f9db3a51e3ff7","src/device/net/mod.rs":"3c6a513f4b95c92e76b6475b56e8c922635d26f5c83bd404d6e5ea209cb60c40","src/device/net/net_buf.rs":"0e67f22587d9564fe0a0a52182333325be3db7d35ec33f1bb4190a6b89c058d5","src/device/socket/connectionmanager.rs":"9ad10edcef4e4e0ce1e57620057a3e478030421a6ca4dfe1a57627361f1f2658","src/device/socket/error.rs":"622c6d5b6ca15a2a574b6cb967a1afe999c9e7fc9a4bda83c78f90763690a2ec","src/device/socket/mod.rs":"891945d2e88002653a9588bcf0586d6c62792af8fc133c5d1d11262abffb47c1","src/device/socket/protocol.rs":"55857b9ee73513a3595dbca35ecde55bf081bc7d082b27a062b365b06cb8dda7","src/device/socket/vsock.rs":"105f24db7adb1b7460196f7049b0de4bb33cd59a8465e71b8801b98d32251152","src/hal.rs":"f6defc683d81b15cfbb825372f67702565c4424c9988f9b1abb7854c5b31a10c","src/hal/fake.rs":"f26fd9834a6d30bfea6ede5e94a832b574b6ab679578b77d662aea373532ee12","src/lib.rs":"6fa410dc70cd208895d1dc3b22c6546fd6698d11e219408682a537cd59cc7a27","src/queue.rs":"b9029dd19bac643b363ecc8eba3f96f3b3d600ee58682b66fe65acc278578d94","src/transport/fake.rs":"5a9c17f4213c67f1869c827f6263c5e5f94d733e5d1b66fded5c42b1d3ebd798","src/transport/mmio.rs":"d3b8973200da7d608dd0d0055a9a98c1154cc97de3530fbba7a783c63b9c95b3","src/transport/mod.rs":"63d58e00f3d5b7509d01405a6767b67079d93e80c888a2689241f53bab3e8a64","src/transport/pci.rs":"994b25ba4aa7286b6b73eaa3359a57de30a65ceff8f8b7c576afbe52a90d4301","src/transport/pci/bus.rs":"830f3e35a0bfdf83593d1045d2ca17b83c27e1ca86b7bbf2dda5faf497fda5ac","src/volatile.rs":"5240e2e9df29947cad86d68381326d36c034a5c36e552ec7d07f68a15ea0ef1f"},"package":"aa40e09453618c7a927c08c5a990497a2954da7c2aaa6c65e0d4f0fc975f6114"}
\ No newline at end of file
+{"files":{"Cargo.toml":"0dc0e15055e897e5b9b0fb92616c1f533db28d7f997ba978139fd7169143d3b6","LICENSE":"bf2a1b2f68528d6cb47939394b181236858d3e9c6c5e43b3af0650976567f152","README.md":"97d5ec352feb03542347b28fab9b77772163390c95b773d1dd4604dc8320d2c0","rust-toolchain.toml":"3e18e70208ee460635e239a91c142cf67371feafb718b05617ff06f388bf96df","src/device/blk.rs":"6fad0670d896aeb507a52280f8b147b9597348c246a4b59bd6b4134b028e72f1","src/device/common.rs":"24277c9fba38a2c87fa6f12863e6e003d911cc2fedad2b6a053d869e26be0813","src/device/console.rs":"ef69c28c4759615ca47eddd844f6720113c3b504872c2de4ac9f0ac933618273","src/device/gpu.rs":"6feb344a18ec34bd4cc82a331befee6aefd56f07df63a5b19ffc3d34e69f7f9a","src/device/input.rs":"1d78997a21ec03f014f42ecd8ec6b5df43b482660c222212e85931da932af44d","src/device/mod.rs":"225fd5d8c894df988d90e30df91477eeff60fefe9c8f5a789a0ae6c10ff1ea8d","src/device/net/dev.rs":"1cd4d08e64fb112d2e24c9a6985d1914f9848ba61984c8fe6d9b4c1798554749","src/device/net/dev_raw.rs":"dabd95dff8381d836a0e66ea0ec65b8324f9c7030fc372e81ffac5ac759e56c8","src/device/net/mod.rs":"3c6a513f4b95c92e76b6475b56e8c922635d26f5c83bd404d6e5ea209cb60c40","src/device/net/net_buf.rs":"0e67f22587d9564fe0a0a52182333325be3db7d35ec33f1bb4190a6b89c058d5","src/device/socket/connectionmanager.rs":"9ad10edcef4e4e0ce1e57620057a3e478030421a6ca4dfe1a57627361f1f2658","src/device/socket/error.rs":"622c6d5b6ca15a2a574b6cb967a1afe999c9e7fc9a4bda83c78f90763690a2ec","src/device/socket/mod.rs":"891945d2e88002653a9588bcf0586d6c62792af8fc133c5d1d11262abffb47c1","src/device/socket/protocol.rs":"55857b9ee73513a3595dbca35ecde55bf081bc7d082b27a062b365b06cb8dda7","src/device/socket/vsock.rs":"7fb8f14720cea7e3254c42de6b8e869b1af381974d9ba72b4f791383d8902b8f","src/device/sound.rs":"ece2e01e088a9f1358da9bfbebd21119109b81e3727dc5f1667096be0d23bce0","src/device/sound/fake.rs":"4d22e5445a253ff327581f711a1f0b500ddf6e4c46091385d9414c4ea7baba8e","src/hal.rs":"f6defc683d81b15cfbb825372f67702565c4424c9988f9b1abb7854c5b31a10c","src/hal/fake.rs":"f26fd9834a6d30bfea6ede5e94a832b574b6ab679578b77d662aea373532ee12","src/lib.rs":"6fa410dc70cd208895d1dc3b22c6546fd6698d11e219408682a537cd59cc7a27","src/queue.rs":"4b19ae32a6193be11347c079157bb03aaea4a99da769f1f6bb1c2b38c245f35e","src/queue/owning.rs":"f0a225338c21c4f818c982a4c836af3a9543f8cd6ad8d5191cca179836bdfa3c","src/transport/fake.rs":"f4c05883ffe04b6861a5fca73e3b49e7101d599a26e7173e2b0edcc376d687ac","src/transport/mmio.rs":"d3b8973200da7d608dd0d0055a9a98c1154cc97de3530fbba7a783c63b9c95b3","src/transport/mod.rs":"038bfc78bf00f8aa8fa19ca22ca74e8f2c5e2d278dc2adc26dbe80dbc13ce0bf","src/transport/pci.rs":"be73b0fbb40c589435e84ec608237446d17ab7387225fe9cf34c1b090f6aae05","src/transport/pci/bus.rs":"562e4a518ce525e3fce95cab8c60396e2afb0314f2af44a1a25aa9027b16e456","src/volatile.rs":"5240e2e9df29947cad86d68381326d36c034a5c36e552ec7d07f68a15ea0ef1f"},"package":"d6a39747311dabb3d37807037ed1c3c38d39f99198d091b5b79ecd5c8d82f799"}
\ No newline at end of file
diff --git a/crates/virtio-drivers/Android.bp b/crates/virtio-drivers/Android.bp
index d02e648..8530f1a 100644
--- a/crates/virtio-drivers/Android.bp
+++ b/crates/virtio-drivers/Android.bp
@@ -17,15 +17,16 @@
     name: "libvirtio_drivers",
     crate_name: "virtio_drivers",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.7.4",
+    cargo_pkg_version: "0.7.5",
     crate_root: "src/lib.rs",
-    edition: "2018",
+    edition: "2021",
     features: ["alloc"],
     rustlibs: [
         "libbitflags",
         "liblog_rust_nostd",
         "libzerocopy-0.7.35_nostd",
     ],
+    proc_macros: ["libenumn"],
     apex_available: [
         "//apex_available:platform",
         "//apex_available:anyapex",
@@ -42,17 +43,18 @@
     name: "virtio-drivers_test_src_lib",
     crate_name: "virtio_drivers",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.7.4",
+    cargo_pkg_version: "0.7.5",
     crate_root: "src/lib.rs",
     test_suites: ["general-tests"],
     auto_gen_config: true,
-    edition: "2018",
+    edition: "2021",
     features: ["alloc"],
     rustlibs: [
         "libbitflags",
         "liblog_rust_nostd",
         "libzerocopy-0.7.35_nostd",
     ],
+    proc_macros: ["libenumn"],
 }
 
 dirgroup {
diff --git a/crates/virtio-drivers/Cargo.toml b/crates/virtio-drivers/Cargo.toml
index 33b96aa..f631e70 100644
--- a/crates/virtio-drivers/Cargo.toml
+++ b/crates/virtio-drivers/Cargo.toml
@@ -10,9 +10,9 @@
 # See Cargo.toml.orig for the original contents.
 
 [package]
-edition = "2018"
+edition = "2021"
 name = "virtio-drivers"
-version = "0.7.4"
+version = "0.7.5"
 authors = [
     "Jiajie Chen <noc@jiegec.ac.cn>",
     "Runji Wang <wangrunji0408@163.com>",
@@ -30,17 +30,20 @@
 repository = "https://github.com/rcore-os/virtio-drivers"
 
 [dependencies.bitflags]
-version = "2.3.0"
+version = "2.6.0"
+
+[dependencies.enumn]
+version = "0.1.14"
 
 [dependencies.log]
-version = "0.4"
+version = "0.4.22"
 
 [dependencies.zerocopy]
-version = "0.7.5"
+version = "0.7.35"
 features = ["derive"]
 
 [dev-dependencies.zerocopy]
-version = "0.7.5"
+version = "0.7.35"
 features = ["alloc"]
 
 [features]
diff --git a/crates/virtio-drivers/METADATA b/crates/virtio-drivers/METADATA
index 3c392a3..b43ce1e 100644
--- a/crates/virtio-drivers/METADATA
+++ b/crates/virtio-drivers/METADATA
@@ -1,17 +1,17 @@
 name: "virtio-drivers"
 description: "VirtIO guest drivers."
 third_party {
-  version: "0.7.4"
+  version: "0.7.5"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2024
-    month: 7
-    day: 15
+    year: 2025
+    month: 1
+    day: 16
   }
   homepage: "https://crates.io/crates/virtio-drivers"
   identifier {
     type: "Archive"
-    value: "https://static.crates.io/crates/virtio-drivers/virtio-drivers-0.7.4.crate"
-    version: "0.7.4"
+    value: "https://static.crates.io/crates/virtio-drivers/virtio-drivers-0.7.5.crate"
+    version: "0.7.5"
   }
 }
diff --git a/crates/virtio-drivers/README.md b/crates/virtio-drivers/README.md
index fc87378..b1f3797 100644
--- a/crates/virtio-drivers/README.md
+++ b/crates/virtio-drivers/README.md
@@ -18,6 +18,7 @@
 | Input   | ✅        |
 | Console | ✅        |
 | Socket  | ✅        |
+| Sound   | ✅        |
 | ...     | ❌        |
 
 ### Transports
diff --git a/crates/virtio-drivers/rules.mk b/crates/virtio-drivers/rules.mk
index 3ccd69f..efcb0f4 100644
--- a/crates/virtio-drivers/rules.mk
+++ b/crates/virtio-drivers/rules.mk
@@ -9,13 +9,14 @@
 MODULE_RUST_CRATE_TYPES := rlib
 MODULE_SRCS := $(LOCAL_DIR)/src/lib.rs
 MODULE_ADD_IMPLICIT_DEPS := false
-MODULE_RUST_EDITION := 2018
+MODULE_RUST_EDITION := 2021
 MODULE_RUSTFLAGS += \
 	--cfg 'feature="alloc"'
 
 MODULE_LIBRARY_DEPS := \
 	trusty/user/base/lib/liballoc-rust \
 	$(call FIND_CRATE,bitflags) \
+	$(call FIND_CRATE,enumn) \
 	$(call FIND_CRATE,log) \
 	$(call FIND_CRATE,zerocopy) \
 	trusty/user/base/lib/libcompiler_builtins-rust \
diff --git a/crates/virtio-drivers/src/device/blk.rs b/crates/virtio-drivers/src/device/blk.rs
index cbd2dcc..bda6edc 100644
--- a/crates/virtio-drivers/src/device/blk.rs
+++ b/crates/virtio-drivers/src/device/blk.rs
@@ -632,7 +632,7 @@
             State::wait_until_queue_notified(&state, QUEUE);
             println!("Transmit queue was notified.");
 
-            state
+            assert!(state
                 .lock()
                 .unwrap()
                 .read_write_queue::<{ QUEUE_SIZE as usize }>(QUEUE, |request| {
@@ -656,7 +656,7 @@
                     );
 
                     response
-                });
+                }));
         });
 
         // Read a block from the device.
@@ -702,7 +702,7 @@
             State::wait_until_queue_notified(&state, QUEUE);
             println!("Transmit queue was notified.");
 
-            state
+            assert!(state
                 .lock()
                 .unwrap()
                 .read_write_queue::<{ QUEUE_SIZE as usize }>(QUEUE, |request| {
@@ -728,7 +728,7 @@
                     );
 
                     response
-                });
+                }));
         });
 
         // Write a block to the device.
@@ -777,7 +777,7 @@
             State::wait_until_queue_notified(&state, QUEUE);
             println!("Transmit queue was notified.");
 
-            state
+            assert!(state
                 .lock()
                 .unwrap()
                 .read_write_queue::<{ QUEUE_SIZE as usize }>(QUEUE, |request| {
@@ -800,7 +800,7 @@
                     );
 
                     response
-                });
+                }));
         });
 
         // Request to flush.
@@ -844,7 +844,7 @@
             State::wait_until_queue_notified(&state, QUEUE);
             println!("Transmit queue was notified.");
 
-            state
+            assert!(state
                 .lock()
                 .unwrap()
                 .read_write_queue::<{ QUEUE_SIZE as usize }>(QUEUE, |request| {
@@ -868,7 +868,7 @@
                     );
 
                     response
-                });
+                }));
         });
 
         let mut id = [0; 20];
diff --git a/crates/virtio-drivers/src/device/mod.rs b/crates/virtio-drivers/src/device/mod.rs
index d8e6389..5a4e9f2 100644
--- a/crates/virtio-drivers/src/device/mod.rs
+++ b/crates/virtio-drivers/src/device/mod.rs
@@ -11,5 +11,7 @@
 pub mod net;
 
 pub mod socket;
+#[cfg(feature = "alloc")]
+pub mod sound;
 
 pub(crate) mod common;
diff --git a/crates/virtio-drivers/src/device/net/dev_raw.rs b/crates/virtio-drivers/src/device/net/dev_raw.rs
index e9834e0..70b3a17 100644
--- a/crates/virtio-drivers/src/device/net/dev_raw.rs
+++ b/crates/virtio-drivers/src/device/net/dev_raw.rs
@@ -8,11 +8,11 @@
 use log::{debug, info, warn};
 use zerocopy::AsBytes;
 
-/// Raw driver for a VirtIO block device.
+/// Raw driver for a VirtIO network device.
 ///
 /// This is a raw version of the VirtIONet driver. It provides non-blocking
 /// methods for transmitting and receiving raw slices, without the buffer
-/// management. For more higher-level fucntions such as receive buffer backing,
+/// management. For more higher-level functions such as receive buffer backing,
 /// see [`VirtIONet`].
 ///
 /// [`VirtIONet`]: super::VirtIONet
diff --git a/crates/virtio-drivers/src/device/socket/vsock.rs b/crates/virtio-drivers/src/device/socket/vsock.rs
index 6c5a3f2..4a9e33b 100644
--- a/crates/virtio-drivers/src/device/socket/vsock.rs
+++ b/crates/virtio-drivers/src/device/socket/vsock.rs
@@ -7,15 +7,13 @@
 };
 use super::DEFAULT_RX_BUFFER_SIZE;
 use crate::hal::Hal;
-use crate::queue::VirtQueue;
+use crate::queue::{owning::OwningQueue, VirtQueue};
 use crate::transport::Transport;
 use crate::volatile::volread;
-use crate::{Error, Result};
-use alloc::boxed::Box;
+use crate::Result;
 use core::mem::size_of;
-use core::ptr::{null_mut, NonNull};
 use log::debug;
-use zerocopy::{AsBytes, FromBytes, FromZeroes};
+use zerocopy::{AsBytes, FromBytes};
 
 pub(crate) const RX_QUEUE_IDX: u16 = 0;
 pub(crate) const TX_QUEUE_IDX: u16 = 1;
@@ -222,30 +220,13 @@
 {
     transport: T,
     /// Virtqueue to receive packets.
-    rx: VirtQueue<H, { QUEUE_SIZE }>,
+    rx: OwningQueue<H, QUEUE_SIZE, RX_BUFFER_SIZE>,
     tx: VirtQueue<H, { QUEUE_SIZE }>,
     /// Virtqueue to receive events from the device.
     event: VirtQueue<H, { QUEUE_SIZE }>,
     /// The guest_cid field contains the guest’s context ID, which uniquely identifies
     /// the device for its lifetime. The upper 32 bits of the CID are reserved and zeroed.
     guest_cid: u64,
-    rx_queue_buffers: [NonNull<[u8; RX_BUFFER_SIZE]>; QUEUE_SIZE],
-}
-
-// SAFETY: The `rx_queue_buffers` can be accessed from any thread.
-unsafe impl<H: Hal, T: Transport + Send, const RX_BUFFER_SIZE: usize> Send
-    for VirtIOSocket<H, T, RX_BUFFER_SIZE>
-where
-    VirtQueue<H, QUEUE_SIZE>: Send,
-{
-}
-
-// SAFETY: A `&VirtIOSocket` only allows reading the guest CID from a field.
-unsafe impl<H: Hal, T: Transport + Sync, const RX_BUFFER_SIZE: usize> Sync
-    for VirtIOSocket<H, T, RX_BUFFER_SIZE>
-where
-    VirtQueue<H, QUEUE_SIZE>: Sync,
-{
 }
 
 impl<H: Hal, T: Transport, const RX_BUFFER_SIZE: usize> Drop
@@ -257,12 +238,6 @@
         self.transport.queue_unset(RX_QUEUE_IDX);
         self.transport.queue_unset(TX_QUEUE_IDX);
         self.transport.queue_unset(EVENT_QUEUE_IDX);
-
-        for buffer in self.rx_queue_buffers {
-            // Safe because we obtained the RX buffer pointer from Box::into_raw, and it won't be
-            // used anywhere else after the driver is destroyed.
-            unsafe { drop(Box::from_raw(buffer.as_ptr())) };
-        }
     }
 }
 
@@ -281,7 +256,7 @@
         };
         debug!("guest cid: {guest_cid:?}");
 
-        let mut rx = VirtQueue::new(
+        let rx = VirtQueue::new(
             &mut transport,
             RX_QUEUE_IDX,
             negotiated_features.contains(Feature::RING_INDIRECT_DESC),
@@ -300,17 +275,7 @@
             negotiated_features.contains(Feature::RING_EVENT_IDX),
         )?;
 
-        // Allocate and add buffers for the RX queue.
-        let mut rx_queue_buffers = [null_mut(); QUEUE_SIZE];
-        for (i, rx_queue_buffer) in rx_queue_buffers.iter_mut().enumerate() {
-            let mut buffer: Box<[u8; RX_BUFFER_SIZE]> = FromZeroes::new_box_zeroed();
-            // Safe because the buffer lives as long as the queue, as specified in the function
-            // safety requirement, and we don't access it until it is popped.
-            let token = unsafe { rx.add(&[], &mut [buffer.as_mut_slice()]) }?;
-            assert_eq!(i, token.into());
-            *rx_queue_buffer = Box::into_raw(buffer);
-        }
-        let rx_queue_buffers = rx_queue_buffers.map(|ptr| NonNull::new(ptr).unwrap());
+        let rx = OwningQueue::new(rx)?;
 
         transport.finish_init();
         if rx.should_notify() {
@@ -323,7 +288,6 @@
             tx,
             event,
             guest_cid,
-            rx_queue_buffers,
         })
     }
 
@@ -412,18 +376,10 @@
         &mut self,
         handler: impl FnOnce(VsockEvent, &[u8]) -> Result<Option<VsockEvent>>,
     ) -> Result<Option<VsockEvent>> {
-        let Some((header, body, token)) = self.pop_packet_from_rx_queue()? else {
-            return Ok(None);
-        };
-
-        let result = VsockEvent::from_header(&header).and_then(|event| handler(event, body));
-
-        unsafe {
-            // TODO: What about if both handler and this give errors?
-            self.add_buffer_to_rx_queue(token)?;
-        }
-
-        result
+        self.rx.poll(&mut self.transport, |buffer| {
+            let (header, body) = read_header_and_body(buffer)?;
+            VsockEvent::from_header(&header).and_then(|event| handler(event, body))
+        })
     }
 
     /// Requests to shut down the connection cleanly, sending hints about whether we will send or
@@ -481,78 +437,19 @@
         };
         Ok(())
     }
-
-    /// Adds the buffer at the given index in `rx_queue_buffers` back to the RX queue.
-    ///
-    /// # Safety
-    ///
-    /// The buffer must not currently be in the RX queue, and no other references to it must exist
-    /// between when this method is called and when it is popped from the queue.
-    unsafe fn add_buffer_to_rx_queue(&mut self, index: u16) -> Result {
-        // Safe because the buffer lives as long as the queue, and the caller guarantees that it's
-        // not currently in the queue or referred to anywhere else until it is popped.
-        unsafe {
-            let buffer = self
-                .rx_queue_buffers
-                .get_mut(usize::from(index))
-                .ok_or(Error::WrongToken)?
-                .as_mut();
-            let new_token = self.rx.add(&[], &mut [buffer])?;
-            // If the RX buffer somehow gets assigned a different token, then our safety assumptions
-            // are broken and we can't safely continue to do anything with the device.
-            assert_eq!(new_token, index);
-        }
-
-        if self.rx.should_notify() {
-            self.transport.notify(RX_QUEUE_IDX);
-        }
-
-        Ok(())
-    }
-
-    /// Pops one packet from the RX queue, if there is one pending. Returns the header, and a
-    /// reference to the buffer containing the body.
-    ///
-    /// Returns `None` if there is no pending packet.
-    fn pop_packet_from_rx_queue(&mut self) -> Result<Option<(VirtioVsockHdr, &[u8], u16)>> {
-        let Some(token) = self.rx.peek_used() else {
-            return Ok(None);
-        };
-
-        // Safe because we maintain a consistent mapping of tokens to buffers, so we pass the same
-        // buffer to `pop_used` as we previously passed to `add` for the token. Once we add the
-        // buffer back to the RX queue then we don't access it again until next time it is popped.
-        let (header, body) = unsafe {
-            let buffer = self.rx_queue_buffers[usize::from(token)].as_mut();
-            let _len = self.rx.pop_used(token, &[], &mut [buffer])?;
-
-            // Read the header and body from the buffer. Don't check the result yet, because we need
-            // to add the buffer back to the queue either way.
-            let header_result = read_header_and_body(buffer);
-            if header_result.is_err() {
-                // If there was an error, add the buffer back immediately. Ignore any errors, as we
-                // need to return the first error.
-                let _ = self.add_buffer_to_rx_queue(token);
-            }
-
-            header_result
-        }?;
-
-        debug!("Received packet {:?}. Op {:?}", header, header.op());
-        Ok(Some((header, body, token)))
-    }
 }
 
 fn read_header_and_body(buffer: &[u8]) -> Result<(VirtioVsockHdr, &[u8])> {
-    // Shouldn't panic, because we know `RX_BUFFER_SIZE > size_of::<VirtioVsockHdr>()`.
-    let header = VirtioVsockHdr::read_from_prefix(buffer).unwrap();
+    // This could fail if the device returns a buffer used length shorter than the header size.
+    let header = VirtioVsockHdr::read_from_prefix(buffer).ok_or(SocketError::BufferTooShort)?;
     let body_length = header.len() as usize;
 
     // This could fail if the device returns an unreasonably long body length.
     let data_end = size_of::<VirtioVsockHdr>()
         .checked_add(body_length)
         .ok_or(SocketError::InvalidNumber)?;
-    // This could fail if the device returns a body length longer than the buffer we gave it.
+    // This could fail if the device returns a body length longer than buffer used length it
+    // returned.
     let data = buffer
         .get(size_of::<VirtioVsockHdr>()..data_end)
         .ok_or(SocketError::BufferTooShort)?;
diff --git a/crates/virtio-drivers/src/device/sound.rs b/crates/virtio-drivers/src/device/sound.rs
new file mode 100644
index 0000000..571a55a
--- /dev/null
+++ b/crates/virtio-drivers/src/device/sound.rs
@@ -0,0 +1,1780 @@
+//! Driver for VirtIO Sound devices.
+
+#[cfg(test)]
+mod fake;
+
+use super::common::Feature;
+use crate::{
+    queue::{owning::OwningQueue, VirtQueue},
+    transport::Transport,
+    volatile::{volread, ReadOnly},
+    Error, Hal, Result, PAGE_SIZE,
+};
+use alloc::{boxed::Box, collections::BTreeMap, vec, vec::Vec};
+use bitflags::bitflags;
+use core::{
+    array,
+    fmt::{self, Debug, Display, Formatter},
+    hint::spin_loop,
+    mem::size_of,
+    ops::RangeInclusive,
+};
+use enumn::N;
+use log::{error, info, warn};
+use zerocopy::{AsBytes, FromBytes, FromZeroes};
+
+/// Audio driver based on virtio v1.2.
+///
+/// Supports synchronous blocking and asynchronous non-blocking audio playback.
+///
+/// Currently, only audio playback functionality has been implemented.
+pub struct VirtIOSound<H: Hal, T: Transport> {
+    transport: T,
+
+    control_queue: VirtQueue<H, { QUEUE_SIZE as usize }>,
+    event_queue: OwningQueue<H, { QUEUE_SIZE as usize }, { size_of::<VirtIOSndEvent>() }>,
+    tx_queue: VirtQueue<H, { QUEUE_SIZE as usize }>,
+    rx_queue: VirtQueue<H, { QUEUE_SIZE as usize }>,
+
+    negotiated_features: Feature,
+
+    jacks: u32,
+    streams: u32,
+    chmaps: u32,
+
+    pcm_infos: Option<Vec<VirtIOSndPcmInfo>>,
+    jack_infos: Option<Vec<VirtIOSndJackInfo>>,
+    chmap_infos: Option<Vec<VirtIOSndChmapInfo>>,
+
+    // pcm params
+    pcm_parameters: Vec<PcmParameters>,
+
+    queue_buf_send: Box<[u8]>,
+    queue_buf_recv: Box<[u8]>,
+
+    set_up: bool,
+
+    token_rsp: BTreeMap<u16, Box<VirtIOSndPcmStatus>>, // includes pcm_xfer response msg
+
+    pcm_states: Vec<PCMState>,
+
+    token_buf: BTreeMap<u16, Vec<u8>>, // store token and its input buf
+}
+
+impl<H: Hal, T: Transport> VirtIOSound<H, T> {
+    /// Create a new VirtIO-Sound driver.
+    pub fn new(mut transport: T) -> Result<Self> {
+        let negotiated_features = transport.begin_init(SUPPORTED_FEATURES);
+        info!(
+            "[sound device] negotiated_features: {:?}",
+            negotiated_features
+        );
+
+        let control_queue = VirtQueue::new(
+            &mut transport,
+            CONTROL_QUEUE_IDX,
+            negotiated_features.contains(Feature::RING_INDIRECT_DESC),
+            negotiated_features.contains(Feature::RING_EVENT_IDX),
+        )?;
+        let event_queue = OwningQueue::new(VirtQueue::new(
+            &mut transport,
+            EVENT_QUEUE_IDX,
+            negotiated_features.contains(Feature::RING_INDIRECT_DESC),
+            negotiated_features.contains(Feature::RING_EVENT_IDX),
+        )?)?;
+        let tx_queue = VirtQueue::new(
+            &mut transport,
+            TX_QUEUE_IDX,
+            negotiated_features.contains(Feature::RING_INDIRECT_DESC),
+            negotiated_features.contains(Feature::RING_EVENT_IDX),
+        )?;
+        let rx_queue = VirtQueue::new(
+            &mut transport,
+            RX_QUEUE_IDX,
+            negotiated_features.contains(Feature::RING_INDIRECT_DESC),
+            negotiated_features.contains(Feature::RING_EVENT_IDX),
+        )?;
+
+        // read configuration space
+        let config_ptr = transport.config_space::<VirtIOSoundConfig>()?;
+        // SAFETY: config_ptr is a valid pointer to the device configuration space.
+        let (jacks, streams, chmaps) = unsafe {
+            (
+                volread!(config_ptr, jacks),
+                volread!(config_ptr, streams),
+                volread!(config_ptr, chmaps),
+            )
+        };
+        info!(
+            "[sound device] config: jacks: {}, streams: {}, chmaps: {}",
+            jacks, streams, chmaps
+        );
+
+        let queue_buf_send = FromZeroes::new_box_slice_zeroed(PAGE_SIZE);
+        let queue_buf_recv = FromZeroes::new_box_slice_zeroed(PAGE_SIZE);
+
+        // set pcm params to default
+        let mut pcm_parameters = vec![];
+        for _ in 0..streams {
+            pcm_parameters.push(PcmParameters::default());
+        }
+
+        transport.finish_init();
+
+        if event_queue.should_notify() {
+            transport.notify(EVENT_QUEUE_IDX);
+        }
+
+        Ok(VirtIOSound {
+            transport,
+            control_queue,
+            event_queue,
+            tx_queue,
+            rx_queue,
+            negotiated_features,
+            jacks,
+            streams,
+            chmaps,
+            pcm_infos: None,
+            jack_infos: None,
+            chmap_infos: None,
+            queue_buf_send,
+            queue_buf_recv,
+            pcm_parameters,
+            set_up: false,
+            token_rsp: BTreeMap::new(),
+            pcm_states: vec![],
+            token_buf: BTreeMap::new(),
+        })
+    }
+
+    /// Total jack num.
+    pub fn jacks(&self) -> u32 {
+        self.jacks
+    }
+
+    /// Total stream num.
+    pub fn streams(&self) -> u32 {
+        self.streams
+    }
+
+    /// Total chmap num.
+    pub fn chmaps(&self) -> u32 {
+        self.chmaps
+    }
+
+    /// Acknowledge interrupt.
+    pub fn ack_interrupt(&mut self) -> bool {
+        self.transport.ack_interrupt()
+    }
+
+    fn request<Req: AsBytes>(&mut self, req: Req) -> Result<VirtIOSndHdr> {
+        self.control_queue.add_notify_wait_pop(
+            &[req.as_bytes()],
+            &mut [self.queue_buf_recv.as_bytes_mut()],
+            &mut self.transport,
+        )?;
+        Ok(VirtIOSndHdr::read_from_prefix(&self.queue_buf_recv).unwrap())
+    }
+
+    /// Set up the driver, initate pcm_infos and jacks_infos
+    fn set_up(&mut self) -> Result<()> {
+        // init jack info
+        if let Ok(jack_infos) = self.jack_info(0, self.jacks) {
+            for jack_info in &jack_infos {
+                info!("[sound device] jack_info: {}", jack_info);
+            }
+            self.jack_infos = Some(jack_infos);
+        } else {
+            self.jack_infos = Some(vec![]);
+            warn!("[sound device] Error getting jack infos");
+        }
+
+        // init pcm info
+        let pcm_infos = self.pcm_info(0, self.streams)?;
+        for pcm_info in &pcm_infos {
+            info!("[sound device] pcm_info: {}", pcm_info);
+        }
+        self.pcm_infos = Some(pcm_infos);
+
+        // init chmap info
+        if let Ok(chmap_infos) = self.chmap_info(0, self.chmaps) {
+            for chmap_info in &chmap_infos {
+                info!("[sound device] chmap_info: {}", chmap_info);
+            }
+            self.chmap_infos = Some(chmap_infos);
+        } else {
+            self.chmap_infos = Some(vec![]);
+            warn!("[sound device] Error getting chmap infos");
+        }
+
+        // set pcm state to default
+        for _ in 0..self.streams {
+            self.pcm_states.push(PCMState::default());
+        }
+        Ok(())
+    }
+
+    /// Enables interrupts from the device.
+    pub fn enable_interrupts(&mut self, enable: bool) {
+        self.event_queue.set_dev_notify(enable);
+    }
+
+    /// Query information about the available jacks.
+    fn jack_info(&mut self, jack_start_id: u32, jack_count: u32) -> Result<Vec<VirtIOSndJackInfo>> {
+        if jack_start_id + jack_count > self.jacks {
+            error!("jack_start_id + jack_count > jacks! There are not enough jacks to be queried!");
+            return Err(Error::IoError);
+        }
+        let hdr = self.request(VirtIOSndQueryInfo {
+            hdr: ItemInformationRequestType::RJackInfo.into(),
+            start_id: jack_start_id,
+            count: jack_count,
+            size: size_of::<VirtIOSndJackInfo>() as u32,
+        })?;
+        if hdr != RequestStatusCode::Ok.into() {
+            return Err(Error::IoError);
+        }
+        // read struct VirtIOSndJackInfo
+        let mut jack_infos = vec![];
+        for i in 0..jack_count as usize {
+            const HDR_SIZE: usize = size_of::<VirtIOSndHdr>();
+            const JACK_INFO_SIZE: usize = size_of::<VirtIOSndJackInfo>();
+            let start_byte_idx = HDR_SIZE + i * JACK_INFO_SIZE;
+            let end_byte_idx = HDR_SIZE + (i + 1) * JACK_INFO_SIZE;
+            let jack_info =
+                VirtIOSndJackInfo::read_from(&self.queue_buf_recv[start_byte_idx..end_byte_idx])
+                    .unwrap();
+            jack_infos.push(jack_info)
+        }
+        Ok(jack_infos)
+    }
+
+    /// Query information about the available streams.
+    fn pcm_info(
+        &mut self,
+        stream_start_id: u32,
+        stream_count: u32,
+    ) -> Result<Vec<VirtIOSndPcmInfo>> {
+        if stream_start_id + stream_count > self.streams {
+            error!("stream_start_id + stream_count > streams! There are not enough streams to be queried!");
+            return Err(Error::IoError);
+        }
+        let request_hdr = VirtIOSndHdr::from(ItemInformationRequestType::RPcmInfo);
+        let hdr = self.request(VirtIOSndQueryInfo {
+            hdr: request_hdr,
+            start_id: stream_start_id,
+            count: stream_count,
+            size: size_of::<VirtIOSndPcmInfo>() as u32,
+        })?;
+        if hdr != RequestStatusCode::Ok.into() {
+            return Err(Error::IoError);
+        }
+        // read struct VirtIOSndPcmInfo
+        let mut pcm_infos = vec![];
+        for i in 0..stream_count as usize {
+            const HDR_SIZE: usize = size_of::<VirtIOSndHdr>();
+            const PCM_INFO_SIZE: usize = size_of::<VirtIOSndPcmInfo>();
+            let start_byte_idx = HDR_SIZE + i * PCM_INFO_SIZE;
+            let end_byte_idx = HDR_SIZE + (i + 1) * PCM_INFO_SIZE;
+            let pcm_info =
+                VirtIOSndPcmInfo::read_from(&self.queue_buf_recv[start_byte_idx..end_byte_idx])
+                    .unwrap();
+            pcm_infos.push(pcm_info);
+        }
+        Ok(pcm_infos)
+    }
+
+    /// Query information about the available chmaps.
+    fn chmap_info(
+        &mut self,
+        chmaps_start_id: u32,
+        chmaps_count: u32,
+    ) -> Result<Vec<VirtIOSndChmapInfo>> {
+        if chmaps_start_id + chmaps_count > self.chmaps {
+            error!("chmaps_start_id + chmaps_count > self.chmaps");
+            return Err(Error::IoError);
+        }
+        let hdr = self.request(VirtIOSndQueryInfo {
+            hdr: ItemInformationRequestType::RChmapInfo.into(),
+            start_id: chmaps_start_id,
+            count: chmaps_count,
+            size: size_of::<VirtIOSndChmapInfo>() as u32,
+        })?;
+        if hdr != RequestStatusCode::Ok.into() {
+            return Err(Error::IoError);
+        }
+        let mut chmap_infos = vec![];
+        for i in 0..chmaps_count as usize {
+            const OFFSET: usize = size_of::<VirtIOSndHdr>();
+            let start_byte = OFFSET + i * size_of::<VirtIOSndChmapInfo>();
+            let end_byte = OFFSET + (i + 1) * size_of::<VirtIOSndChmapInfo>();
+            let chmap_info =
+                VirtIOSndChmapInfo::read_from(&self.queue_buf_recv[start_byte..end_byte]).unwrap();
+            chmap_infos.push(chmap_info);
+        }
+        Ok(chmap_infos)
+    }
+
+    /// If the VIRTIO_SND_JACK_F_REMAP feature bit is set in the jack information, then the driver can send a
+    /// control request to change the association and/or sequence number for the specified jack ID.
+    /// # Arguments
+    ///
+    /// * `jack_id` - A u32 int which is in the range of [0, jacks)
+    pub fn jack_remap(&mut self, jack_id: u32, association: u32, sequence: u32) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if self.jacks == 0 {
+            error!("[sound device] There is no available jacks!");
+            return Err(Error::InvalidParam);
+        }
+        if jack_id >= self.jacks {
+            error!("jack_id >= self.jacks! Make sure jack_id is in the range of [0, jacks - 1)!");
+            return Err(Error::InvalidParam);
+        }
+
+        let jack_features = JackFeatures::from_bits_retain(
+            self.jack_infos
+                .as_ref()
+                .unwrap()
+                .get(jack_id as usize)
+                .unwrap()
+                .features,
+        );
+        if !jack_features.contains(JackFeatures::REMAP) {
+            error!("The jack selected does not support VIRTIO_SND_JACK_F_REMAP!");
+            return Err(Error::Unsupported);
+        }
+        let hdr = self.request(VirtIOSndJackRemap {
+            hdr: VirtIOSndJackHdr {
+                hdr: CommandCode::RJackRemap.into(),
+                jack_id,
+            },
+            association,
+            sequence,
+        })?;
+        if hdr == RequestStatusCode::Ok.into() {
+            Ok(())
+        } else {
+            Err(Error::Unsupported)
+        }
+    }
+
+    /// Set selected stream parameters for the specified stream ID.
+    pub fn pcm_set_params(
+        &mut self,
+        stream_id: u32,
+        buffer_bytes: u32,
+        period_bytes: u32,
+        features: PcmFeatures,
+        channels: u8,
+        format: PcmFormat,
+        rate: PcmRate,
+    ) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if period_bytes == 0 || period_bytes > buffer_bytes || buffer_bytes % period_bytes != 0 {
+            return Err(Error::InvalidParam);
+        }
+        let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmSetParams);
+        let rsp = self.request(VirtIOSndPcmSetParams {
+            hdr: VirtIOSndPcmHdr {
+                hdr: request_hdr,
+                stream_id,
+            },
+            buffer_bytes,
+            period_bytes,
+            features: features.bits(),
+            channels,
+            format: format.into(),
+            rate: rate.into(),
+            _padding: 0,
+        })?;
+        // rsp is just a header, so it can be compared with VirtIOSndHdr
+        if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) {
+            self.pcm_parameters[stream_id as usize] = PcmParameters {
+                setup: true,
+                buffer_bytes,
+                period_bytes,
+                features,
+                channels,
+                format,
+                rate,
+            };
+            Ok(())
+        } else {
+            Err(Error::IoError)
+        }
+    }
+
+    /// Prepare a stream with specified stream ID.
+    pub fn pcm_prepare(&mut self, stream_id: u32) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmPrepare);
+        let rsp = self.request(VirtIOSndPcmHdr {
+            hdr: request_hdr,
+            stream_id,
+        })?;
+        // rsp is just a header, so it can be compared with VirtIOSndHdr
+        if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) {
+            Ok(())
+        } else {
+            Err(Error::IoError)
+        }
+    }
+
+    /// Release a stream with specified stream ID.
+    pub fn pcm_release(&mut self, stream_id: u32) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmRelease);
+        let rsp = self.request(VirtIOSndPcmHdr {
+            hdr: request_hdr,
+            stream_id,
+        })?;
+        // rsp is just a header, so it can be compared with VirtIOSndHdr
+        if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) {
+            Ok(())
+        } else {
+            Err(Error::IoError)
+        }
+    }
+
+    /// Start a stream with specified stream ID.
+    pub fn pcm_start(&mut self, stream_id: u32) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmStart);
+        let rsp = self.request(VirtIOSndPcmHdr {
+            hdr: request_hdr,
+            stream_id,
+        })?;
+        // rsp is just a header, so it can be compared with VirtIOSndHdr
+        if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) {
+            Ok(())
+        } else {
+            Err(Error::IoError)
+        }
+    }
+
+    /// Stop a stream with specified stream ID.
+    pub fn pcm_stop(&mut self, stream_id: u32) -> Result {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        let request_hdr = VirtIOSndHdr::from(CommandCode::RPcmStop);
+        let rsp = self.request(VirtIOSndPcmHdr {
+            hdr: request_hdr,
+            stream_id,
+        })?;
+        // rsp is just a header, so it can be compared with VirtIOSndHdr
+        if rsp == VirtIOSndHdr::from(RequestStatusCode::Ok) {
+            Ok(())
+        } else {
+            Err(Error::IoError)
+        }
+    }
+
+    /// Transfer PCM frame to device, based on the stream type(OUTPUT/INPUT).
+    ///
+    /// Currently supports only output stream.
+    ///
+    /// This is a blocking method that will not return until the audio playback is complete.
+    pub fn pcm_xfer(&mut self, stream_id: u32, frames: &[u8]) -> Result {
+        const U32_SIZE: usize = size_of::<u32>();
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if !self.pcm_parameters[stream_id as usize].setup {
+            warn!("Please set parameters for a stream before using it!");
+            return Err(Error::IoError);
+        }
+
+        let stream_id_bytes = stream_id.to_le_bytes();
+        let period_size = self.pcm_parameters[stream_id as usize].period_bytes as usize;
+
+        let mut remaining_buffers = frames.chunks(period_size);
+        let mut buffers: [Option<&[u8]>; QUEUE_SIZE as usize] = [None; QUEUE_SIZE as usize];
+        let mut statuses: [VirtIOSndPcmStatus; QUEUE_SIZE as usize] =
+            array::from_fn(|_| Default::default());
+        let mut tokens = [0; QUEUE_SIZE as usize];
+        // The next element of `statuses` and `tokens` to use for adding to the queue.
+        let mut head = 0;
+        // The next element of `status` and `tokens` to use for popping the queue.
+        let mut tail = 0;
+
+        loop {
+            // Add as buffers to the TX queue if possible. 3 descriptors are required for the 2
+            // input buffers and 1 output buffer.
+            if self.tx_queue.available_desc() >= 3 {
+                if let Some(buffer) = remaining_buffers.next() {
+                    tokens[head] = unsafe {
+                        self.tx_queue.add(
+                            &[&stream_id_bytes, buffer],
+                            &mut [statuses[head].as_bytes_mut()],
+                        )?
+                    };
+                    if self.tx_queue.should_notify() {
+                        self.transport.notify(TX_QUEUE_IDX);
+                    }
+                    buffers[head] = Some(buffer);
+                    head += 1;
+                    if head >= usize::from(QUEUE_SIZE) {
+                        head = 0;
+                    }
+                } else if head == tail {
+                    break;
+                }
+            }
+            if self.tx_queue.can_pop() {
+                unsafe {
+                    self.tx_queue.pop_used(
+                        tokens[tail],
+                        &[&stream_id_bytes, buffers[tail].unwrap()],
+                        &mut [statuses[tail].as_bytes_mut()],
+                    )?;
+                }
+                if statuses[tail].status != CommandCode::SOk.into() {
+                    return Err(Error::IoError);
+                }
+                tail += 1;
+                if tail >= usize::from(QUEUE_SIZE) {
+                    tail = 0;
+                }
+            }
+            spin_loop();
+        }
+
+        Ok(())
+    }
+
+    /// Transfer PCM frame to device, based on the stream type(OUTPUT/INPUT).
+    ///
+    /// Currently supports only output stream.
+    ///
+    /// This is a non-blocking method that returns a token.
+    ///
+    /// The length of the `frames` must be equal to the buffer size set for the stream corresponding to the `stream_id`.
+    pub fn pcm_xfer_nb(&mut self, stream_id: u32, frames: &[u8]) -> Result<u16> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if !self.pcm_parameters[stream_id as usize].setup {
+            warn!("Please set parameters for a stream before using it!");
+            return Err(Error::IoError);
+        }
+        const U32_SIZE: usize = size_of::<u32>();
+        let period_size: usize = self.pcm_parameters[stream_id as usize].period_bytes as usize;
+        assert_eq!(period_size, frames.len());
+        let mut buf = vec![0; U32_SIZE + period_size];
+        buf[..U32_SIZE].copy_from_slice(&stream_id.to_le_bytes());
+        buf[U32_SIZE..U32_SIZE + period_size].copy_from_slice(frames);
+        let mut rsp = VirtIOSndPcmStatus::new_box_zeroed();
+        let token = unsafe { self.tx_queue.add(&[&buf], &mut [rsp.as_bytes_mut()])? };
+        if self.tx_queue.should_notify() {
+            self.transport.notify(TX_QUEUE_IDX);
+        }
+        self.token_buf.insert(token, buf);
+        self.token_rsp.insert(token, rsp);
+        Ok(token)
+    }
+
+    /// The PCM frame transmission corresponding to the given token has been completed.
+    pub fn pcm_xfer_ok(&mut self, token: u16) -> Result {
+        assert!(self.token_buf.contains_key(&token));
+        assert!(self.token_rsp.contains_key(&token));
+        unsafe {
+            self.tx_queue.pop_used(
+                token,
+                &[&self.token_buf[&token]],
+                &mut [self.token_rsp.get_mut(&token).unwrap().as_bytes_mut()],
+            )?;
+        }
+
+        self.token_buf.remove(&token);
+        self.token_rsp.remove(&token);
+        Ok(())
+    }
+
+    /// Get all output streams.
+    pub fn output_streams(&mut self) -> Result<Vec<u32>> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        Ok(self
+            .pcm_infos
+            .as_ref()
+            .unwrap()
+            .iter()
+            .enumerate()
+            .filter(|(_, info)| info.direction == VIRTIO_SND_D_OUTPUT)
+            .map(|(idx, _)| idx as u32)
+            .collect())
+    }
+
+    /// Get all input streams.
+    pub fn input_streams(&mut self) -> Result<Vec<u32>> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        Ok(self
+            .pcm_infos
+            .as_ref()
+            .unwrap()
+            .iter()
+            .enumerate()
+            .filter(|(_, info)| info.direction == VIRTIO_SND_D_INPUT)
+            .map(|(idx, _)| idx as u32)
+            .collect())
+    }
+
+    /// Get the rates that a stream supports.
+    pub fn rates_supported(&mut self, stream_id: u32) -> Result<PcmRates> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 {
+            return Err(Error::InvalidParam);
+        }
+        Ok(PcmRates::from_bits_retain(
+            self.pcm_infos.as_ref().unwrap()[stream_id as usize].rates,
+        ))
+    }
+
+    /// Get the formats that a stream supports.
+    pub fn formats_supported(&mut self, stream_id: u32) -> Result<PcmFormats> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 {
+            return Err(Error::InvalidParam);
+        }
+        Ok(PcmFormats::from_bits_retain(
+            self.pcm_infos.as_ref().unwrap()[stream_id as usize].formats,
+        ))
+    }
+
+    /// Get channel range that a stream supports.
+    pub fn channel_range_supported(&mut self, stream_id: u32) -> Result<RangeInclusive<u8>> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 {
+            return Err(Error::InvalidParam);
+        }
+        let pcm_info = &self.pcm_infos.as_ref().unwrap()[stream_id as usize];
+        Ok(pcm_info.channels_min..=pcm_info.channels_max)
+    }
+
+    /// Get features that a stream supports.
+    pub fn features_supported(&mut self, stream_id: u32) -> Result<PcmFeatures> {
+        if !self.set_up {
+            self.set_up()?;
+            self.set_up = true;
+        }
+        if stream_id >= self.pcm_infos.as_ref().unwrap().len() as u32 {
+            return Err(Error::InvalidParam);
+        }
+        let pcm_info = &self.pcm_infos.as_ref().unwrap()[stream_id as usize];
+        Ok(PcmFeatures::from_bits_retain(pcm_info.features))
+    }
+
+    /// Get the latest notification.
+    pub fn latest_notification(&mut self) -> Result<Option<Notification>> {
+        // If the device has written notifications to the event_queue,
+        // then the oldest notification should be at the front of the queue.
+        self.event_queue.poll(&mut self.transport, |buffer| {
+            if let Some(event) = VirtIOSndEvent::read_from(buffer) {
+                Ok(Some(Notification {
+                    notification_type: NotificationType::n(event.hdr.command_code)
+                        .ok_or(Error::IoError)?,
+                    data: event.data,
+                }))
+            } else {
+                Ok(None)
+            }
+        })
+    }
+}
+
+/// The status of the PCM stream.
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
+enum PCMState {
+    #[default]
+    SetParams,
+    Prepare,
+    Release,
+    Start,
+    Stop,
+}
+
+const QUEUE_SIZE: u16 = 32;
+const CONTROL_QUEUE_IDX: u16 = 0;
+const EVENT_QUEUE_IDX: u16 = 1;
+const TX_QUEUE_IDX: u16 = 2;
+const RX_QUEUE_IDX: u16 = 3;
+
+const SUPPORTED_FEATURES: Feature = Feature::RING_INDIRECT_DESC.union(Feature::RING_EVENT_IDX);
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+    #[repr(transparent)]
+    struct JackFeatures: u32 {
+        /// Jack remapping support.
+        const REMAP = 1 << 0;
+    }
+}
+
+bitflags! {
+    /// Supported PCM stream features.
+    #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+    #[repr(transparent)]
+    pub struct PcmFeatures: u32 {
+        /// Supports sharing a host memory with a guest.
+        const SHMEM_HOST = 1 << 0;
+        /// Supports sharing a guest memory with a host.
+        const SHMEM_GUEST = 1 << 1;
+        /// Supports polling mode for message-based transport.
+        const MSG_POLLING = 1 << 2;
+        /// Supports elapsed period notifications for shared memory transport.
+        const EVT_SHMEM_PERIODS = 1 << 3;
+        /// Supports underrun/overrun notifications.
+        const EVT_XRUNS = 1 << 4;
+    }
+}
+
+bitflags! {
+    /// Supported PCM sample formats.
+    #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+    #[repr(transparent)]
+    pub struct PcmFormats: u64 {
+        /// IMA ADPCM format.
+        const IMA_ADPCM = 1 << 0;
+        /// Mu-law format.
+        const MU_LAW = 1 << 1;
+        /// A-law format.
+        const A_LAW = 1 << 2;
+        /// Signed 8-bit format.
+        const S8 = 1 << 3;
+        /// Unsigned 8-bit format.
+        const U8 = 1 << 4;
+        /// Signed 16-bit format.
+        const S16 = 1 << 5;
+        /// Unsigned 16-bit format.
+        const U16 = 1 << 6;
+        /// Signed 18.3-bit format.
+        const S18_3 = 1 << 7;
+        /// Unsigned 18.3-bit format.
+        const U18_3 = 1 << 8;
+        /// Signed 20.3-bit format.
+        const S20_3 = 1 << 9;
+        /// Unsigned 20.3-bit format.
+        const U20_3 = 1 << 10;
+        /// Signed 24.3-bit format.
+        const S24_3 = 1 << 11;
+        /// Unsigned 24.3-bit format.
+        const U24_3 = 1 << 12;
+        /// Signed 20-bit format.
+        const S20 = 1 << 13;
+        /// Unsigned 20-bit format.
+        const U20 = 1 << 14;
+        /// Signed 24-bit format.
+        const S24 = 1 << 15;
+        /// Unsigned 24-bit format.
+        const U24 = 1 << 16;
+        /// Signed 32-bit format.
+        const S32 = 1 << 17;
+        /// Unsigned 32-bit format.
+        const U32 = 1 << 18;
+        /// 32-bit floating-point format.
+        const FLOAT = 1 << 19;
+        /// 64-bit floating-point format.
+        const FLOAT64 = 1 << 20;
+        /// DSD unsigned 8-bit format.
+        const DSD_U8 = 1 << 21;
+        /// DSD unsigned 16-bit format.
+        const DSD_U16 = 1 << 22;
+        /// DSD unsigned 32-bit format.
+        const DSD_U32 = 1 << 23;
+        /// IEC958 subframe format.
+        const IEC958_SUBFRAME = 1 << 24;
+    }
+}
+
+/// A single PCM sample format.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+#[repr(u8)]
+pub enum PcmFormat {
+    /// IMA ADPCM format.
+    #[default]
+    ImaAdpcm = 0,
+    /// Mu-law format.
+    MuLaw = 1,
+    /// A-law format.
+    ALaw = 2,
+    /// Signed 8-bit format.
+    S8 = 3,
+    /// Unsigned 8-bit format.
+    U8 = 4,
+    /// Signed 16-bit format.
+    S16 = 5,
+    /// Unsigned 16-bit format.
+    U16 = 6,
+    /// Signed 18.3-bit format.
+    S18_3 = 7,
+    /// Unsigned 18.3-bit format.
+    U18_3 = 8,
+    /// Signed 20.3-bit format.
+    S20_3 = 9,
+    /// Unsigned 20.3-bit format.
+    U20_3 = 10,
+    /// Signed 24.3-bit format.
+    S24_3 = 11,
+    /// Unsigned 24.3-bit format.
+    U24_3 = 12,
+    /// Signed 20-bit format.
+    S20 = 13,
+    /// Unsigned 20-bit format.
+    U20 = 14,
+    /// Signed 24-bit format.
+    S24 = 15,
+    /// Unsigned 24-bit format.
+    U24 = 16,
+    /// Signed 32-bit format.
+    S32 = 17,
+    /// Unsigned 32-bit format.
+    U32 = 18,
+    /// 32-bit floating-point format.
+    FLOAT = 19,
+    /// 64-bit floating-point format.
+    FLOAT64 = 20,
+    /// DSD unsigned 8-bit format.
+    DsdU8 = 21,
+    /// DSD unsigned 16-bit format.
+    DsdU16 = 22,
+    /// DSD unsigned 32-bit format.
+    DsdU32 = 23,
+    /// IEC958 subframe format.
+    Iec958Subframe = 24,
+}
+
+impl From<PcmFormat> for PcmFormats {
+    fn from(format: PcmFormat) -> Self {
+        match format {
+            PcmFormat::ImaAdpcm => PcmFormats::IMA_ADPCM,
+            PcmFormat::MuLaw => PcmFormats::MU_LAW,
+            PcmFormat::ALaw => PcmFormats::A_LAW,
+            PcmFormat::S8 => PcmFormats::S8,
+            PcmFormat::U8 => PcmFormats::U8,
+            PcmFormat::S16 => PcmFormats::S16,
+            PcmFormat::U16 => PcmFormats::U16,
+            PcmFormat::S18_3 => PcmFormats::S18_3,
+            PcmFormat::U18_3 => PcmFormats::U18_3,
+            PcmFormat::S20_3 => PcmFormats::S20_3,
+            PcmFormat::U20_3 => PcmFormats::U20_3,
+            PcmFormat::S24_3 => PcmFormats::S24_3,
+            PcmFormat::U24_3 => PcmFormats::U24_3,
+            PcmFormat::S20 => PcmFormats::S20,
+            PcmFormat::U20 => PcmFormats::U20,
+            PcmFormat::S24 => PcmFormats::S24,
+            PcmFormat::U24 => PcmFormats::U24,
+            PcmFormat::S32 => PcmFormats::S32,
+            PcmFormat::U32 => PcmFormats::U32,
+            PcmFormat::FLOAT => PcmFormats::FLOAT,
+            PcmFormat::FLOAT64 => PcmFormats::FLOAT64,
+            PcmFormat::DsdU8 => PcmFormats::DSD_U8,
+            PcmFormat::DsdU16 => PcmFormats::DSD_U16,
+            PcmFormat::DsdU32 => PcmFormats::DSD_U32,
+            PcmFormat::Iec958Subframe => PcmFormats::IEC958_SUBFRAME,
+        }
+    }
+}
+
+impl From<PcmFormat> for u8 {
+    fn from(format: PcmFormat) -> u8 {
+        format as _
+    }
+}
+
+bitflags! {
+    /// Supported PCM frame rates.
+    #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+    #[repr(transparent)]
+    pub struct PcmRates: u64 {
+        /// 5512 Hz PCM rate.
+        const RATE_5512 = 1 << 0;
+        /// 8000 Hz PCM rate.
+        const RATE_8000 = 1 << 1;
+        /// 11025 Hz PCM rate.
+        const RATE_11025 = 1 << 2;
+        /// 16000 Hz PCM rate.
+        const RATE_16000 = 1 << 3;
+        /// 22050 Hz PCM rate.
+        const RATE_22050 = 1 << 4;
+        /// 32000 Hz PCM rate.
+        const RATE_32000 = 1 << 5;
+        /// 44100 Hz PCM rate.
+        const RATE_44100 = 1 << 6;
+        /// 48000 Hz PCM rate.
+        const RATE_48000 = 1 << 7;
+        /// 64000 Hz PCM rate.
+        const RATE_64000 = 1 << 8;
+        /// 88200 Hz PCM rate.
+        const RATE_88200 = 1 << 9;
+        /// 96000 Hz PCM rate.
+        const RATE_96000 = 1 << 10;
+        /// 176400 Hz PCM rate.
+        const RATE_176400 = 1 << 11;
+        /// 192000 Hz PCM rate.
+        const RATE_192000 = 1 << 12;
+        /// 384000 Hz PCM rate.
+        const RATE_384000 = 1 << 13;
+    }
+}
+
+/// A PCM frame rate.
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+#[repr(u8)]
+pub enum PcmRate {
+    /// 5512 Hz PCM rate.
+    #[default]
+    Rate5512 = 0,
+    /// 8000 Hz PCM rate.
+    Rate8000 = 1,
+    /// 11025 Hz PCM rate.
+    Rate11025 = 2,
+    /// 16000 Hz PCM rate.
+    Rate16000 = 3,
+    /// 22050 Hz PCM rate.
+    Rate22050 = 4,
+    /// 32000 Hz PCM rate.
+    Rate32000 = 5,
+    /// 44100 Hz PCM rate.
+    Rate44100 = 6,
+    /// 48000 Hz PCM rate.
+    Rate48000 = 7,
+    /// 64000 Hz PCM rate.
+    Rate64000 = 8,
+    /// 88200 Hz PCM rate.
+    Rate88200 = 9,
+    /// 96000 Hz PCM rate.
+    Rate96000 = 10,
+    /// 176400 Hz PCM rate.
+    Rate176400 = 11,
+    /// 192000 Hz PCM rate.
+    Rate192000 = 12,
+    /// 384000 Hz PCM rate.
+    Rate384000 = 13,
+}
+
+impl From<PcmRate> for PcmRates {
+    fn from(rate: PcmRate) -> Self {
+        match rate {
+            PcmRate::Rate5512 => Self::RATE_5512,
+            PcmRate::Rate8000 => Self::RATE_8000,
+            PcmRate::Rate11025 => Self::RATE_11025,
+            PcmRate::Rate16000 => Self::RATE_16000,
+            PcmRate::Rate22050 => Self::RATE_22050,
+            PcmRate::Rate32000 => Self::RATE_32000,
+            PcmRate::Rate44100 => Self::RATE_44100,
+            PcmRate::Rate48000 => Self::RATE_48000,
+            PcmRate::Rate64000 => Self::RATE_64000,
+            PcmRate::Rate88200 => Self::RATE_88200,
+            PcmRate::Rate96000 => Self::RATE_96000,
+            PcmRate::Rate176400 => Self::RATE_176400,
+            PcmRate::Rate192000 => Self::RATE_192000,
+            PcmRate::Rate384000 => Self::RATE_384000,
+        }
+    }
+}
+
+impl From<PcmRate> for u8 {
+    fn from(rate: PcmRate) -> Self {
+        rate as _
+    }
+}
+
+#[repr(C)]
+struct VirtIOSoundConfig {
+    jacks: ReadOnly<u32>,
+    streams: ReadOnly<u32>,
+    chmaps: ReadOnly<u32>,
+}
+
+/// In virtIO v1.2, this enum should be called "Code".
+///
+/// To avoid ambiguity in its meaning, I use the term "CommandCode" here.
+#[repr(u32)]
+#[derive(Copy, Clone, Debug, Eq, N, PartialEq)]
+enum CommandCode {
+    /* jack control request types */
+    RJackInfo = 1,
+    RJackRemap,
+
+    /* PCM control request types */
+    RPcmInfo = 0x0100,
+    RPcmSetParams,
+    RPcmPrepare,
+    RPcmRelease,
+    RPcmStart,
+    RPcmStop,
+
+    /* channel map control request types */
+    RChmapInfo = 0x0200,
+
+    /* jack event types */
+    EvtJackConnected = 0x1000,
+    EvtJackDisconnected,
+
+    /* PCM event types */
+    EvtPcmPeriodElapsed = 0x1100,
+    EvtPcmXrun,
+
+    /* common status codes */
+    /// success
+    SOk = 0x8000,
+    /// a control message is malformed or contains invalid parameters
+    SBadMsg,
+    /// requested operation or parameters are not supported
+    SNotSupp,
+    ///  an I/O error occurred
+    SIoErr,
+}
+
+impl From<CommandCode> for u32 {
+    fn from(code: CommandCode) -> u32 {
+        code as u32
+    }
+}
+
+/// Enum representing the types of item information requests.
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ItemInformationRequestType {
+    /// Represents a jack information request.
+    RJackInfo = 1,
+    /// Represents a PCM information request.
+    RPcmInfo = 0x0100,
+    /// Represents a channel map information request.
+    RChmapInfo = 0x0200,
+}
+
+impl From<ItemInformationRequestType> for VirtIOSndHdr {
+    fn from(value: ItemInformationRequestType) -> Self {
+        VirtIOSndHdr {
+            command_code: value.into(),
+        }
+    }
+}
+
+impl From<ItemInformationRequestType> for u32 {
+    fn from(request_type: ItemInformationRequestType) -> u32 {
+        request_type as _
+    }
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+#[repr(u32)]
+enum RequestStatusCode {
+    /* common status codes */
+    Ok = 0x8000,
+    BadMsg,
+    NotSupp,
+    IoErr,
+}
+
+impl From<RequestStatusCode> for VirtIOSndHdr {
+    fn from(value: RequestStatusCode) -> Self {
+        VirtIOSndHdr {
+            command_code: value as _,
+        }
+    }
+}
+
+/// A common header
+#[repr(C)]
+#[derive(AsBytes, Clone, Debug, Eq, FromBytes, FromZeroes, PartialEq)]
+struct VirtIOSndHdr {
+    command_code: u32,
+}
+
+impl From<CommandCode> for VirtIOSndHdr {
+    fn from(value: CommandCode) -> Self {
+        VirtIOSndHdr {
+            command_code: value.into(),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(FromBytes, FromZeroes)]
+/// An event notification
+struct VirtIOSndEvent {
+    hdr: VirtIOSndHdr,
+    data: u32,
+}
+
+/// The notification type.
+#[repr(u32)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum NotificationType {
+    /// An external device has been connected to the jack.
+    JackConnected = 0x1000,
+    /// An external device has been disconnected from the jack.
+    JackDisconnected,
+    /// A hardware buffer period has elapsed, the period size is controlled using the `period_bytes` field.
+    PcmPeriodElapsed = 0x1100,
+    /// An underflow for the output stream or an overflow for the inputstream has occurred.
+    PcmXrun,
+}
+
+impl NotificationType {
+    /// Converts the given value to a variant of this enum, if any matches.
+    fn n(value: u32) -> Option<Self> {
+        match value {
+            0x1100 => Some(Self::PcmPeriodElapsed),
+            0x1101 => Some(Self::PcmXrun),
+            0x1000 => Some(Self::JackConnected),
+            0x1001 => Some(Self::JackDisconnected),
+            _ => None,
+        }
+    }
+}
+
+/// Notification from sound device.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Notification {
+    notification_type: NotificationType,
+    data: u32,
+}
+
+impl Notification {
+    /// Get the resource index.
+    pub fn data(&self) -> u32 {
+        self.data
+    }
+
+    /// Get the notification type.
+    pub fn notification_type(&self) -> NotificationType {
+        self.notification_type
+    }
+}
+
+const VIRTIO_SND_D_OUTPUT: u8 = 0;
+const VIRTIO_SND_D_INPUT: u8 = 1;
+
+#[repr(C)]
+#[derive(AsBytes, Debug, FromBytes, FromZeroes)]
+struct VirtIOSndQueryInfo {
+    /// specifies a particular item request type (VIRTIO_SND_R_*_INFO)
+    hdr: VirtIOSndHdr,
+    /// specifies the starting identifier for the item
+    /// (the range of available identifiers is limited
+    ///  by the total number of particular items
+    ///  that is indicated in the device configuration space)
+    start_id: u32,
+    /// specifies the number of items for which information is requested
+    ///  (the total number of particular items is indicated
+    ///  in the device configuration space).
+    count: u32,
+    /// specifies the size of the structure containing information for one item
+    /// (used for backward compatibility)
+    size: u32,
+}
+
+#[repr(C)]
+#[derive(AsBytes, Debug, FromBytes, FromZeroes)]
+struct VirtIOSndQueryInfoRsp {
+    hdr: VirtIOSndHdr,
+    info: VirtIOSndInfo,
+}
+
+/// Field `hda_fn_nid` indicates a function group node identifier.
+#[repr(C)]
+#[derive(AsBytes, Clone, Debug, Eq, FromBytes, FromZeroes, PartialEq)]
+pub struct VirtIOSndInfo {
+    hda_fn_nid: u32,
+}
+
+#[repr(C)]
+#[derive(AsBytes, Clone, Debug, FromBytes, FromZeroes)]
+struct VirtIOSndJackHdr {
+    hdr: VirtIOSndHdr,
+    /// specifies a jack identifier from 0 to jacks - 1
+    jack_id: u32,
+}
+
+/// Jack infomation.
+#[repr(C)]
+#[derive(AsBytes, Clone, Eq, FromBytes, FromZeroes, PartialEq)]
+pub struct VirtIOSndJackInfo {
+    hdr: VirtIOSndInfo,
+    features: u32,
+    /// indicates a pin default configuration value
+    hda_reg_defconf: u32,
+    /// indicates a pin capabilities value
+    hda_reg_caps: u32,
+    /// indicates the current jack connection status (1 - connected, 0 - disconnected)
+    connected: u8,
+
+    _padding: [u8; 7],
+}
+
+impl Debug for VirtIOSndJackInfo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.debug_struct("VirtIOSndJackInfo")
+            .field("hdr", &self.hdr)
+            .field("features", &JackFeatures::from_bits_retain(self.features))
+            .field("hda_reg_defconf", &self.hda_reg_defconf)
+            .field("hda_reg_caps", &self.hda_reg_caps)
+            .field("connected", &self.connected)
+            .field("_padding", &self._padding)
+            .finish()
+    }
+}
+
+impl Display for VirtIOSndJackInfo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let connected_status = if self.connected == 1 {
+            "CONNECTED"
+        } else {
+            "DISCONNECTED"
+        };
+        write!(
+            f,
+            "features: {:?}, hda_reg_defconf: {}, hda_reg_caps: {}, connected: {}",
+            JackFeatures::from_bits_retain(self.features),
+            self.hda_reg_defconf,
+            self.hda_reg_caps,
+            connected_status
+        )
+    }
+}
+
+#[repr(C)]
+#[derive(AsBytes, FromBytes, FromZeroes)]
+struct VirtIOSndJackInfoRsp {
+    hdr: VirtIOSndHdr,
+    body: VirtIOSndJackInfo,
+}
+
+#[repr(C)]
+#[derive(AsBytes, FromBytes, FromZeroes)]
+struct VirtIOSndJackRemap {
+    hdr: VirtIOSndJackHdr,
+    association: u32,
+    sequence: u32,
+}
+
+#[repr(C)]
+#[derive(AsBytes, Debug, Eq, FromBytes, FromZeroes, PartialEq)]
+struct VirtIOSndPcmHdr {
+    /// specifies request type (VIRTIO_SND_R_PCM_*)
+    hdr: VirtIOSndHdr,
+    /// specifies a PCM stream identifier from 0 to streams - 1
+    stream_id: u32,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+enum PcmStreamFeatures {
+    ShmemHost = 0,
+    ShmemGuest,
+    MsgPolling,
+    EvtShmemPeriods,
+    EvtXruns,
+}
+
+impl From<PcmStreamFeatures> for u32 {
+    fn from(value: PcmStreamFeatures) -> Self {
+        value as _
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[repr(u64)]
+enum PcmSampleFormat {
+    /* analog formats (width / physical width) */
+    ImaAdpcm = 0, /* 4 / 4 bits */
+    MuLaw,        /* 8 / 8 bits */
+    ALaw,         /* 8 / 8 bits */
+    S8,           /* 8 / 8 bits */
+    U8,           /* 8 / 8 bits */
+    S16,          /* 16 / 16 bits */
+    U16,          /* 16 / 16 bits */
+    S18_3,        /* 18 / 24 bits */
+    U18_3,        /* 18 / 24 bits */
+    S20_3,        /* 20 / 24 bits */
+    U20_3,        /* 20 / 24 bits */
+    S24_3,        /* 24 / 24 bits */
+    U24_3,        /* 24 / 24 bits */
+    S20,          /* 20 / 32 bits */
+    U20,          /* 20 / 32 bits */
+    S24,          /* 24 / 32 bits */
+    U24,          /* 24 / 32 bits */
+    S32,          /* 32 / 32 bits */
+    U32,          /* 32 / 32 bits */
+    Float,        /* 32 / 32 bits */
+    Float64,      /* 64 / 64 bits */
+    /* digital formats (width / physical width) */
+    DsdU8,          /* 8 / 8 bits */
+    DsdU16,         /* 16 / 16 bits */
+    DsdU32,         /* 32 / 32 bits */
+    Iec958Subframe, /* 32 / 32 bits */
+}
+
+impl From<PcmSampleFormat> for u64 {
+    fn from(value: PcmSampleFormat) -> Self {
+        value as _
+    }
+}
+
+/// PCM information.
+#[repr(C)]
+#[derive(AsBytes, Clone, Eq, FromBytes, FromZeroes, PartialEq)]
+pub struct VirtIOSndPcmInfo {
+    hdr: VirtIOSndInfo,
+    features: u32, /* 1 << VIRTIO_SND_PCM_F_XXX */
+    formats: u64,  /* 1 << VIRTIO_SND_PCM_FMT_XXX */
+    rates: u64,    /* 1 << VIRTIO_SND_PCM_RATE_XXX */
+    /// indicates the direction of data flow (VIRTIO_SND_D_*)
+    direction: u8,
+    /// indicates a minimum number of supported channels
+    channels_min: u8,
+    /// indicates a maximum number of supported channels
+    channels_max: u8,
+    _padding: [u8; 5],
+}
+
+impl Debug for VirtIOSndPcmInfo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.debug_struct("VirtIOSndPcmInfo")
+            .field("hdr", &self.hdr)
+            .field("features", &PcmFeatures::from_bits_retain(self.features))
+            .field("formats", &PcmFormats::from_bits_retain(self.formats))
+            .field("rates", &PcmRates::from_bits_retain(self.rates))
+            .field("direction", &self.direction)
+            .field("channels_min", &self.channels_min)
+            .field("channels_max", &self.channels_max)
+            .field("_padding", &self._padding)
+            .finish()
+    }
+}
+
+impl Display for VirtIOSndPcmInfo {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let direction = if self.direction == VIRTIO_SND_D_INPUT {
+            "INPUT"
+        } else {
+            "OUTPUT"
+        };
+        write!(
+            f,
+            "features: {:?}, rates: {:?}, formats: {:?}, direction: {}",
+            PcmFeatures::from_bits_retain(self.features),
+            PcmRates::from_bits_retain(self.rates),
+            PcmFormats::from_bits_retain(self.formats),
+            direction
+        )
+    }
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+struct PcmParameters {
+    setup: bool,
+    buffer_bytes: u32,
+    period_bytes: u32,
+    features: PcmFeatures,
+    channels: u8,
+    format: PcmFormat,
+    rate: PcmRate,
+}
+
+#[repr(C)]
+#[derive(AsBytes, Debug, Eq, FromBytes, FromZeroes, PartialEq)]
+struct VirtIOSndPcmSetParams {
+    hdr: VirtIOSndPcmHdr, /* .code = VIRTIO_SND_R_PCM_SET_PARAMS */
+    buffer_bytes: u32,
+    period_bytes: u32,
+    features: u32, /* 1 << VIRTIO_SND_PCM_F_XXX */
+    channels: u8,
+    format: u8,
+    rate: u8,
+
+    _padding: u8,
+}
+
+/// An I/O header
+#[repr(C)]
+#[derive(AsBytes, FromBytes, FromZeroes)]
+struct VirtIOSndPcmXfer {
+    stream_id: u32,
+}
+
+/// An I/O status
+#[repr(C)]
+#[derive(AsBytes, Default, FromBytes, FromZeroes)]
+struct VirtIOSndPcmStatus {
+    status: u32,
+    latency_bytes: u32,
+}
+
+#[derive(Copy, Clone, Debug, Eq, N, PartialEq)]
+#[repr(u8)]
+enum ChannelPosition {
+    /// undefined
+    None = 0,
+    /// silent
+    Na,
+    /// mono stream
+    Mono,
+    /// front left
+    Fl,
+    /// front right
+    Fr,
+    /// rear left
+    Rl,
+    /// rear right
+    Rr,
+    /// front center
+    Fc,
+    /// low frequency (LFE)
+    Lfe,
+    /// side left
+    Sl,
+    /// side right
+    Sr,
+    /// rear center
+    Rc,
+    /// front left center
+    Flc,
+    /// front right center
+    Frc,
+    /// rear left center
+    Rlc,
+    /// rear right center
+    Rrc,
+    /// front left wide
+    Flw,
+    /// front right wide
+    Frw,
+    /// front left high
+    Flh,
+    /// front center high
+    Fch,
+    /// front right high
+    Frh,
+    /// top center
+    Tc,
+    /// top front left
+    Tfl,
+    /// top front right
+    Tfr,
+    /// top front center
+    Tfc,
+    /// top rear left
+    Trl,
+    /// top rear right
+    Trr,
+    /// top rear center
+    Trc,
+    /// top front left center
+    Tflc,
+    /// top front right center
+    Tfrc,
+    /// top side left
+    Tsl,
+    /// top side right
+    Tsr,
+    /// left LFE
+    Llfe,
+    /// right LFE
+    Rlfe,
+    /// bottom center
+    Bc,
+    /// bottom left center
+    Blc,
+    /// bottom right center
+    Brc,
+}
+
+/// maximum possible number of channels
+const VIRTIO_SND_CHMAP_MAX_SIZE: usize = 18;
+
+#[repr(C)]
+#[derive(AsBytes, Clone, Debug, FromBytes, FromZeroes)]
+struct VirtIOSndChmapInfo {
+    hdr: VirtIOSndInfo,
+    direction: u8,
+    channels: u8,
+    positions: [u8; VIRTIO_SND_CHMAP_MAX_SIZE],
+}
+
+impl Display for VirtIOSndChmapInfo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let direction = if self.direction == VIRTIO_SND_D_INPUT {
+            "INPUT"
+        } else {
+            "OUTPUT"
+        };
+        write!(
+            f,
+            "direction: {}, channels: {}, postions: [",
+            direction, self.channels
+        )?;
+        for i in 0..usize::from(self.channels) {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            if let Some(position) = ChannelPosition::n(self.positions[i]) {
+                write!(f, "{:?}", position)?;
+            } else {
+                write!(f, "{}", self.positions[i])?;
+            }
+        }
+        write!(f, "]")?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        hal::fake::FakeHal,
+        transport::{
+            fake::{FakeTransport, QueueStatus, State},
+            DeviceType,
+        },
+        volatile::ReadOnly,
+    };
+    use alloc::{sync::Arc, vec};
+    use core::ptr::NonNull;
+    use fake::FakeSoundDevice;
+    use std::sync::Mutex;
+
+    #[test]
+    fn config() {
+        let mut config_space = VirtIOSoundConfig {
+            jacks: ReadOnly::new(3),
+            streams: ReadOnly::new(4),
+            chmaps: ReadOnly::new(2),
+        };
+        let state = Arc::new(Mutex::new(State {
+            queues: vec![
+                QueueStatus::default(),
+                QueueStatus::default(),
+                QueueStatus::default(),
+                QueueStatus::default(),
+            ],
+            ..Default::default()
+        }));
+        let transport = FakeTransport {
+            device_type: DeviceType::Sound,
+            max_queue_size: 32,
+            device_features: 0,
+            config_space: NonNull::from(&mut config_space),
+            state: state.clone(),
+        };
+        let sound =
+            VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap();
+        assert_eq!(sound.jacks(), 3);
+        assert_eq!(sound.streams(), 4);
+        assert_eq!(sound.chmaps(), 2);
+    }
+
+    #[test]
+    fn empty_info() {
+        let (fake, transport) = FakeSoundDevice::new(vec![], vec![], vec![]);
+        let mut sound =
+            VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap();
+        let handle = fake.spawn();
+
+        assert_eq!(sound.jacks(), 0);
+        assert_eq!(sound.streams(), 0);
+        assert_eq!(sound.chmaps(), 0);
+        assert_eq!(sound.output_streams().unwrap(), vec![]);
+        assert_eq!(sound.input_streams().unwrap(), vec![]);
+
+        fake.terminate();
+        handle.join().unwrap();
+    }
+
+    #[test]
+    fn stream_info() {
+        let (fake, transport) = FakeSoundDevice::new(
+            vec![VirtIOSndJackInfo {
+                hdr: VirtIOSndInfo { hda_fn_nid: 0 },
+                features: 0,
+                hda_reg_defconf: 0,
+                hda_reg_caps: 0,
+                connected: 0,
+                _padding: Default::default(),
+            }],
+            vec![
+                VirtIOSndPcmInfo {
+                    hdr: VirtIOSndInfo { hda_fn_nid: 0 },
+                    features: 0,
+                    formats: (PcmFormats::U8 | PcmFormats::U32).bits(),
+                    rates: (PcmRates::RATE_44100 | PcmRates::RATE_32000).bits(),
+                    direction: VIRTIO_SND_D_OUTPUT,
+                    channels_min: 1,
+                    channels_max: 2,
+                    _padding: Default::default(),
+                },
+                VirtIOSndPcmInfo {
+                    hdr: VirtIOSndInfo { hda_fn_nid: 0 },
+                    features: 0,
+                    formats: 0,
+                    rates: 0,
+                    direction: VIRTIO_SND_D_INPUT,
+                    channels_min: 0,
+                    channels_max: 0,
+                    _padding: Default::default(),
+                },
+            ],
+            vec![VirtIOSndChmapInfo {
+                hdr: VirtIOSndInfo { hda_fn_nid: 0 },
+                direction: 0,
+                channels: 0,
+                positions: [0; 18],
+            }],
+        );
+        let mut sound =
+            VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap();
+        let handle = fake.spawn();
+
+        assert_eq!(sound.output_streams().unwrap(), vec![0]);
+        assert_eq!(
+            sound.rates_supported(0).unwrap(),
+            PcmRates::RATE_44100 | PcmRates::RATE_32000
+        );
+        assert_eq!(
+            sound.formats_supported(0).unwrap(),
+            PcmFormats::U8 | PcmFormats::U32
+        );
+        assert_eq!(sound.channel_range_supported(0).unwrap(), 1..=2);
+        assert_eq!(sound.features_supported(0).unwrap(), PcmFeatures::empty());
+
+        assert_eq!(sound.input_streams().unwrap(), vec![1]);
+        assert_eq!(sound.rates_supported(1).unwrap(), PcmRates::empty());
+        assert_eq!(sound.formats_supported(1).unwrap(), PcmFormats::empty());
+        assert_eq!(sound.channel_range_supported(1).unwrap(), 0..=0);
+        assert_eq!(sound.features_supported(1).unwrap(), PcmFeatures::empty());
+
+        fake.terminate();
+        handle.join().unwrap();
+    }
+
+    #[test]
+    fn play() {
+        let (fake, transport) = FakeSoundDevice::new(
+            vec![],
+            vec![VirtIOSndPcmInfo {
+                hdr: VirtIOSndInfo { hda_fn_nid: 0 },
+                features: 0,
+                formats: (PcmFormats::U8 | PcmFormats::U32).bits(),
+                rates: (PcmRates::RATE_44100 | PcmRates::RATE_32000).bits(),
+                direction: VIRTIO_SND_D_OUTPUT,
+                channels_min: 1,
+                channels_max: 2,
+                _padding: Default::default(),
+            }],
+            vec![],
+        );
+        let mut sound =
+            VirtIOSound::<FakeHal, FakeTransport<VirtIOSoundConfig>>::new(transport).unwrap();
+        let handle = fake.spawn();
+
+        assert_eq!(sound.output_streams().unwrap(), vec![0]);
+        assert_eq!(sound.input_streams().unwrap(), vec![]);
+
+        sound
+            .pcm_set_params(
+                0,
+                100,
+                100,
+                PcmFeatures::empty(),
+                1,
+                PcmFormat::U8,
+                PcmRate::Rate8000,
+            )
+            .unwrap();
+        assert_eq!(
+            fake.params.lock().unwrap()[0],
+            Some(VirtIOSndPcmSetParams {
+                hdr: VirtIOSndPcmHdr {
+                    hdr: VirtIOSndHdr {
+                        command_code: CommandCode::RPcmSetParams.into(),
+                    },
+                    stream_id: 0,
+                },
+                buffer_bytes: 100,
+                period_bytes: 100,
+                features: 0,
+                channels: 1,
+                format: PcmFormat::U8.into(),
+                rate: PcmRate::Rate8000.into(),
+                _padding: Default::default(),
+            })
+        );
+
+        sound.pcm_prepare(0).unwrap();
+        sound.pcm_start(0).unwrap();
+
+        let mut expected_sound = vec![];
+
+        // Playing an empty set of frames should be a no-op.
+        println!("Playing empty");
+        sound.pcm_xfer(0, &[]).unwrap();
+        assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound);
+
+        // Send one buffer worth.
+        println!("Playing 100");
+        sound.pcm_xfer(0, &[42; 100]).unwrap();
+        expected_sound.extend([42; 100]);
+        assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound);
+
+        // Send two buffers worth.
+        println!("Playing 200");
+        sound.pcm_xfer(0, &[66; 200]).unwrap();
+        expected_sound.extend([66; 200]);
+        assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound);
+
+        // Send half a buffer worth.
+        println!("Playing 50");
+        sound.pcm_xfer(0, &[55; 50]).unwrap();
+        expected_sound.extend([55; 50]);
+        assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound);
+
+        // Send enough that the queue will fill up.
+        println!("Playing 5000");
+        sound.pcm_xfer(0, &[12; 5000]).unwrap();
+        expected_sound.extend([12; 5000]);
+        assert_eq!(fake.played_bytes.lock().unwrap()[0], expected_sound);
+
+        sound.pcm_stop(0).unwrap();
+        sound.pcm_release(0).unwrap();
+
+        fake.terminate();
+        handle.join().unwrap();
+    }
+}
diff --git a/crates/virtio-drivers/src/device/sound/fake.rs b/crates/virtio-drivers/src/device/sound/fake.rs
new file mode 100644
index 0000000..b4bfb8c
--- /dev/null
+++ b/crates/virtio-drivers/src/device/sound/fake.rs
@@ -0,0 +1,244 @@
+//! Fake VirtIO sound device for tests.
+
+use super::{
+    CommandCode, VirtIOSndChmapInfo, VirtIOSndHdr, VirtIOSndJackInfo, VirtIOSndPcmInfo,
+    VirtIOSndPcmStatus, VirtIOSndPcmXfer, VirtIOSndQueryInfo, VirtIOSoundConfig, CONTROL_QUEUE_IDX,
+    QUEUE_SIZE, TX_QUEUE_IDX,
+};
+use crate::{
+    device::sound::{VirtIOSndPcmHdr, VirtIOSndPcmSetParams},
+    transport::{
+        fake::{FakeTransport, QueueStatus, State},
+        DeviceType,
+    },
+    volatile::ReadOnly,
+};
+use alloc::{sync::Arc, vec};
+use core::{
+    convert::{TryFrom, TryInto},
+    mem::size_of,
+    ptr::NonNull,
+    time::Duration,
+};
+use std::{
+    iter::repeat_with,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Mutex,
+    },
+    thread::{self, JoinHandle},
+};
+use zerocopy::{AsBytes, FromBytes};
+
+#[derive(Clone, Debug)]
+pub struct FakeSoundDevice {
+    pub state: Arc<Mutex<State>>,
+    pub terminate: Arc<AtomicBool>,
+    /// The paramaters set for each stream, if any.
+    pub params: Arc<Mutex<Vec<Option<VirtIOSndPcmSetParams>>>>,
+    /// The bytes send on the TX queue for each channel.
+    pub played_bytes: Arc<Mutex<Vec<Vec<u8>>>>,
+    pub jack_infos: Vec<VirtIOSndJackInfo>,
+    pub pcm_infos: Vec<VirtIOSndPcmInfo>,
+    pub chmap_infos: Vec<VirtIOSndChmapInfo>,
+}
+
+impl FakeSoundDevice {
+    pub fn new(
+        jack_infos: Vec<VirtIOSndJackInfo>,
+        pcm_infos: Vec<VirtIOSndPcmInfo>,
+        chmap_infos: Vec<VirtIOSndChmapInfo>,
+    ) -> (Self, FakeTransport<VirtIOSoundConfig>) {
+        let mut config_space = VirtIOSoundConfig {
+            jacks: ReadOnly::new(jack_infos.len().try_into().unwrap()),
+            streams: ReadOnly::new(pcm_infos.len().try_into().unwrap()),
+            chmaps: ReadOnly::new(chmap_infos.len().try_into().unwrap()),
+        };
+        let state = Arc::new(Mutex::new(State {
+            queues: vec![
+                QueueStatus::default(),
+                QueueStatus::default(),
+                QueueStatus::default(),
+                QueueStatus::default(),
+            ],
+            ..Default::default()
+        }));
+        let transport = FakeTransport {
+            device_type: DeviceType::Socket,
+            max_queue_size: 32,
+            device_features: 0,
+            config_space: NonNull::from(&mut config_space),
+            state: state.clone(),
+        };
+        let params = repeat_with(|| None).take(pcm_infos.len()).collect();
+        let played_bytes = vec![vec![]; pcm_infos.len()];
+
+        (
+            Self {
+                state,
+                terminate: Arc::new(AtomicBool::new(false)),
+                params: Arc::new(Mutex::new(params)),
+                played_bytes: Arc::new(Mutex::new(played_bytes)),
+                jack_infos,
+                pcm_infos,
+                chmap_infos,
+            },
+            transport,
+        )
+    }
+
+    /// Start a background thread simulating the device.
+    pub fn spawn(&self) -> JoinHandle<()> {
+        let clone = self.clone();
+        thread::spawn(move || clone.run())
+    }
+
+    /// Terminate the background thread for the device.
+    pub fn terminate(&self) {
+        self.terminate.store(true, Ordering::Release);
+    }
+
+    fn run(&self) {
+        while !self.terminate.load(Ordering::Acquire) {
+            if State::poll_queue_notified(&self.state, CONTROL_QUEUE_IDX) {
+                println!("Control queue was notified.");
+
+                while self
+                    .state
+                    .lock()
+                    .unwrap()
+                    .read_write_queue::<{ QUEUE_SIZE as usize }>(CONTROL_QUEUE_IDX, |request| {
+                        self.handle_control_request(&request)
+                    })
+                {}
+            } else if State::poll_queue_notified(&self.state, TX_QUEUE_IDX) {
+                println!("TX queue was notified");
+                while self
+                    .state
+                    .lock()
+                    .unwrap()
+                    .read_write_queue::<{ QUEUE_SIZE as usize }>(TX_QUEUE_IDX, |request| {
+                        self.handle_tx(&request)
+                    })
+                {}
+            } else {
+                thread::sleep(Duration::from_millis(10));
+            }
+        }
+    }
+
+    fn handle_tx(&self, request: &[u8]) -> Vec<u8> {
+        let header = VirtIOSndPcmXfer::read_from_prefix(&request).expect("TX request too short");
+        self.played_bytes.lock().unwrap()[usize::try_from(header.stream_id).unwrap()]
+            .extend(&request[size_of::<VirtIOSndPcmXfer>()..]);
+
+        VirtIOSndPcmStatus {
+            status: CommandCode::SOk.into(),
+            latency_bytes: 0,
+        }
+        .as_bytes()
+        .to_owned()
+    }
+
+    fn handle_control_request(&self, request: &[u8]) -> Vec<u8> {
+        {
+            let header =
+                VirtIOSndHdr::read_from_prefix(&request).expect("Control request too short");
+            let mut response = Vec::new();
+            const R_JACK_INFO: u32 = CommandCode::RJackInfo as u32;
+            const R_PCM_INFO: u32 = CommandCode::RPcmInfo as u32;
+            const R_CHMAP_INFO: u32 = CommandCode::RChmapInfo as u32;
+            const R_PCM_SET_PARAMS: u32 = CommandCode::RPcmSetParams as u32;
+            const R_PCM_PREPARE: u32 = CommandCode::RPcmPrepare as u32;
+            const R_PCM_START: u32 = CommandCode::RPcmStart as u32;
+            const R_PCM_STOP: u32 = CommandCode::RPcmStop as u32;
+            const R_PCM_RELEASE: u32 = CommandCode::RPcmRelease as u32;
+            match header.command_code {
+                R_JACK_INFO => {
+                    let request = VirtIOSndQueryInfo::read_from(&request)
+                        .expect("R_JACK_INFO control request wrong length");
+                    assert_eq!(
+                        request.size,
+                        u32::try_from(size_of::<VirtIOSndJackInfo>()).unwrap()
+                    );
+                    response.extend_from_slice(
+                        VirtIOSndHdr {
+                            command_code: CommandCode::SOk.into(),
+                        }
+                        .as_bytes(),
+                    );
+                    for jack_info in &self.jack_infos[request.start_id as usize
+                        ..request.start_id as usize + request.count as usize]
+                    {
+                        response.extend_from_slice(jack_info.as_bytes());
+                    }
+                }
+                R_PCM_INFO => {
+                    let request = VirtIOSndQueryInfo::read_from(&request)
+                        .expect("R_PCM_INFO control request wrong length");
+                    assert_eq!(
+                        request.size,
+                        u32::try_from(size_of::<VirtIOSndPcmInfo>()).unwrap()
+                    );
+                    response.extend_from_slice(
+                        VirtIOSndHdr {
+                            command_code: CommandCode::SOk.into(),
+                        }
+                        .as_bytes(),
+                    );
+                    for pcm_info in &self.pcm_infos[request.start_id as usize
+                        ..request.start_id as usize + request.count as usize]
+                    {
+                        response.extend_from_slice(pcm_info.as_bytes());
+                    }
+                }
+                R_CHMAP_INFO => {
+                    let request = VirtIOSndQueryInfo::read_from(&request)
+                        .expect("R_CHMAP_INFO control request wrong length");
+                    assert_eq!(
+                        request.size,
+                        u32::try_from(size_of::<VirtIOSndChmapInfo>()).unwrap()
+                    );
+                    response.extend_from_slice(
+                        VirtIOSndHdr {
+                            command_code: CommandCode::SOk.into(),
+                        }
+                        .as_bytes(),
+                    );
+                    for chmap_info in &self.chmap_infos[request.start_id as usize
+                        ..request.start_id as usize + request.count as usize]
+                    {
+                        response.extend_from_slice(chmap_info.as_bytes());
+                    }
+                }
+                R_PCM_SET_PARAMS => {
+                    let request = VirtIOSndPcmSetParams::read_from(&request)
+                        .expect("R_PCM_SET_PARAMS request wrong length");
+                    let stream_id = request.hdr.stream_id;
+                    self.params.lock().unwrap()[usize::try_from(stream_id).unwrap()] =
+                        Some(request);
+                    response.extend_from_slice(
+                        VirtIOSndHdr {
+                            command_code: CommandCode::SOk.into(),
+                        }
+                        .as_bytes(),
+                    );
+                }
+                R_PCM_PREPARE | R_PCM_START | R_PCM_STOP | R_PCM_RELEASE => {
+                    let _request =
+                        VirtIOSndPcmHdr::read_from(&request).expect("Request wrong length");
+                    response.extend_from_slice(
+                        VirtIOSndHdr {
+                            command_code: CommandCode::SOk.into(),
+                        }
+                        .as_bytes(),
+                    );
+                }
+                _ => {
+                    panic!("Unexpected control request, header {:?}", header);
+                }
+            }
+            response
+        }
+    }
+}
diff --git a/crates/virtio-drivers/src/queue.rs b/crates/virtio-drivers/src/queue.rs
index 3573a39..ed7c856 100644
--- a/crates/virtio-drivers/src/queue.rs
+++ b/crates/virtio-drivers/src/queue.rs
@@ -1,5 +1,8 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
+#[cfg(feature = "alloc")]
+pub mod owning;
+
 use crate::hal::{BufferDirection, Dma, Hal, PhysAddr};
 use crate::transport::Transport;
 use crate::{align_up, nonnull_slice_from_raw_parts, pages, Error, Result, PAGE_SIZE};
@@ -837,13 +840,16 @@
 /// Simulates the device reading from a VirtIO queue and writing a response back, for use in tests.
 ///
 /// The fake device always uses descriptors in order.
+///
+/// Returns true if a descriptor chain was available and processed, or false if no descriptors were
+/// available.
 #[cfg(test)]
 pub(crate) fn fake_read_write_queue<const QUEUE_SIZE: usize>(
     descriptors: *const [Descriptor; QUEUE_SIZE],
     queue_driver_area: *const u8,
     queue_device_area: *mut u8,
     handler: impl FnOnce(Vec<u8>) -> Vec<u8>,
-) {
+) -> bool {
     use core::{ops::Deref, slice};
 
     let available_ring = queue_driver_area as *const AvailRing<QUEUE_SIZE>;
@@ -853,10 +859,10 @@
     // nothing else accesses them during this block.
     unsafe {
         // Make sure there is actually at least one descriptor available to read from.
-        assert_ne!(
-            (*available_ring).idx.load(Ordering::Acquire),
-            (*used_ring).idx.load(Ordering::Acquire)
-        );
+        if (*available_ring).idx.load(Ordering::Acquire) == (*used_ring).idx.load(Ordering::Acquire)
+        {
+            return false;
+        }
         // The fake device always uses descriptors in order, like VIRTIO_F_IN_ORDER, so
         // `used_ring.idx` marks the next descriptor we should take from the available ring.
         let next_slot = (*used_ring).idx.load(Ordering::Acquire) & (QUEUE_SIZE as u16 - 1);
@@ -961,6 +967,8 @@
         (*used_ring).ring[next_slot as usize].id = head_descriptor_index.into();
         (*used_ring).ring[next_slot as usize].len = (input_length + output.len()) as u32;
         (*used_ring).idx.fetch_add(1, Ordering::AcqRel);
+
+        true
     }
 }
 
diff --git a/crates/virtio-drivers/src/queue/owning.rs b/crates/virtio-drivers/src/queue/owning.rs
new file mode 100644
index 0000000..9a0e17d
--- /dev/null
+++ b/crates/virtio-drivers/src/queue/owning.rs
@@ -0,0 +1,154 @@
+use super::VirtQueue;
+use crate::{transport::Transport, Error, Hal, Result};
+use alloc::boxed::Box;
+use core::convert::TryInto;
+use core::ptr::{null_mut, NonNull};
+use zerocopy::FromZeroes;
+
+/// A wrapper around [`Queue`] that owns all the buffers that are passed to the queue.
+#[derive(Debug)]
+pub struct OwningQueue<H: Hal, const SIZE: usize, const BUFFER_SIZE: usize> {
+    queue: VirtQueue<H, SIZE>,
+    buffers: [NonNull<[u8; BUFFER_SIZE]>; SIZE],
+}
+
+impl<H: Hal, const SIZE: usize, const BUFFER_SIZE: usize> OwningQueue<H, SIZE, BUFFER_SIZE> {
+    /// Constructs a new `OwningQueue` wrapping around the given `VirtQueue`.
+    ///
+    /// This will allocate `SIZE` buffers of `BUFFER_SIZE` bytes each and add them to the queue.
+    ///
+    /// The caller is responsible for notifying the device if `should_notify` returns true.
+    pub fn new(mut queue: VirtQueue<H, SIZE>) -> Result<Self> {
+        let mut buffers = [null_mut(); SIZE];
+        for (i, queue_buffer) in buffers.iter_mut().enumerate() {
+            let mut buffer: Box<[u8; BUFFER_SIZE]> = FromZeroes::new_box_zeroed();
+            // SAFETY: The buffer lives as long as the queue, as specified in the function safety
+            // requirement, and we don't access it until it is popped.
+            let token = unsafe { queue.add(&[], &mut [buffer.as_mut_slice()]) }?;
+            assert_eq!(i, token.into());
+            *queue_buffer = Box::into_raw(buffer);
+        }
+        let buffers = buffers.map(|ptr| NonNull::new(ptr).unwrap());
+
+        Ok(Self { queue, buffers })
+    }
+
+    /// Returns whether the driver should notify the device after adding a new buffer to the
+    /// virtqueue.
+    ///
+    /// This will be false if the device has supressed notifications.
+    pub fn should_notify(&self) -> bool {
+        self.queue.should_notify()
+    }
+
+    /// Tells the device whether to send used buffer notifications.
+    pub fn set_dev_notify(&mut self, enable: bool) {
+        self.queue.set_dev_notify(enable);
+    }
+
+    /// Adds the buffer at the given index in `buffers` back to the queue.
+    ///
+    /// Automatically notifies the device if required.
+    ///
+    /// # Safety
+    ///
+    /// The buffer must not currently be in the RX queue, and no other references to it must exist
+    /// between when this method is called and when it is popped from the queue.
+    unsafe fn add_buffer_to_queue(&mut self, index: u16, transport: &mut impl Transport) -> Result {
+        // SAFETY: The buffer lives as long as the queue, and the caller guarantees that it's not
+        // currently in the queue or referred to anywhere else until it is popped.
+        unsafe {
+            let buffer = self
+                .buffers
+                .get_mut(usize::from(index))
+                .ok_or(Error::WrongToken)?
+                .as_mut();
+            let new_token = self.queue.add(&[], &mut [buffer])?;
+            // If the RX buffer somehow gets assigned a different token, then our safety assumptions
+            // are broken and we can't safely continue to do anything with the device.
+            assert_eq!(new_token, index);
+        }
+
+        if self.queue.should_notify() {
+            transport.notify(self.queue.queue_idx);
+        }
+
+        Ok(())
+    }
+
+    fn pop(&mut self) -> Result<Option<(&[u8], u16)>> {
+        let Some(token) = self.queue.peek_used() else {
+            return Ok(None);
+        };
+
+        // SAFETY: The device has told us it has finished using the buffer, and there are no other
+        // references to it.
+        let buffer = unsafe { self.buffers[usize::from(token)].as_mut() };
+        // SAFETY: We maintain a consistent mapping of tokens to buffers, so we pass the same buffer
+        // to `pop_used` as we previously passed to `add` for the token. Once we add the buffer back
+        // to the RX queue then we don't access it again until next time it is popped.
+        let len = unsafe { self.queue.pop_used(token, &[], &mut [buffer])? }
+            .try_into()
+            .unwrap();
+
+        Ok(Some((&buffer[0..len], token)))
+    }
+
+    /// Checks whether there are any buffers which the device has marked as used so the driver
+    /// should now process. If so, passes the first one to the `handle` function and then adds it
+    /// back to the queue.
+    ///
+    /// Returns an error if there is an error accessing the queue or `handler` returns an error.
+    /// Returns `Ok(None)` if there are no pending buffers to handle, or if `handler` returns
+    /// `Ok(None)`.
+    ///
+    /// If `handler` panics then the buffer will not be added back to the queue, so this should be
+    /// avoided.
+    pub fn poll<T>(
+        &mut self,
+        transport: &mut impl Transport,
+        handler: impl FnOnce(&[u8]) -> Result<Option<T>>,
+    ) -> Result<Option<T>> {
+        let Some((buffer, token)) = self.pop()? else {
+            return Ok(None);
+        };
+
+        let result = handler(buffer);
+
+        // SAFETY: The buffer was just popped from the queue so it's not in it, and there won't be
+        // any other references until next time it's popped.
+        unsafe {
+            self.add_buffer_to_queue(token, transport)?;
+        }
+
+        result
+    }
+}
+
+// SAFETY: The `buffers` can be accessed from any thread.
+unsafe impl<H: Hal, const SIZE: usize, const BUFFER_SIZE: usize> Send
+    for OwningQueue<H, SIZE, BUFFER_SIZE>
+where
+    VirtQueue<H, SIZE>: Send,
+{
+}
+
+// SAFETY: An `&OwningQueue` only allows calling `should_notify`.
+unsafe impl<H: Hal, const SIZE: usize, const BUFFER_SIZE: usize> Sync
+    for OwningQueue<H, SIZE, BUFFER_SIZE>
+where
+    VirtQueue<H, SIZE>: Sync,
+{
+}
+
+impl<H: Hal, const SIZE: usize, const BUFFER_SIZE: usize> Drop
+    for OwningQueue<H, SIZE, BUFFER_SIZE>
+{
+    fn drop(&mut self) {
+        for buffer in self.buffers {
+            // Safe because we obtained the buffer pointer from Box::into_raw, and it won't be used
+            // anywhere else after the queue is destroyed.
+            unsafe { drop(Box::from_raw(buffer.as_ptr())) };
+        }
+    }
+}
diff --git a/crates/virtio-drivers/src/transport/fake.rs b/crates/virtio-drivers/src/transport/fake.rs
index 6ab61fc..77ed8f9 100644
--- a/crates/virtio-drivers/src/transport/fake.rs
+++ b/crates/virtio-drivers/src/transport/fake.rs
@@ -122,7 +122,7 @@
     pub fn write_to_queue<const QUEUE_SIZE: usize>(&mut self, queue_index: u16, data: &[u8]) {
         let queue = &self.queues[queue_index as usize];
         assert_ne!(queue.descriptors, 0);
-        fake_read_write_queue(
+        assert!(fake_read_write_queue(
             queue.descriptors as *const [Descriptor; QUEUE_SIZE],
             queue.driver_area as *const u8,
             queue.device_area as *mut u8,
@@ -130,7 +130,7 @@
                 assert_eq!(input, Vec::new());
                 data.to_owned()
             },
-        );
+        ));
     }
 
     /// Simulates the device reading from the given queue.
@@ -145,7 +145,7 @@
         let mut ret = None;
 
         // Read data from the queue but don't write any response.
-        fake_read_write_queue(
+        assert!(fake_read_write_queue(
             queue.descriptors as *const [Descriptor; QUEUE_SIZE],
             queue.driver_area as *const u8,
             queue.device_area as *mut u8,
@@ -153,7 +153,7 @@
                 ret = Some(input);
                 Vec::new()
             },
-        );
+        ));
 
         ret.unwrap()
     }
@@ -161,11 +161,14 @@
     /// Simulates the device reading data from the given queue and then writing a response back.
     ///
     /// The fake device always uses descriptors in order.
+    ///
+    /// Returns true if a descriptor chain was available and processed, or false if no descriptors were
+    /// available.
     pub fn read_write_queue<const QUEUE_SIZE: usize>(
         &mut self,
         queue_index: u16,
         handler: impl FnOnce(Vec<u8>) -> Vec<u8>,
-    ) {
+    ) -> bool {
         let queue = &self.queues[queue_index as usize];
         assert_ne!(queue.descriptors, 0);
         fake_read_write_queue(
@@ -178,13 +181,20 @@
 
     /// Waits until the given queue is notified.
     pub fn wait_until_queue_notified(state: &Mutex<Self>, queue_index: u16) {
-        while !state.lock().unwrap().queues[usize::from(queue_index)]
-            .notified
-            .swap(false, Ordering::SeqCst)
-        {
+        while !Self::poll_queue_notified(state, queue_index) {
             thread::sleep(Duration::from_millis(10));
         }
     }
+
+    /// Checks if the given queue has been notified.
+    ///
+    /// If it has, returns true and resets the status so this will return false until it is notified
+    /// again.
+    pub fn poll_queue_notified(state: &Mutex<Self>, queue_index: u16) -> bool {
+        state.lock().unwrap().queues[usize::from(queue_index)]
+            .notified
+            .swap(false, Ordering::SeqCst)
+    }
 }
 
 #[derive(Debug, Default)]
diff --git a/crates/virtio-drivers/src/transport/mod.rs b/crates/virtio-drivers/src/transport/mod.rs
index f6e9eae..6923475 100644
--- a/crates/virtio-drivers/src/transport/mod.rs
+++ b/crates/virtio-drivers/src/transport/mod.rs
@@ -160,6 +160,7 @@
     Pstore = 22,
     IOMMU = 23,
     Memory = 24,
+    Sound = 25,
 }
 
 impl From<u32> for DeviceType {
@@ -187,6 +188,7 @@
             22 => DeviceType::Pstore,
             23 => DeviceType::IOMMU,
             24 => DeviceType::Memory,
+            25 => DeviceType::Sound,
             _ => DeviceType::Invalid,
         }
     }
diff --git a/crates/virtio-drivers/src/transport/pci.rs b/crates/virtio-drivers/src/transport/pci.rs
index a987a9c..d6afa03 100644
--- a/crates/virtio-drivers/src/transport/pci.rs
+++ b/crates/virtio-drivers/src/transport/pci.rs
@@ -525,11 +525,12 @@
 
     #[test]
     fn offset_device_ids() {
+        assert_eq!(device_type(0x1040), DeviceType::Invalid);
         assert_eq!(device_type(0x1045), DeviceType::MemoryBalloon);
         assert_eq!(device_type(0x1049), DeviceType::_9P);
         assert_eq!(device_type(0x1058), DeviceType::Memory);
-        assert_eq!(device_type(0x1040), DeviceType::Invalid);
-        assert_eq!(device_type(0x1059), DeviceType::Invalid);
+        assert_eq!(device_type(0x1059), DeviceType::Sound);
+        assert_eq!(device_type(0x1060), DeviceType::Invalid);
     }
 
     #[test]
diff --git a/crates/virtio-drivers/src/transport/pci/bus.rs b/crates/virtio-drivers/src/transport/pci/bus.rs
index 146a7d6..0682680 100644
--- a/crates/virtio-drivers/src/transport/pci/bus.rs
+++ b/crates/virtio-drivers/src/transport/pci/bus.rs
@@ -2,6 +2,7 @@
 
 use bitflags::bitflags;
 use core::{
+    array,
     convert::TryFrom,
     fmt::{self, Display, Formatter},
 };
@@ -258,6 +259,22 @@
         }
     }
 
+    /// Returns information about all the given device function's BARs.
+    pub fn bars(
+        &mut self,
+        device_function: DeviceFunction,
+    ) -> Result<[Option<BarInfo>; 6], PciError> {
+        let mut bars = array::from_fn(|_| None);
+        let mut bar_index = 0;
+        while bar_index < 6 {
+            let info = self.bar_info(device_function, bar_index)?;
+            let takes_two_entries = info.takes_two_entries();
+            bars[usize::from(bar_index)] = Some(info);
+            bar_index += if takes_two_entries { 2 } else { 1 };
+        }
+        Ok(bars)
+    }
+
     /// Gets information about the given BAR of the given device function.
     pub fn bar_info(
         &mut self,
diff --git a/pseudo_crate/Cargo.lock b/pseudo_crate/Cargo.lock
index 2bbaf94..45cde80 100644
--- a/pseudo_crate/Cargo.lock
+++ b/pseudo_crate/Cargo.lock
@@ -5777,11 +5777,12 @@
 
 [[package]]
 name = "virtio-drivers"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa40e09453618c7a927c08c5a990497a2954da7c2aaa6c65e0d4f0fc975f6114"
+checksum = "d6a39747311dabb3d37807037ed1c3c38d39f99198d091b5b79ecd5c8d82f799"
 dependencies = [
  "bitflags 2.8.0",
+ "enumn",
  "log",
  "zerocopy 0.7.35",
 ]
diff --git a/pseudo_crate/Cargo.toml b/pseudo_crate/Cargo.toml
index b2c0a87..f858156 100644
--- a/pseudo_crate/Cargo.toml
+++ b/pseudo_crate/Cargo.toml
@@ -370,7 +370,7 @@
 vhost = "=0.8.1"
 vhost-user-backend = "=0.10.1"
 virtio-bindings = "=0.2.2"
-virtio-drivers = "=0.7.4"
+virtio-drivers = "=0.7.5"
 virtio-queue = "=0.12.0"
 virtio-vsock = "=0.6.0"
 vm-memory = "=0.12.2"