WIP.

.cargo/config

@@ -0,0 +1,12 @@
+[build]
+# Instruction set of Cortex-M0+
+target = "thumbv6m-none-eabi"
+
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+rustflags = [
+    "-C", "link-arg=--nmagic",
+    "-C", "link-arg=-Tlink.x",
+    "-C", "inline-threshold=5",
+    "-C", "no-vectorize-loops",
+]
+runner = "elf2uf2-rs -d"

.gitignore

@@ -0,0 +1,2 @@
+/target
+*.swp

Cargo.lock

@@ -0,0 +1,984 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4dc07131ffa69b8072d35f5007352af944213cde02545e2103680baed38fcd"
+
+[[package]]
+name = "as-slice"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45403b49e3954a4b8428a0ac21a4b7afadccf92bfd96273f1a58cd4812496ae0"
+dependencies = [
+ "generic-array 0.12.4",
+ "generic-array 0.13.3",
+ "generic-array 0.14.4",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "ascii-canvas"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+dependencies = [
+ "term",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "bare-metal"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
+name = "bare-metal"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"
+
+[[package]]
+name = "bit-set"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e11e16035ea35e4e5997b393eacbf6f63983188f7a2ad25bfb13465f5ad59de"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
+[[package]]
+name = "bitfield"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "byteorder"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
+[[package]]
+name = "cortex-m"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ac919ef424449ec8c08d515590ce15d9262c0ca5f0da5b0c901e971a3b783b3"
+dependencies = [
+ "bare-metal 0.2.5",
+ "bitfield",
+ "embedded-hal",
+ "volatile-register",
+]
+
+[[package]]
+name = "cortex-m-rt"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "069533b58e25b635fac881eb6556616bd8f83a3e0ffe2b4b9619289ed14d465e"
+dependencies = [
+ "cortex-m-rt-macros",
+]
+
+[[package]]
+name = "cortex-m-rt-macros"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f6f3e36f203cfedbc78b357fb28730aa2c6dc1ab060ee5c2405e843988d3c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cortex-m-rtic"
+version = "0.6.0-alpha.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74081ae0575d772472789aa6a642a1632303fd64529078d7be06fdcbec31401a"
+dependencies = [
+ "bare-metal 1.0.0",
+ "cortex-m",
+ "cortex-m-rtic-macros",
+ "generic-array 0.14.4",
+ "heapless",
+ "rtic-core",
+ "rtic-monotonic",
+ "version_check",
+]
+
+[[package]]
+name = "cortex-m-rtic-macros"
+version = "0.6.0-alpha.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c537c47b1d14be9bc6781f0bdfc514a043dd03d33796fa4f1052ac8e13c7f7d4"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "rtic-syntax",
+ "syn",
+]
+
+[[package]]
+name = "crc-any"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c268ef4daf6fe48c6794ffb5e138afb6ea405b7987ec8f8501b817a84a56d6"
+dependencies = [
+ "debug-helper",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "debug-helper"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76fbd10dce159c002b9c688ae8ab7cd531151e185e0ad360f4bfea3b0eede3a8"
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "either"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+
+[[package]]
+name = "embedded-dma"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c8c02e4347a0267ca60813c952017f4c5948c232474c6010a381a337f1bda4"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "embedded-hal"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e36cfb62ff156596c892272f3015ef952fe1525e85261fa3a7f327bd6b384ab9"
+dependencies = [
+ "nb 0.1.3",
+ "void",
+]
+
+[[package]]
+name = "embedded-time"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86fbafcea0dea120d8ed8af67ddbf82afc031f1d3b064920645db8d061781e2c"
+dependencies = [
+ "num",
+]
+
+[[package]]
+name = "ena"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7402b94a93c24e742487327a7cd839dc9d36fec9de9fb25b09f2dae459f36c3"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
+
+[[package]]
+name = "generic-array"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f797e67af32588215eaaab8327027ee8e71b9dd0b2b26996aedf20c030fce309"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "hash32"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4041af86e63ac4298ce40e5cca669066e75b6f1aa3390fe2561ffa5e1d9f4cc"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "heapless"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634bd4d29cbf24424d0a4bfcbf80c6960129dc24424752a7d1d1390607023422"
+dependencies = [
+ "as-slice",
+ "generic-array 0.14.4",
+ "hash32",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "lalrpop"
+version = "0.19.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15174f1c529af5bf1283c3bc0058266b483a67156f79589fab2a25e23cf8988"
+dependencies = [
+ "ascii-canvas",
+ "atty",
+ "bit-set",
+ "diff",
+ "ena",
+ "itertools",
+ "lalrpop-util",
+ "petgraph",
+ "pico-args",
+ "regex",
+ "regex-syntax",
+ "string_cache",
+ "term",
+ "tiny-keccak",
+ "unicode-xid",
+]
+
+[[package]]
+name = "lalrpop-util"
+version = "0.19.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e58cce361efcc90ba8a0a5f982c741ff86b603495bb15a998412e957dcd278"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+
+[[package]]
+name = "nb"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
+dependencies = [
+ "nb 1.0.0",
+]
+
+[[package]]
+name = "nb"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
+
+[[package]]
+name = "num"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b7a8e9be5e039e2ff869df49155f1c06bd01ade2117ec783e56ab0932b67a8f"
+dependencies = [
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "747d632c0c558b87dbabbe6a82f3b4ae03720d0646ac5b7b4dae89394be5f2c5"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9bd055fb730c4f8f4f57d45d35cd6b3f0980535b056dc7ff119cee6a66ed6f"
+dependencies = [
+ "derivative",
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "486ea01961c4a818096de679a8b740b26d9033146ac5291b1c98557658f8cdd9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "panic-halt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
+
+[[package]]
+name = "paste"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
+
+[[package]]
+name = "petgraph"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "467d164a6de56270bd7c4d070df81d07beace25012d5103ced4e9ff08d6afdb7"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pico-args"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8bcd96cb740d03149cbad5518db9fd87126a10ab519c011893b1754134c468"
+
+[[package]]
+name = "pio"
+version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
+dependencies = [
+ "arrayvec",
+ "num_enum",
+ "paste",
+]
+
+[[package]]
+name = "pio-parser"
+version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
+dependencies = [
+ "lalrpop",
+ "lalrpop-util",
+ "pio",
+]
+
+[[package]]
+name = "pio-proc"
+version = "0.1.0"
+source = "git+https://github.com/rp-rs/pio-rs.git?branch=main#8c12d426685ac23cac975341e728fc0a50ebfd6c"
+dependencies = [
+ "codespan-reporting",
+ "lalrpop-util",
+ "pio",
+ "pio-parser",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+dependencies = [
+ "getrandom",
+ "redox_syscall",
+]
+
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
+[[package]]
+name = "rp2040-boot2"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233203dcc51018ec08df8462fc84c0170aa4b4220bbcbe56901bc637ba98604a"
+dependencies = [
+ "crc-any",
+]
+
+[[package]]
+name = "rp2040-hal"
+version = "0.3.0"
+dependencies = [
+ "cortex-m",
+ "embedded-dma",
+ "embedded-hal",
+ "embedded-time",
+ "itertools",
+ "nb 1.0.0",
+ "paste",
+ "pio",
+ "pio-proc",
+ "rand_core",
+ "rp2040-pac",
+ "usb-device",
+ "vcell",
+ "void",
+]
+
+[[package]]
+name = "rp2040-pac"
+version = "0.1.5"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+ "vcell",
+]
+
+[[package]]
+name = "rp2040-usb-sound-card"
+version = "0.1.0"
+dependencies = [
+ "cortex-m",
+ "cortex-m-rt",
+ "cortex-m-rtic",
+ "embedded-hal",
+ "embedded-time",
+ "nb 1.0.0",
+ "panic-halt",
+ "pio",
+ "pio-proc",
+ "rp2040-boot2",
+ "rp2040-hal",
+ "stable_deref_trait",
+ "systick-monotonic",
+ "usb-device",
+ "void",
+]
+
+[[package]]
+name = "rtic-core"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bd58a6949de8ff797a346a28d9f13f7b8f54fa61bb5e3cb0985a4efb497a5ef"
+
+[[package]]
+name = "rtic-monotonic"
+version = "0.1.0-alpha.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cbf2b6e30a7e6d184be839e0858745fa15ca1af81755c9edcb7b612676604b9"
+dependencies = [
+ "embedded-time",
+]
+
+[[package]]
+name = "rtic-syntax"
+version = "0.5.0-alpha.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7676b45b31022d31d9db7efe19a0c0f554e68cf569df389a75664f7b6b7aa8ef"
+dependencies = [
+ "indexmap",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61b3909d758bb75c79f23d4736fac9433868679d3ad2ea7a61e3c25cfda9a088"
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
+[[package]]
+name = "siphasher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "533494a8f9b724d33625ab53c6c4800f7cc445895924a8ef649222dcb76e938b"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "string_cache"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ddb1139b5353f96e429e1a5e19fbaf663bddedaa06d1dbd49f82e352601209a"
+dependencies = [
+ "lazy_static",
+ "new_debug_unreachable",
+ "phf_shared",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5239bc68e0fef57495900cfea4e8dc75596d9a319d7e16b1e0a440d24e6fe0a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "systick-monotonic"
+version = "0.1.0-alpha.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e07a7e9fc4dfc670d76938ec06fe11098bb6bae775d452dca220c156a4ae50"
+dependencies = [
+ "cortex-m",
+ "rtic-monotonic",
+]
+
+[[package]]
+name = "term"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+dependencies = [
+ "dirs-next",
+ "rustversion",
+ "winapi",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "typenum"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "usb-device"
+version = "0.2.8"
+
+[[package]]
+name = "vcell"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "volatile-register"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ee8f19f9d74293faf70901bc20ad067dc1ad390d2cbf1e3f75f721ffee908b6"
+dependencies = [
+ "vcell",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "rp2040-usb-sound-card"
+version = "0.1.0"
+edition = "2018"
+resolver = "2"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.7.2"
+cortex-m-rt = "0.7"
+cortex-m-rtic = "0.6.0-alpha.5"
+embedded-hal ="0.2.5"
+embedded-time = "0.12.0"
+nb = "1.0"
+panic-halt = "0.2.0"
+pio = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
+pio-proc = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
+#rp2040-hal = { git = "https://github.com/rp-rs/rp-hal.git", features = ["rt"] }
+rp2040-hal = { path = "../rp-hal/rp2040-hal", features = ["rt"] }
+rp2040-boot2 = "0.1.2"
+stable_deref_trait = { version = "1.2.0", default-features = false }
+systick-monotonic = "0.1.0-alpha.0"
+usb-device = { version = "0.2.8", features = ["control-buffer-256"] }
+void = { version = "*", default_features = false }
+
+[patch.crates-io]
+usb-device = { path = "../usb-device" }

build.rs

@@ -0,0 +1,31 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    // By default, Cargo will re-run a build script whenever
+    // any file in the project changes. By specifying `memory.x`
+    // here, we ensure the build script is only re-run when
+    // `memory.x` is changed.
+    println!("cargo:rerun-if-changed=memory.x");
+}

memory.x

@@ -0,0 +1,13 @@
+MEMORY {
+    BOOT2 : ORIGIN = 0x10000000, LENGTH = 0x100
+    FLASH : ORIGIN = 0x10000100, LENGTH = 2048K - 0x100
+    RAM   : ORIGIN = 0x20000000, LENGTH = 256K
+}
+
+SECTIONS {
+    /* ### Boot loader */
+    .boot2 ORIGIN(BOOT2) :
+    {
+        KEEP(*(.boot2));
+    } > BOOT2
+} INSERT BEFORE .text;

src/audio_buffer.rs

@@ -0,0 +1,205 @@
+//! Audio buffer type to transfer audio data within different software/hardware components.
+#![warn(missing_docs)]
+
+use core::cell::{Cell, UnsafeCell};
+use core::ops::Deref;
+
+use cortex_m::interrupt::{CriticalSection, Mutex};
+use stable_deref_trait::StableDeref;
+
+/// Each packet contains 1 millisecond of audio data (48 samples at 48000kHz).
+///
+/// This translates two twice the number of values, as each sample contains two channels.
+pub const SAMPLES_PER_PACKET: usize = 48;
+/// Number of channels for all audio data.
+pub const CHANNELS: usize = 2;
+
+/// Buffer for a single packet with audio data.
+pub type Packet = [u32; SAMPLES_PER_PACKET * CHANNELS];
+
+/// Type for audio packet buffering.
+///
+/// The audio packets always contain two channels with 32-bit samples. The type contains a number
+/// of buffers each containing the same fixed number of samples.
+pub struct AudioBuffer<const PACKETS: usize> {
+    mutex: Mutex<AudioBufferInner<PACKETS>>,
+}
+
+struct AudioBufferInner<const PACKETS: usize> {
+    /// Packet contents.
+    packets: [UnsafeCell<Packet>; PACKETS],
+    /// Bitmask of packets which contain valid data and are not currently being read.
+    valid: Cell<u32>,
+    /// Bitmask of packets which do not contain valid data and which are not currently being
+    /// written.
+    invalid: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_read()`.
+    reading: Cell<u32>,
+    /// Bitmask of all packets which are currently borrowed via `borrow_write()`.
+    writing: Cell<u32>,
+}
+
+impl AudioBuffer<4> {
+    /// Creates a new audio buffer.
+    pub const fn new() -> Self {
+        const PACKETS: usize = 4;
+        // Initially, all packet contents are invalid and no packets are currently being read or
+        // written.
+        AudioBuffer {
+            mutex: Mutex::new(AudioBufferInner {
+                packets: [
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                    UnsafeCell::new([0; SAMPLES_PER_PACKET * CHANNELS]),
+                ],
+                valid: Cell::new(0),
+                invalid: Cell::new(((1 << PACKETS) - 1) as u32),
+                reading: Cell::new(0),
+                writing: Cell::new(0),
+            }),
+        }
+    }
+}
+
+impl<const PACKETS: usize> AudioBuffer<PACKETS> {
+    /// Returns an interface to read packets from this buffer.
+    pub fn read(&'static self) -> ReadBuffer<PACKETS> {
+        ReadBuffer { buffer: self }
+    }
+
+    /// Returns an interface to write packets to this buffer.
+    pub fn write(&'static self) -> WriteBuffer<PACKETS> {
+        WriteBuffer { buffer: self }
+    }
+}
+
+/// Interface to read packets from a buffer.
+pub struct ReadBuffer<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+}
+
+impl<const PACKETS: usize> ReadBuffer<PACKETS> {
+    /// Returns whether there are any buffers with valid data ready for reading.
+    pub fn can_read(&self, cs: &CriticalSection) -> bool {
+        let inner = self.buffer.mutex.borrow(cs);
+        inner.valid.get() != 0
+    }
+
+    /// Borrows a single buffer for reading, returns `None` if no buffer with valid data is
+    /// available.
+    ///
+    /// The caller needs to return the buffer via `read_finished()` once the data has been
+    /// processed.
+    pub fn borrow_read(&self, cs: &CriticalSection) -> Option<ReadPacket<PACKETS>> {
+        let inner = self.buffer.mutex.borrow(cs);
+        let valid = inner.valid.get();
+        if valid == 0 {
+            return None;
+        }
+        let index = valid.trailing_zeros();
+        inner.valid.set(valid & !(1 << index));
+        inner.reading.set(inner.reading.get() | (1 << index));
+
+        let index = index as usize;
+        Some(ReadPacket {
+            buffer: self.buffer,
+            data: unsafe { &*inner.packets[index].get() },
+            index,
+        })
+    }
+
+    /// Returns a buffer that was allocated via `borrow_read()` and marks it as empty.
+    pub fn read_finished(&self, packet: ReadPacket<PACKETS>, cs: &CriticalSection) {
+        assert!((self.buffer as *const _) == (packet.buffer as *const _));
+        let inner = self.buffer.mutex.borrow(cs);
+        let index = packet.index;
+        inner.reading.set(inner.reading.get() & !(1 << index));
+        inner.invalid.set(inner.invalid.get() | (1 << index));
+    }
+}
+
+/// Interface to write packets to a buffer.
+pub struct WriteBuffer<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+}
+
+impl<const PACKETS: usize> WriteBuffer<PACKETS> {
+    /// Returns whether there are any empty buffers ready for writing.
+    pub fn can_write(&self, cs: &CriticalSection) -> bool {
+        let inner = self.buffer.mutex.borrow(cs);
+        inner.invalid.get() != 0
+    }
+
+    /// Borrows a single buffer for writing, returns `None` if no empty buffer is available.
+    ///
+    /// The caller needs to return the buffer via `write_finished()` once it was filled with data.
+    pub fn borrow_write(&self, cs: &CriticalSection) -> Option<WritePacket<PACKETS>> {
+        let inner = self.buffer.mutex.borrow(cs);
+        let invalid = inner.invalid.get();
+        if invalid == 0 {
+            return None;
+        }
+        let index = invalid.trailing_zeros();
+        inner.invalid.set(invalid & !(1 << index));
+        inner.writing.set(inner.writing.get() | (1 << index));
+
+        let index = index as usize;
+        Some(WritePacket {
+            buffer: self.buffer,
+            data: unsafe { &mut *inner.packets[index].get() },
+            index,
+        })
+    }
+
+    /// Returns a buffer that was allocated via `borrow_write()` and marks it as ready for reading.
+    pub fn write_finished(&self, packet: WritePacket<PACKETS>, cs: &CriticalSection) {
+        assert!((self.buffer as *const _) == (packet.buffer as *const _));
+        let inner = self.buffer.mutex.borrow(cs);
+        let index = packet.index;
+        inner.writing.set(inner.writing.get() & !(1 << index));
+        inner.valid.set(inner.valid.get() | (1 << index));
+    }
+}
+
+/// Packet buffer that has been borrowed for reading (i.e., the buffer contains valid data).
+pub struct ReadPacket<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+    data: &'static Packet,
+    index: usize,
+}
+
+impl<const PACKETS: usize> AsRef<[u32]> for ReadPacket<PACKETS> {
+    fn as_ref(&self) -> &[u32] {
+        self.data
+    }
+}
+
+impl<const PACKETS: usize> Deref for ReadPacket<PACKETS> {
+    type Target = Packet;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+unsafe impl<const PACKETS: usize> StableDeref for ReadPacket<PACKETS> {}
+
+/// Packet buffer that has been borrowed for writing (i.e., the buffer was previously empty).
+pub struct WritePacket<const PACKETS: usize> {
+    buffer: &'static AudioBuffer<PACKETS>,
+    data: &'static mut Packet,
+    index: usize,
+}
+
+impl<const PACKETS: usize> AsRef<[u32]> for WritePacket<PACKETS> {
+    fn as_ref(&self) -> &[u32] {
+        self.data
+    }
+}
+
+impl<const PACKETS: usize> AsMut<[u32]> for WritePacket<PACKETS> {
+    fn as_mut(&mut self) -> &mut [u32] {
+        self.data
+    }
+}

src/i2s_master.rs

@@ -0,0 +1,121 @@
+use crate::audio_buffer::{ReadBuffer, ReadPacket};
+use core::marker::PhantomData;
+use cortex_m::interrupt;
+use rp2040_hal::dma::{Channel, ChannelIndex, SingleBuffering, SingleBufferingConfig};
+use rp2040_hal::gpio::bank0::{Gpio0, Gpio1, Gpio3, Gpio6};
+use rp2040_hal::gpio::{Function, Pin, Pio0};
+use rp2040_hal::pac::PIO0;
+use rp2040_hal::pio::{
+    PIOBuilder, PIOExt, StateMachineIndex, Tx, UninitStateMachine, ValidStateMachine, PIO,
+};
+
+pub trait PinConfig {
+    type PIO;
+
+    const OUT_MASK: u32;
+}
+
+impl PinConfig
+    for (
+        Pin<Gpio0, Function<Pio0>>,
+        Pin<Gpio1, Function<Pio0>>,
+        Pin<Gpio6, Function<Pio0>>,
+        Pin<Gpio3, Function<Pio0>>,
+    )
+{
+    type PIO = PIO0;
+
+    const OUT_MASK: u32 = 0x4b;
+}
+
+pub struct I2sMaster<SM: ValidStateMachine, DMACH: ChannelIndex, LRCLK, BCLK, SDO, SDI> {
+    tx: Option<SingleBuffering<Channel<DMACH>, ReadPacket<4>, Tx<SM>>>,
+    out_buffer: ReadBuffer<4>,
+    _phantom: PhantomData<(SM, LRCLK, BCLK, SDO, SDI)>,
+}
+
+impl<P: PIOExt, SM: StateMachineIndex, DMACH: ChannelIndex, LRCLK, BCLK, SDO, SDI>
+    I2sMaster<(P, SM), DMACH, LRCLK, BCLK, SDO, SDI>
+where
+    (LRCLK, BCLK, SDO, SDI): PinConfig,
+{
+    pub fn init(
+        pio: &mut PIO<P>,
+        sm: UninitStateMachine<(P, SM)>,
+        dma: Channel<DMACH>,
+        out_buffer: ReadBuffer<4>,
+        _lrclk: LRCLK,
+        _bclk: BCLK,
+        _sdo: SDO,
+        _sdi: SDI,
+    ) -> Self {
+        let program = pio_proc::pio!(
+            32,
+            "
+        .side_set 2
+
+        .wrap_target
+            pull noblock      side 0b11 [0]
+            set x, 14         side 0b11 [0]
+
+        leftloop:
+            out pins, 1       side 0b00 [6]
+            in pins, 1        side 0b01 [5]
+            jmp x-- leftloop  side 0b01 [0]
+
+            out pins, 1       side 0b00 [6]
+            in pins, 1        side 0b01 [5]
+            set x, 14         side 0b01 [0]
+        rightloop:
+            out pins, 1       side 0b10 [6]
+            in pins, 1        side 0b11 [5]
+            jmp x-- rightloop side 0b11 [0]
+
+            out pins, 1       side 0b10 [6]
+            in pins, 1        side 0b11 [3]
+            push noblock      side 0b11 [0]
+        .wrap
+                    "
+        );
+
+        let installed = pio.install(&program.program).unwrap();
+        let (mut sm, _rx, tx) = PIOBuilder::from_program(installed)
+            .side_set_pin_base(0)
+            //.set_pins(6, 1)
+            .out_pins(6, 1)
+            .in_pin_base(3)
+            .clock_divisor(4.0)
+            .build(sm);
+        sm.set_pindirs_with_mask(
+            <(LRCLK, BCLK, SDO, SDI)>::OUT_MASK,
+            <(LRCLK, BCLK, SDO, SDI)>::OUT_MASK,
+        );
+
+        // Start the first DMA transfer.
+        let packet = interrupt::free(|cs| out_buffer.borrow_read(cs).unwrap());
+        let tx = SingleBufferingConfig::new(dma, packet, tx).start();
+
+        // Start I2S.
+        // TODO: Synchronized start of multiple I2S instances?
+        sm.start();
+
+        I2sMaster {
+            tx: Some(tx),
+            out_buffer,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn next_packet(&mut self) {
+        if !self.tx.as_mut().unwrap().check_irq0() {
+            return;
+        }
+
+        let (dma, prev_packet, tx) = self.tx.take().unwrap().wait();
+        let packet = interrupt::free(|cs| {
+            self.out_buffer.read_finished(prev_packet, cs);
+            self.out_buffer.borrow_read(cs).unwrap()
+        });
+        self.tx = Some(SingleBufferingConfig::new(dma, packet, tx).start());
+    }
+}

src/main.rs

@@ -0,0 +1,231 @@
+#![no_std]
+#![no_main]
+
+use panic_halt as _;
+
+mod audio_buffer;
+mod i2s_master;
+mod usb;
+mod usb_audio;
+
+#[link_section = ".boot2"]
+#[used]
+pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER;
+
+#[rtic::app(device = rp2040_hal::pac, peripherals = true, dispatchers = [RTC_IRQ, XIP_IRQ])]
+mod app {
+    use embedded_hal::digital::v2::OutputPin;
+    use embedded_time::duration::Milliseconds;
+    use embedded_time::rate::{Extensions, Megahertz};
+    use rp2040_hal::clocks::ClocksManager;
+    use rp2040_hal::gpio;
+    //use rp2040_hal::pio::{PIOBuilder, PIOExt};
+    use crate::audio_buffer::AudioBuffer;
+    use crate::i2s_master::I2sMaster;
+    use crate::usb::Usb;
+    use cortex_m::interrupt;
+    use rp2040_hal::dma::{DMAExt, SingleChannel, CH0};
+    use rp2040_hal::gpio::bank0::{Gpio0, Gpio1, Gpio3, Gpio6};
+    use rp2040_hal::gpio::{Function, Pin, Pio0};
+    use rp2040_hal::pio::{PIOExt, PIO0SM0};
+    use rp2040_hal::pll::common_configs::PLL_USB_48MHZ;
+    use rp2040_hal::pll::{setup_pll_blocking, PLLConfig};
+    use rp2040_hal::sio::Sio;
+    use rp2040_hal::timer::Timer;
+    use rp2040_hal::usb::UsbBus;
+    use rp2040_hal::watchdog::Watchdog;
+    use rp2040_hal::xosc::setup_xosc_blocking;
+    use systick_monotonic::Systick;
+    use usb_device::class_prelude::*;
+
+    const XOSC_CRYSTAL_FREQ: u32 = 12_000_000;
+    pub const PLL_SYS_86MHZ: PLLConfig<Megahertz> = PLLConfig {
+        vco_freq: Megahertz(1032),
+        refdiv: 1,
+        post_div1: 6,
+        post_div2: 2,
+    };
+
+    static AUDIO_BUFFER: AudioBuffer<4> = AudioBuffer::new();
+
+    #[monotonic(binds = SysTick, default = true)]
+    type SystickMono = Systick<100>;
+
+    #[shared]
+    struct Shared {}
+
+    #[local]
+    struct Local {
+        led: gpio::Pin<gpio::pin::bank0::Gpio25, gpio::PushPullOutput>,
+        i2s: I2sMaster<
+            PIO0SM0,
+            CH0,
+            Pin<Gpio0, Function<Pio0>>,
+            Pin<Gpio1, Function<Pio0>>,
+            Pin<Gpio6, Function<Pio0>>,
+            Pin<Gpio3, Function<Pio0>>,
+        >,
+        usb: Usb,
+    }
+
+    #[init]
+    fn init(c: init::Context) -> (Shared, Local, init::Monotonics) {
+        let mut resets = c.device.RESETS;
+
+        // The timer needs a 1MHz input from the watchdog.
+        let mut watchdog = Watchdog::new(c.device.WATCHDOG);
+        watchdog.enable_tick_generation((XOSC_CRYSTAL_FREQ / 1000000) as u8);
+
+        // We let an LED blink to show that the system is still alive.
+        let sio = Sio::new(c.device.SIO);
+        let pins = gpio::Pins::new(
+            c.device.IO_BANK0,
+            c.device.PADS_BANK0,
+            sio.gpio_bank0,
+            &mut resets,
+        );
+
+        // We select a 86 MHz system clock as that lets us generate a clean and precise 12.288 MHz
+        // master clock by dividing the system clock by 7.
+        // TODO: Select 123 MHz instead (0.1% deviation, whereas 86 MHz results in 0.02%
+        // deviation), or look for an even better frequency that is not a multiple of 1MHz.
+        let mut clocks = ClocksManager::new(c.device.CLOCKS);
+        let xosc = setup_xosc_blocking(c.device.XOSC, XOSC_CRYSTAL_FREQ.Hz())
+            .ok()
+            .unwrap();
+        let pll_sys = setup_pll_blocking(
+            c.device.PLL_SYS,
+            xosc.operating_frequency().into(),
+            PLL_SYS_86MHZ,
+            &mut clocks,
+            &mut resets,
+        )
+        .ok()
+        .unwrap();
+        let pll_usb = setup_pll_blocking(
+            c.device.PLL_USB,
+            xosc.operating_frequency().into(),
+            PLL_USB_48MHZ,
+            &mut clocks,
+            &mut resets,
+        )
+        .ok()
+        .unwrap();
+        let _clocks = clocks.init_default(&xosc, &pll_sys, &pll_usb).ok().unwrap();
+
+        let mut led = pins.gpio25.into_push_pull_output();
+        led.set_low().ok().unwrap();
+
+        // We need a timer so that we can determine the USB SOF frequency for asynchronous USB
+        // audio.
+        let timer = Timer::new(c.device.TIMER, &mut resets);
+
+        // We initialize the output audio buffers with some data. As the I2S input buffers are
+        // filled at the same rate as the I2S output buffers, this initial state ensures that the
+        // output buffers never run empty (note that the USB audio interface performs its own
+        // adaptive synchronization).
+        interrupt::free(|cs| {
+            let write = AUDIO_BUFFER.write();
+            for _ in 0..2 {
+                let mut packet = write.borrow_write(cs).unwrap();
+                let data = packet.as_mut();
+                for i in 0..data.len() {
+                    //data[i] = 0x80000000; // "0"
+                    data[i] = 0xa5a5aa55;
+                }
+                write.write_finished(packet, cs);
+            }
+        });
+
+        // Configure USB audio.
+        static mut USB_BUS: Option<UsbBusAllocator<UsbBus>> = None;
+        unsafe {
+            USB_BUS = Some(UsbBusAllocator::new(UsbBus::new(
+                c.device.USBCTRL_REGS,
+                c.device.USBCTRL_DPRAM,
+                clocks.usb_clock,
+                true,
+                &mut resets,
+            )))
+        };
+
+        let usb = Usb::init(
+            unsafe { USB_BUS.as_ref().unwrap() },
+            AUDIO_BUFFER.write(),
+            timer,
+        );
+
+        // Configure the PIO unit and start I2S.
+        let mut dma = c.device.DMA.split(&mut resets);
+        let (mut pio, sm0, _sm1, _sm2, _sm3) = c.device.PIO0.split(&mut resets);
+        dma.ch0.listen_irq0();
+        let i2s = I2sMaster::init(
+            &mut pio,
+            sm0,
+            dma.ch0,
+            AUDIO_BUFFER.read(),
+            pins.gpio0.into_mode(),
+            pins.gpio1.into_mode(),
+            pins.gpio6.into_mode(),
+            pins.gpio3.into_mode(),
+        );
+
+        // A speaker amplifier (TAS5760) is connected to I2S - we need to configure it via I2C.
+        // TODO
+        // TODO: I2C stuff should happen in a low-priority task as we do not want to make data
+        // streaming to I2S wait.
+
+        let systick = c.core.SYST;
+        let mono = Systick::new(systick, 86_000_000);
+        blink::spawn().ok().unwrap();
+        (Shared {}, Local { led, i2s, usb }, init::Monotonics(mono))
+    }
+
+    #[task(shared = [], local = [led, state: bool = false])]
+    fn blink(ctx: blink::Context) {
+        blink::spawn_after(Milliseconds(500_u32)).ok().unwrap();
+        *ctx.local.state = !*ctx.local.state;
+        if *ctx.local.state {
+            ctx.local.led.set_high().ok().unwrap();
+        } else {
+            ctx.local.led.set_low().ok().unwrap();
+        }
+    }
+
+    /// DMA interrupt handler.
+    ///
+    /// DMA interrupts need to have highest priority as we need to quickly restart the DMA transfer
+    /// to ensure that the PIO FIFO always contains data.
+    #[task(binds = DMA_IRQ_0, priority = 3, local = [i2s])]
+    fn dma(ctx: dma::Context) {
+        ctx.local.i2s.next_packet();
+        process_buffers::spawn().unwrap();
+    }
+
+    #[task]
+    fn process_buffers(_: process_buffers::Context) {
+        interrupt::free(|cs| {
+            // If we have run out of data from USB, insert a packet filled with zeros.
+            // TODO
+
+            let write = AUDIO_BUFFER.write();
+            let mut packet = write.borrow_write(cs).unwrap();
+            let data = packet.as_mut();
+            for i in 0..data.len() {
+                //data[i] = 0x80000000; // "0"
+                data[i] = 0xa5a5aa55;
+            }
+            write.write_finished(packet, cs);
+        });
+    }
+
+    /// USB interrupt handler.
+    ///
+    /// USB interrupts have a high priority (albeit not as high as DMA) so that we can precisely
+    /// measure the SOF frequency relative to our system clock. The frequency ratio is required for
+    /// asynchronous USB audio.
+    #[task(binds = USBCTRL_IRQ, priority = 2, local = [usb])]
+    fn usb(ctx: usb::Context) {
+        ctx.local.usb.poll();
+    }
+}

src/usb.rs

@@ -0,0 +1,63 @@
+use crate::audio_buffer::{WriteBuffer, WritePacket};
+use crate::usb_audio::UsbAudioClass;
+use rp2040_hal::pac::USBCTRL_REGS;
+use rp2040_hal::timer::Timer;
+use rp2040_hal::usb::UsbBus;
+use usb_device::{class_prelude::*, prelude::*};
+
+pub struct Usb {
+    usb_audio: UsbAudioClass<'static, UsbBus, WritePacket<4>>,
+    usb_dev: UsbDevice<'static, UsbBus>,
+    in_buffer: WriteBuffer<4>,
+
+    timer: Timer,
+}
+
+impl Usb {
+    pub fn init(
+        bus: &'static UsbBusAllocator<UsbBus>,
+        in_buffer: WriteBuffer<4>,
+        timer: Timer,
+    ) -> Usb {
+        let usb_audio = UsbAudioClass::new(bus);
+
+        // This PID/VID combination is selected from the pid.codes PID space and only intended for
+        // software development. It is not universally unique and should not be used outside of
+        // test environments!
+        let usb_dev = UsbDeviceBuilder::new(bus, UsbVidPid(0x1209, 0x000d))
+            .manufacturer("TEST")
+            .product("USB audio test")
+            .serial_number("TEST")
+            .build();
+
+        // TODO
+        Usb {
+            usb_audio,
+            usb_dev,
+            in_buffer,
+            timer,
+        }
+    }
+
+    pub fn poll(&mut self) {
+        // Safety: The read access does not have any side effect, and this function is the only one
+        // using the USB peripheral at this time.
+        let sof = unsafe { (&*USBCTRL_REGS::ptr()).intr.read().dev_sof().bit_is_set() };
+        if sof {
+            // Calculate the frequency difference (frames versus 1kHz derived from the system
+            // clock) and update the synchronization data for the USB audio class accordingly.
+            // Also, add a correction factor if the buffers are running low or high.
+            // TODO
+
+            /*let mut buffer = [0u8; 64];
+            for i in 0..64 {
+                buffer[i] = i as u8 * 4;
+            }
+            let _err = self.usb_audio.write_packet(&buffer);*/
+        }
+        if self.usb_dev.poll(&mut [&mut self.usb_audio]) {
+            // If we received audio data, move it into the buffer.
+            // TODO
+        }
+    }
+}

src/usb_audio.rs

@@ -0,0 +1,568 @@
+//! USB audio class for asynchronous, bidirectional (microphone + speakers) 48kHz audio.
+//!
+//! See "Universal Serial Bus Device Class Definition for Audio Devices", release 1.0 (March 18,
+//! 1998) for a specification of the USB audio class.
+use usb_device::class_prelude::*;
+use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
+use usb_device::Result;
+
+const DEVICE_CLASS_AUDIO: u8 = 0x01;
+const AUDIO_SUBCLASS_CONTROL: u8 = 0x01;
+const AUDIO_SUBCLASS_STREAMING: u8 = 0x02;
+const AUDIO_PROTOCOL_NONE: u8 = 0x00;
+
+const AUDIO_INTERFACE_DESC_TYPE: u8 = 0x24;
+const AUDIO_ENDPOINT_DESC_TYPE: u8 = 0x25;
+
+const AUDIO_CONTROL_HEADER: u8 = 0x01;
+const AUDIO_CONTROL_INPUT_TERMINAL: u8 = 0x02;
+const AUDIO_CONTROL_OUTPUT_TERMINAL: u8 = 0x03;
+const AUDIO_CONTROL_FEATURE_UNIT: u8 = 0x06;
+
+const AUDIO_STREAMING_GENERAL: u8 = 0x01;
+const AUDIO_STREAMING_FORMAT_TYPE: u8 = 0x02;
+
+const AUDIO_ENDPOINT_GENERAL: u8 = 0x01;
+
+// TODO: Update bDelay.
+
+pub struct UsbAudioClass<'a, B: UsbBus, OUTBUF: AsRef<[u32]>> {
+    audio_control: InterfaceNumber,
+    audio_streaming_inactive: InterfaceNumber,
+    audio_streaming: InterfaceNumber,
+    audio_out: EndpointOut<'a, B>,
+    audio_out_sync: EndpointIn<'a, B>,
+    //audio_in: EndpointIn<'a, B>,
+    samples_per_frame: [u8; 3],
+
+    audio_out_buf: Option<OUTBUF>,
+}
+
+impl<'a, B: UsbBus, OUTBUF: AsRef<[u32]>> UsbAudioClass<'a, B, OUTBUF> {
+    pub fn new(bus_alloc: &'a UsbBusAllocator<B>) -> Self {
+        UsbAudioClass {
+            audio_control: bus_alloc.interface(),
+            audio_streaming_inactive: bus_alloc.interface(),
+            audio_streaming: bus_alloc.interface(),
+            // 48kHz * 2 * 16bit = 192B per packet. We allocate a bit more in case the device clock
+            // is faster than the host clock.
+            /*audio_out: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),*/
+            audio_out: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Synchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),
+            audio_out_sync: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Feedback,
+                3,
+                1,
+            ),
+            /*audio_in: bus_alloc.isochronous(
+                IsochronousSynchronizationType::Asynchronous,
+                IsochronousUsageType::Data,
+                256,
+                1,
+            ),*/
+            samples_per_frame: [48 >> 2, 48 << 6, 0], // 48 kHz
+            audio_out_buf: None,
+        }
+    }
+
+    // TODO: Functions to read and write data?
+}
+
+impl<B: UsbBus, OUTBUF: AsRef<[u32]>> UsbClass<B> for UsbAudioClass<'_, B, OUTBUF> {
+    fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
+        writer.iad(
+            self.audio_control,
+            2,   // Two interfaces (control + streaming).
+            0x0, // Each interface specifies its own class.
+            0x0, // Each interface specifies its own subclass.
+            0x0, // No class-specific protocols for this device.
+        )?;
+
+        // Audio control interface.
+        writer.interface(
+            self.audio_control,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_CONTROL,
+            AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_HEADER,        // bDescriptorSubtype
+                0x00,                        // bcdADC
+                0x01,                        //
+                37,                          // wTotalLength
+                0,                           //
+                0x01,                        // bInCollection
+                self.audio_streaming.into(), // baInterfaceNr
+            ],
+        )?;
+
+        // Input terminal (USB streaming).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_INPUT_TERMINAL, // bDescriptorSubtype
+                0x01,                         // bTerminalID
+                0x01,                         // wTerminalType
+                0x01,                         //
+                0x00,                         // bAssocTerminal
+                0x02,                         // bNrChannels
+                0x03,                         // wChannelConfig
+                0x00,                         //
+                0x00,                         // iChannelNames
+                0x00,                         // iTerminal
+            ],
+        )?;
+
+        // Feature unit (volume and mute).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_FEATURE_UNIT, // bDescriptorSubtype
+                0x02,                       // bUnitID
+                0x01,                       // bSourceID
+                0x01,                       // bControlSize
+                0x03,                       // bmaControls(0)
+                0x00,                       // iFeature
+            ],
+        )?;
+
+        // Output terminal (speaker).
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_CONTROL_OUTPUT_TERMINAL, // bDescriptorSubtype
+                0x03,                          // bTerminalID
+                0x01,                          // wTerminalType
+                0x03,                          //
+                0x00,                          // bAssocTerminal
+                0x02,                          // bSourceID
+                0x00,                          // iTerminal
+            ],
+        )?;
+
+        // Audio streaming interface (zero-bandwidth).
+        writer.interface(
+            self.audio_streaming_inactive,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_STREAMING,
+            AUDIO_PROTOCOL_NONE,
+        )?;
+
+        // Audio streaming interface (operational).
+        writer.interface_alt(
+            self.audio_streaming,
+            1,
+            DEVICE_CLASS_AUDIO,
+            AUDIO_SUBCLASS_STREAMING,
+            AUDIO_PROTOCOL_NONE,
+            None,
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_STREAMING_GENERAL, // bDescriptorSubtype
+                0x01,                    // bTerminalLink
+                0x03,                    // bDelay
+                0x01,                    // wFormatTag
+                0x00,                    //
+            ],
+        )?;
+
+        writer.write(
+            AUDIO_INTERFACE_DESC_TYPE,
+            &[
+                AUDIO_STREAMING_FORMAT_TYPE, // bDescriptorSubtype
+                0x01,                        // bFormatType
+                0x02,                        // bNrChannels
+                0x02,                        // bSubframeSize
+                0x10,                        // bBitResolution
+                0x01,                        // bSamFreqType
+            ],
+        )?;
+
+        /*writer.endpoint_ex(&self.audio_out, |data| {
+            // TODO: Faster refresh
+            data[0] = 0x09; // bRefresh
+            data[1] = self.audio_out_sync.address().into(); // bSynchAddress
+            Ok(2)
+        })?;*/
+        writer.endpoint(&self.audio_out)?;
+
+        writer.write(
+            AUDIO_ENDPOINT_DESC_TYPE,
+            &[
+                AUDIO_ENDPOINT_GENERAL, // bDescriptorSubtype
+                0x00,                   // bmAttributes
+                0x01,                   // bLockDelayUnits
+                0x00,                   // wLockDelay
+                0x00,
+            ],
+        )?;
+
+        /*writer.endpoint_ex(&self.audio_out_sync, |data| {
+            data[0] = 0x00; // bRefresh
+            data[1] = 0x00; // bSynchAddress
+            Ok(2)
+        })?;*/
+
+        Ok(())
+    }
+
+    fn get_string(&self, _index: StringIndex, _lang_id: u16) -> Option<&str> {
+        // TODO
+        None
+    }
+
+    fn reset(&mut self) {
+        // Start sending synchronization data.
+        self.endpoint_in_complete(self.audio_out_sync.address());
+    }
+
+    fn control_out(&mut self, xfer: ControlOut<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            // TODO
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+
+    fn control_in(&mut self, xfer: ControlIn<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            // TODO
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+
+    fn endpoint_out(&mut self, addr: EndpointAddress) {
+        if addr == self.audio_out.address() {
+            if self.audio_out_buf.is_some() {
+                // TODO: Write data into buffer, move buffer somewhere else.
+            } else {
+                // TODO
+            }
+            // TODO: Process incoming audio data.
+            let mut buffer = [0u8; 256];
+            self.audio_out.read(&mut buffer);
+        }
+    }
+
+    fn endpoint_in_complete(&mut self, addr: EndpointAddress) {
+        if addr == self.audio_out_sync.address() {
+            // Immediately write the next sync value.
+            //self.audio_out_sync.write(&self.samples_per_frame).unwrap();
+        }
+    }
+}
+
+/*use usb_device::class_prelude::*;
+use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
+use usb_device::Result;
+
+/// This should be used as `device_class` when building the `UsbDevice`.
+pub const USB_INTERFACE_CLASS_AUDIO: u8 = 0x01;
+
+const USB_AUDIO_SUBCLASS_UNDEFINED: u8 = 0x0;
+const USB_AUDIO_SUBCLASS_AUDIOCONTROL: u8 = 0x01;
+const USB_AUDIO_SUBCLASS_AUDIOSTREAMING: u8 = 0x02;
+const USB_AUDIO_SUBCLASS_MIDISTREAMING: u8 = 0x03;
+
+const USB_CLASS_CDC_DATA: u8 = 0x0a;
+const CDC_SUBCLASS_ACM: u8 = 0x02;
+const USB_AUDIO_PROTOCOL_NONE: u8 = 0x00;
+
+const CS_DEVICE: u8 = 0x21;
+const CS_CONFIGURATION: u8 = 0x22;
+const CS_STRING: u8 = 0x23;
+const CS_INTERFACE: u8 = 0x24;
+const CS_ENDPOINT: u8 = 0x25;
+
+const EP_GENERAL: u8 = 0x1;
+
+const AC_DESC_TYPE_HEADER: u8 = 0x1;
+const AC_DESC_TYPE_INPUT_TERMINAL: u8 = 0x2;
+const AC_DESC_TYPE_OUTPUT_TERMINAL: u8 = 0x3;
+const AC_DESC_TYPE_MIXER_UNIT: u8 = 0x4;
+const AC_DESC_TYPE_SELECTOR_UNIT: u8 = 0x5;
+const AC_DESC_TYPE_FEATURE_UNIT: u8 = 0x6;
+const AC_DESC_TYPE_PROCESSING_UNIT: u8 = 0x7;
+const AC_DESC_TYPE_EXTENSION_UNIT: u8 = 0x8;
+
+const AC_DESC_ST_GENERAL: u8 = 0x1;
+const AC_DESC_ST_FORMAT_TYPE: u8 = 0x2;
+const AC_DESC_ST_FORMAT_SPECIFIC: u8 = 0x3;
+
+const AUDIO_SUB_TYPE_HEADER: u8 = 0x01;
+const AUDIO_SUB_TYPE_INPUT_TERMINAL: u8 = 0x02;
+const AUDIO_SUB_TYPE_FEATURE_UNIT: u8 = 0x06;
+const AUDIO_SUB_TYPE_OUTPUT_TERMINAL: u8 = 0x03;
+const AUDIO_SUB_TYPE_AS_GENERAL: u8 = 0x01;
+const AUDIO_SUB_TYPE_FORMAT_TYPE: u8 = 0x02;
+
+pub struct UsbAudioClass<'a, B: UsbBus> {
+    audio_control_if: InterfaceNumber,
+    audio_stream: InterfaceNumber,
+    alt_audio_stream: InterfaceNumber,
+    audio_in_ep: EndpointIn<'a, B>,
+}
+
+impl<B: UsbBus> UsbAudioClass<'_, B> {
+    /// Creates a new UsbAudioClass with the provided UsbBus and max_packet_size in bytes. For
+    /// full-speed devices, max_packet_size has to be one of 8, 16, 32 or 64.
+    pub fn new(alloc: &UsbBusAllocator<B>, max_packet_size: u16) -> UsbAudioClass<'_, B> {
+        UsbAudioClass {
+            audio_control_if: alloc.interface(),
+            audio_stream: alloc.interface(),
+            alt_audio_stream: alloc.interface(),
+            audio_in_ep: alloc.isochronous(
+                IsochronousSynchronizationType::Synchronous,
+                IsochronousUsageType::Data,
+                max_packet_size,
+                4,
+            ),
+        }
+    }
+
+    /// Gets the maximum packet size in bytes.
+    pub fn max_packet_size(&self) -> u16 {
+        self.audio_in_ep.max_packet_size()
+    }
+
+    /// Writes a single packet into the IN endpoint.
+    pub fn write_packet(&mut self, data: &[u8]) -> Result<usize> {
+        //defmt::info!("write_packet");
+        self.audio_in_ep.write(data)
+    }
+
+    /// Gets the address of the IN endpoint.
+    pub(crate) fn write_ep_address(&self) -> EndpointAddress {
+        self.audio_in_ep.address()
+    }
+}
+
+impl<B: UsbBus> UsbClass<B> for UsbAudioClass<'_, B> {
+    fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
+        writer.iad(
+            self.audio_control_if,
+            3,
+            0x0, // device defined at interface level
+            0x0, // subclass unused
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.interface(
+            self.audio_control_if,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOCONTROL,
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_HEADER, // bDescriptorSubtype
+                0x00,
+                0x1, // bcdADC (1.0),
+                43,
+                0,    // wTotalLength (Compute this!)
+                0x01, // bInCollection (1 streaming interface)
+                0x01, // baInterfaceNr (Interface 1 is stream)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_INPUT_TERMINAL, // bDescriptorSubtype
+                0x01,                          // bTerminalID 1,
+                0x10,
+                0x07, // wTerminalType (radio receiver)
+                0x00, // bAssocTerminal (none)
+                0x02, // bNrChannels - 2 for I and Q
+                0x03,
+                0x00, // wChannelConfig (left, right)
+                0x00, // iChannelNames (none)
+                0x00, // iTerminal (none)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_FEATURE_UNIT, // bDescriptorSubtype
+                0x02,                        // bUnitID,
+                0x01,                        // bSourceID (input terminal 1)
+                0x02,                        // bControlSize (2 bytes)
+                0x01,
+                0x00, // Master controls
+                0x00,
+                0x00, // Channel 0 controls
+                0x00,
+                0x00, // Channel 1 controls
+                0x00, // iFeature (none)
+            ],
+        )?;
+
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_OUTPUT_TERMINAL, // bDescriptorSubtype
+                0x03,                           // bTerminalID,
+                0x01,
+                0x01, // wTerminalType (USB Streaming)
+                0x00, // bAssocTerminal (none)
+                0x02, // bSourceID (feature unit 2)
+                0x00, // iTerminal (none)
+            ],
+        )?;
+
+        writer.interface(
+            self.audio_stream,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOSTREAMING,
+            USB_AUDIO_PROTOCOL_NONE,
+        )?;
+
+        //alternate audio stream
+        /*writer.interface_alt(
+            self.alt_audio_stream,
+            1,
+            USB_INTERFACE_CLASS_AUDIO,
+            USB_AUDIO_SUBCLASS_AUDIOSTREAMING,
+            USB_AUDIO_PROTOCOL_NONE,
+            None,
+        )?;*/
+
+        // Audio Stream Audio Class Descriptor
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_AS_GENERAL, // bDescriptorSubtype
+                0x03,                      // bTerminalID,
+                0x00,                      // bDelay
+                0x01,
+                0x00, // wFormatTag (PCM Format)
+            ],
+        )?;
+
+        // Format Type Audio Descriptor
+        writer.write(
+            CS_INTERFACE,
+            &[
+                AUDIO_SUB_TYPE_FORMAT_TYPE, // bDescriptorSubtype
+                0x01,                       // bFormatType (TYPE_I)
+                0x02,                       // bNrChannels (2)
+                0x02,                       // bSubFrameSize (2)
+                0x10,                       // bBitResolution (16 bits)
+                0x01,                       // bSamFreqType (1 sample frequency)
+                0x80,                       // 8*2 = 16 KHz byte 0
+                0x3E,                       // 8*2 = 16 KHz byte 1
+                0x00,                       // 8*2 = 16 KHz byte 2
+            ],
+        )?;
+
+        // TODO: Set the necessary flags for Isochronous
+        writer.endpoint(&self.audio_in_ep)?;
+
+        // Isochronous endpoint Audio Class descriptor
+        writer.write(
+            CS_ENDPOINT,
+            &[
+                EP_GENERAL, // bDescriptorSubtype
+                0x00,       // bmAttributes (none)
+                0x02,       // bLockDelayUnits (PCM Samples)
+                0x00, 0x00, // wLockDelay (0)  - should be zero for asynchronous
+            ],
+        )?;
+        Ok(())
+    }
+
+    fn reset(&mut self) {}
+
+    fn control_in(&mut self, xfer: ControlIn<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control_if) as u16)
+        {
+            return;
+        }
+
+        //defmt::info!("control_in - req : {:?}", req.request);
+        match req.request {
+            /*
+            REQ_GET_LINE_CODING if req.length == 7 => {
+                xfer.accept(|data| {
+                    data[0..4].copy_from_slice(&self.line_coding.data_rate.to_le_bytes());
+                    data[4] = self.line_coding.stop_bits as u8;
+                    data[5] = self.line_coding.parity_type as u8;
+                    data[6] = self.line_coding.data_bits;
+
+                    Ok(7)
+                }).ok();
+            },
+            */
+            _ => {
+                xfer.reject().ok();
+            }
+        }
+    }
+
+    fn control_out(&mut self, xfer: ControlOut<B>) {
+        let req = xfer.request();
+
+        if !(req.request_type == control::RequestType::Class
+            && req.recipient == control::Recipient::Interface
+            && req.index == u8::from(self.audio_control_if) as u16)
+        {
+            return;
+        }
+
+        match req.request {
+            /*
+            REQ_SEND_ENCAPSULATED_COMMAND => {
+                // We don't actually support encapsulated commands but pretend we do for standards
+                // compatibility.
+                xfer.accept().ok();
+            },*/
+            _ => {
+                xfer.reject().ok();
+            }
+        };
+    }
+}*/