stateless scsi

automount works after reformat!
can unmount now
2025-07-30 14:59:53 -06:00 · 2025-07-29 14:52:50 -06:00 · 2025-07-29 13:49:58 -06:00 · 2025-07-29 13:21:06 -06:00 · 2025-07-29 01:02:54 -06:00 · 2025-07-28 12:57:50 -06:00
13 changed files with 1234 additions and 297 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12,6 +12,18 @@ dependencies = [
 "regex",
 ]

+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -42,7 +54,7 @@ version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891"
 dependencies = [
- "term 1.0.2",
+ "term 1.1.0",
 ]

 [[package]]
@@ -75,21 +87,6 @@ dependencies = [
 "rustc_version",
 ]

-[[package]]
-name = "bisync"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5020822f6d6f23196ccaf55e228db36f9de1cf788052b37992e17cbc96ec41a7"
-dependencies = [
- "bisync_macros",
-]
-
-[[package]]
-name = "bisync_macros"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d21f40d350a700f6aa107e45fb26448cf489d34794b2ba4522181dc9f1173af6"
-
 [[package]]
 name = "bit-set"
 version = "0.5.3"
@@ -126,6 +123,12 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719"

+[[package]]
+name = "bitfield"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d7e60934ceec538daadb9d8432424ed043a904d8e0243f3c6446bce549a46ac"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -138,6 +141,18 @@ version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"

+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -203,7 +218,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ec610d8f49840a5b376c69663b6369e71f4b34484b9b2eb29fb918d92516cb9"
 dependencies = [
 "bare-metal",
- "bitfield",
+ "bitfield 0.13.2",
 "embedded-hal 0.2.7",
 "volatile-register",
 ]
@@ -447,12 +462,13 @@ checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"

 [[package]]
 name = "embassy-embedded-hal"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41fea5ef5bed4d3468dfd44f5c9fa4cda8f54c86d4fb4ae683eacf9d39e2ea12"
+checksum = "8578db196d74db92efdd5ebc546736dac1685499ee245b22eff92fa5e4b57945"
 dependencies = [
 "embassy-futures",
- "embassy-sync 0.6.2",
+ "embassy-hal-internal 0.3.0",
+ "embassy-sync 0.7.0",
 "embassy-time",
 "embedded-hal 0.2.7",
 "embedded-hal 1.0.0",
@@ -505,6 +521,15 @@ dependencies = [
 "num-traits",
 ]

+[[package]]
+name = "embassy-hal-internal"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95285007a91b619dc9f26ea8f55452aa6c60f7115a4edc05085cd2bd3127cd7a"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "embassy-net-driver"
 version = "0.2.0"
@@ -513,13 +538,13 @@ checksum = "524eb3c489760508f71360112bca70f6e53173e6fe48fc5f0efd0f5ab217751d"

 [[package]]
 name = "embassy-net-driver-channel"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4818c32afec43e3cae234f324bad9a976c9aa7501022d26ff60a4017a1a006b7"
+checksum = "25a567ab50319d866ad5e6c583ed665ba9b07865389644d3d82e45bf1497c934"
 dependencies = [
 "embassy-futures",
 "embassy-net-driver",
- "embassy-sync 0.6.2",
+ "embassy-sync 0.7.0",
 ]

 [[package]]
@@ -536,7 +561,7 @@ dependencies = [
 "document-features",
 "embassy-embedded-hal",
 "embassy-futures",
- "embassy-hal-internal",
+ "embassy-hal-internal 0.2.0",
 "embassy-sync 0.6.2",
 "embassy-time",
 "embassy-usb-driver",
@@ -574,7 +599,7 @@ dependencies = [
 "document-features",
 "embassy-embedded-hal",
 "embassy-futures",
- "embassy-hal-internal",
+ "embassy-hal-internal 0.2.0",
 "embassy-sync 0.6.2",
 "embassy-time",
 "embassy-time-driver",
@@ -639,6 +664,7 @@ dependencies = [
 "defmt 0.3.100",
 "document-features",
 "embassy-time-driver",
+ "embassy-time-queue-utils",
 "embedded-hal 0.2.7",
 "embedded-hal 1.0.0",
 "embedded-hal-async",
@@ -665,12 +691,28 @@ dependencies = [
 ]

 [[package]]
-name = "embassy-usb-driver"
-version = "0.1.0"
+name = "embassy-usb"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc247028eae04174b6635104a35b1ed336aabef4654f5e87a8f32327d231970"
+checksum = "6e651b9b7b47b514e6e6d1940a6e2e300891a2c33641917130643602a0cb6386"
 dependencies = [
- "defmt 0.3.100",
+ "embassy-futures",
+ "embassy-net-driver-channel",
+ "embassy-sync 0.6.2",
+ "embassy-usb-driver",
+ "heapless",
+ "ssmarshal",
+ "usbd-hid",
+]
+
+[[package]]
+name = "embassy-usb-driver"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "340c5ce591ef58c6449e43f51d2c53efe1bf0bb6a40cbf80afa0d259c7d52c76"
+dependencies = [
+ "defmt 1.0.1",
+ "embedded-io-async",
 ]

 [[package]]
@@ -761,17 +803,14 @@ dependencies = [

 [[package]]
 name = "embedded-sdmmc"
-version = "0.8.0"
-source = "git+https://github.com/Be-ing/embedded-sdmmc-rs?branch=bisync#835b2e4f9d3482b6287f674d7ecf6ae5d0618c18"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce3c7f9ea039eeafc4a49597b7bd5ae3a1c8e51b2803a381cb0f29ce90fe1ec6"
 dependencies = [
- "bisync",
 "byteorder",
 "defmt 0.3.100",
- "embassy-futures",
 "embedded-hal 1.0.0",
- "embedded-hal-async",
 "embedded-io",
- "embedded-io-async",
 "heapless",
 ]

@@ -799,6 +838,12 @@ dependencies = [
 "log",
 ]

+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -844,6 +889,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -967,6 +1018,15 @@ dependencies = [
 "byteorder",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+dependencies = [
+ "ahash",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.15.4"
@@ -989,15 +1049,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"

-[[package]]
-name = "home"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
-dependencies = [
- "windows-sys",
-]
-
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -1006,12 +1057,12 @@ checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"

 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
 dependencies = [
 "equivalent",
- "hashbrown",
+ "hashbrown 0.15.4",
 ]

 [[package]]
@@ -1022,7 +1073,7 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
 "hermit-abi",
 "libc",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -1101,7 +1152,7 @@ dependencies = [
 "regex-syntax 0.8.5",
 "sha3",
 "string_cache",
- "term 1.0.2",
+ "term 1.1.0",
 "unicode-xid",
 "walkdir",
 ]
@@ -1288,7 +1339,7 @@ dependencies = [
 "libc",
 "redox_syscall",
 "smallvec",
- "windows-targets",
+ "windows-targets 0.52.6",
 ]

 [[package]]
@@ -1336,6 +1387,7 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 name = "picocalc-os-rs"
 version = "0.1.0"
 dependencies = [
+ "bitflags 2.9.1",
 "bt-hci",
 "cortex-m",
 "cortex-m-rt",
@@ -1349,15 +1401,20 @@ dependencies = [
 "embassy-rp 0.4.0",
 "embassy-sync 0.7.0",
 "embassy-time",
+ "embassy-usb",
 "embedded-graphics",
 "embedded-hal 0.2.7",
 "embedded-hal-async",
 "embedded-hal-bus",
 "embedded-sdmmc",
+ "heapless",
+ "num_enum 0.7.4",
 "panic-probe",
 "portable-atomic",
+ "spin",
 "st7365p-lcd",
 "static_cell",
+ "talc",
 "trouble-host",
 ]

@@ -1540,6 +1597,12 @@ dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
 [[package]]
 name = "rand_core"
 version = "0.6.4"
@@ -1603,9 +1666,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

 [[package]]
 name = "rgb"
-version = "0.8.50"
+version = "0.8.52"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
+checksum = "0c6a884d2998352bb4daf0183589aec883f16a6da1f4dde84d8e2e9a5409a1ce"
 dependencies = [
 "bytemuck",
 ]
@@ -1680,6 +1743,26 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"

+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.104",
+]
+
 [[package]]
 name = "sha2-const-stable"
 version = "0.1.0"
@@ -1727,12 +1810,34 @@ dependencies = [
 ]

 [[package]]
-name = "st7365p-lcd"
+name = "spin"
 version = "0.10.0"
-source = "git+https://github.com/legitcamper/st7365p-lcd-rs#d751e8d30f1a3f964ffe05e4bb16f82112fbefce"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591"
 dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "ssmarshal"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3e6ad23b128192ed337dfa4f1b8099ced0c2bf30d61e551b65fda5916dbb850"
+dependencies = [
+ "encode_unicode",
+ "serde",
+]
+
+[[package]]
+name = "st7365p-lcd"
+version = "0.11.0"
+source = "git+https://github.com/legitcamper/st7365p-lcd-rs?branch=async#87abf450404865dcb535292e9e1a6a2457fd4599"
+dependencies = [
+ "bitvec",
 "embedded-graphics-core",
 "embedded-hal 1.0.0",
+ "embedded-hal-async",
+ "heapless",
 "nb 1.1.0",
 ]

@@ -1791,6 +1896,21 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "talc"
+version = "4.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3ae828aa394de34c7de08f522d1b86bd1c182c668d27da69caadda00590f26d"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
 [[package]]
 name = "term"
 version = "0.7.0"
@@ -1804,12 +1924,11 @@ dependencies = [

 [[package]]
 name = "term"
-version = "1.0.2"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a984c8d058c627faaf5e8e2ed493fa3c51771889196de1016cf9c1c6e90d750"
+checksum = "a43bddab41f8626c7bdaab872bbba75f8df5847b516d77c569c746e2ae5eb746"
 dependencies = [
- "home",
- "windows-sys",
+ "windows-sys 0.60.2",
 ]

 [[package]]
@@ -1927,6 +2046,53 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

+[[package]]
+name = "usb-device"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98816b1accafbb09085168b90f27e93d790b4bfa19d883466b5e53315b5f06a6"
+dependencies = [
+ "heapless",
+ "portable-atomic",
+]
+
+[[package]]
+name = "usbd-hid"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6f291ab53d428685cc780f08a2eb9d5d6ff58622db2b36e239a4f715f1e184c"
+dependencies = [
+ "serde",
+ "ssmarshal",
+ "usb-device",
+ "usbd-hid-macros",
+]
+
+[[package]]
+name = "usbd-hid-descriptors"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee54712c5d778d2fb2da43b1ce5a7b5060886ef7b09891baeb4bf36910a3ed"
+dependencies = [
+ "bitfield 0.14.0",
+]
+
+[[package]]
+name = "usbd-hid-macros"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb573c76e7884035ac5e1ab4a81234c187a82b6100140af0ab45757650ccda38"
+dependencies = [
+ "byteorder",
+ "hashbrown 0.13.2",
+ "log",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 1.0.109",
+ "usbd-hid-descriptors",
+]
+
 [[package]]
 name = "uuid"
 version = "1.17.0"
@@ -2060,7 +2226,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@@ -2075,7 +2241,16 @@ version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.2",
 ]

 [[package]]
@@ -2084,14 +2259,30 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
+dependencies = [
+ "windows_aarch64_gnullvm 0.53.0",
+ "windows_aarch64_msvc 0.53.0",
+ "windows_i686_gnu 0.53.0",
+ "windows_i686_gnullvm 0.53.0",
+ "windows_i686_msvc 0.53.0",
+ "windows_x86_64_gnu 0.53.0",
+ "windows_x86_64_gnullvm 0.53.0",
+ "windows_x86_64_msvc 0.53.0",
 ]

 [[package]]
@@ -2100,48 +2291,105 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"

+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.8.26"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@ opt-level = "z"

 [features]
 default = ["rp235x", "defmt"]
-rp2040 = ["embassy-rp/rp2040"]
+# rp2040 = ["embassy-rp/rp2040"]
 rp235x = ["embassy-rp/rp235xb"]
 trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
 defmt = [
@@ -44,9 +44,10 @@ embassy-rp = { version = "0.4.0", features = [
  "binary-info",
 ] }
 embassy-futures = "0.1.1"
-embassy-time = "0.4.0"
-embassy-embedded-hal = "0.3.0"
-embassy-sync = { version = "0.7" }
+embassy-time = { version = "0.4.0", features = ["generic-queue-8"] }
+embassy-embedded-hal = "0.3.1"
+embassy-sync = "0.7"
+embassy-usb = "0.4.0"
 trouble-host = { version = "0.1", features = [
  "derive",
  "scan",
@@ -70,8 +71,12 @@ defmt = { version = "0.3", optional = true }
 defmt-rtt = "0.4.2"

 embedded-graphics = { version = "0.8.1" }
-embedded-sdmmc = { git = "https://github.com/Be-ing/embedded-sdmmc-rs", branch = "bisync", default-features = false }
-st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs" }
-# st7365p-lcd = { path = "../ST7365P-lcd-rs" }
+embedded-sdmmc = { version = "0.9", default-features = false }
+st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", branch = "async" }

 static_cell = "2.1.1"
+bitflags = "2.9.1"
+talc = "4.4.3"
+spin = "0.10.0"
+heapless = "0.8.0"
+num_enum = { version = "0.7.4", default-features = false }
--- a/memory.x
+++ b/memory.x
@@ -4,7 +4,7 @@ MEMORY {
     *
     * 2 MiB is a safe default here, although a Pico 2 has 4 MiB.
     */
-    FLASH : ORIGIN = 0x10000000, LENGTH = 2048K
+    FLASH : ORIGIN = 0x10000000, LENGTH = 4096K
    /*
     * RAM consists of 8 banks, SRAM0-SRAM7, with a striped mapping.
     * This is usually good for performance, as it distributes load on
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,21 +1,33 @@
+use core::sync::atomic::Ordering;
+
+use defmt::info;
 use embassy_rp::{
    gpio::{Level, Output},
    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Blocking, Spi},
+    spi::{Async, Spi},
 };
-use embassy_time::{Delay, Timer};
+use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
+use embassy_time::{Delay, Instant, Timer};
 use embedded_graphics::{
    Drawable,
-    pixelcolor::{BinaryColor, Rgb555, Rgb565},
-    prelude::{Point, Primitive, RgbColor, Size},
-    primitives::{PrimitiveStyle, Rectangle, Triangle},
+    draw_target::DrawTarget,
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::{Dimensions, Point, RgbColor, Size},
+    primitives::Rectangle,
+    text::{Alignment, Text},
 };
 use embedded_hal_bus::spi::ExclusiveDevice;
-use st7365p_lcd::{Orientation, ST7365P};
+use portable_atomic::AtomicBool;
+use st7365p_lcd::{FrameBuffer, ST7365P};

-#[embassy_executor::task]
-pub async fn display_task(
-    spi: Spi<'static, SPI1, Blocking>,
+const SCREEN_WIDTH: usize = 320;
+const SCREEN_HEIGHT: usize = 320;
+
+pub static DISPLAY_SIGNAL: Signal<ThreadModeRawMutex, ()> = Signal::new();
+
+pub async fn display_handler(
+    spi: Spi<'static, SPI1, Async>,
    cs: PIN_13,
    data: PIN_14,
    reset: PIN_15,
@@ -27,20 +39,30 @@ pub async fn display_task(
        Some(Output::new(reset, Level::High)),
        false,
        true,
-        320,
-        320,
+        Delay,
    );
-    display.init(&mut Delay).unwrap();
-    display.set_orientation(&Orientation::Landscape).unwrap();
+    let mut framebuffer: FrameBuffer<
+        SCREEN_WIDTH,
+        SCREEN_HEIGHT,
+        { SCREEN_WIDTH * SCREEN_HEIGHT },
+    > = FrameBuffer::new();
+    display.init().await.unwrap();
+    display.set_custom_orientation(0x40).await.unwrap();
+    framebuffer.draw(&mut display).await.unwrap();
+    display.set_on().await.unwrap();

-    let thin_stroke = PrimitiveStyle::with_stroke(Rgb565::RED, 20);
-
-    Rectangle::new(Point::new(10, 10), Size::new(100, 100))
-        .into_styled(thin_stroke)
-        .draw(&mut display)
-        .unwrap();
+    DISPLAY_SIGNAL.signal(());

    loop {
-        Timer::after_millis(500).await;
+        DISPLAY_SIGNAL.wait().await;
+
+        // text.draw(&mut framebuffer).unwrap();
+
+        let start = Instant::now();
+        framebuffer
+            .partial_draw_batched(&mut display)
+            .await
+            .unwrap();
+        info!("Elapsed {}ms", start.elapsed().as_millis());
    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,62 +1,88 @@
 #![feature(impl_trait_in_assoc_type)]
+#![feature(ascii_char)]
 #![no_std]
 #![no_main]

-#[cfg(feature = "defmt")]
-use defmt::*;
+use crate::{
+    display::DISPLAY_SIGNAL,
+    peripherals::keyboard::{KeyCode, KeyState, read_keyboard_fifo},
+    storage::SdCard,
+    usb::usb_handler,
+};
+
 use {defmt_rtt as _, panic_probe as _};

+use core::cell::RefCell;
 use embassy_executor::Spawner;
-use embassy_rp::peripherals::I2C1;
-use embassy_rp::spi::Spi;
+use embassy_futures::join::join;
 use embassy_rp::{
-    bind_interrupts,
-    gpio::{Level, Output},
-    i2c,
-    i2c::I2c,
-    spi,
+    gpio::{Input, Level, Output, Pull},
+    peripherals::{I2C1, USB},
+    spi::Spi,
+    usb as embassy_rp_usb,
 };
-use embassy_sync::blocking_mutex::raw::NoopRawMutex;
-use embassy_sync::channel::Channel;
-use embassy_time::Timer;
+use embassy_rp::{i2c, i2c::I2c, spi};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::{Delay, Timer};
+use embedded_graphics::primitives::Rectangle;
 use embedded_hal_bus::spi::ExclusiveDevice;
-use embedded_sdmmc::asynchronous::{File, SdCard, ShortFileName, VolumeIdx, VolumeManager};
-use static_cell::StaticCell;
+use embedded_sdmmc::SdCard as SdmmcSdCard;
+use heapless::String;

 mod peripherals;
-use peripherals::{keyboard::KeyEvent, peripherals_task};
+use peripherals::conf_peripherals;
 mod display;
-use display::display_task;
+use display::display_handler;
+mod scsi;
+mod storage;
+mod usb;
+mod utils;

 embassy_rp::bind_interrupts!(struct Irqs {
    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+    USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
 });

 #[embassy_executor::main]
-async fn main(spawner: Spawner) {
+async fn main(_spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

-    static KEYBOARD_EVENTS: StaticCell<Channel<NoopRawMutex, KeyEvent, 10>> = StaticCell::new();
-    let keyboard_events = KEYBOARD_EVENTS.init(Channel::new());
-
-    // configure keyboard event handler
-    let config = i2c::Config::default();
+    // MCU i2c bus for peripherals
+    let mut config = i2c::Config::default();
+    config.frequency = 400_000;
    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
-    spawner
-        .spawn(peripherals_task(i2c1, keyboard_events.sender()))
-        .unwrap();
+    conf_peripherals(i2c1).await;

-    // configure display handler
+    // SPI1 bus display
    let mut config = spi::Config::default();
    config.frequency = 16_000_000;
-    let spi1 = spi::Spi::new_blocking(p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, config);
-    spawner
-        .spawn(display_task(spi1, p.PIN_13, p.PIN_14, p.PIN_15))
-        .unwrap();
+    let spi1 = spi::Spi::new(
+        p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, p.DMA_CH0, p.DMA_CH1, config,
+    );

-    let receiver = keyboard_events.receiver();
-    loop {
-        let key = receiver.receive().await;
-        info!("got key: {}", key.key as u8);
-    }
+    let usb = embassy_rp_usb::Driver::new(p.USB, Irqs);
+
+    let sdcard = {
+        let mut config = spi::Config::default();
+        config.frequency = 400_000;
+        let spi = Spi::new_blocking(
+            p.SPI0,
+            p.PIN_18, // clk
+            p.PIN_19, // mosi
+            p.PIN_16, // miso
+            config.clone(),
+        );
+        let cs = Output::new(p.PIN_17, Level::High);
+        let det = Input::new(p.PIN_22, Pull::None);
+
+        let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
+        let sdcard = SdmmcSdCard::new(device, Delay);
+
+        config.frequency = 32_000_000;
+        sdcard.spi(|dev| dev.bus_mut().set_config(&config));
+        SdCard::new(sdcard, det)
+    };
+
+    usb_handler(usb, sdcard).await;
 }
--- a/src/peripherals/battery.rs
+++ b/src/peripherals/battery.rs
@@ -1,20 +0,0 @@
-use embassy_rp::{
-    i2c::{Async, I2c},
-    peripherals::I2C1,
-};
-use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex, watch::Watch};
-
-const REG_ID_BAT: u8 = 0x0b;
-
-pub static BATTERY_PCT: Watch<CriticalSectionRawMutex, u8, 1> = Watch::new();
-
-pub async fn read_battery(i2c: &mut I2c<'static, I2C1, Async>) {
-    let mut buf = [0_u8; 2];
-    i2c.write_read_async(super::MCU_ADDR, [REG_ID_BAT], &mut buf)
-        .await
-        .unwrap();
-
-    if buf[0] == REG_ID_BAT {
-        BATTERY_PCT.sender().send(buf[0]);
-    }
-}
--- a/src/peripherals/keyboard.rs
+++ b/src/peripherals/keyboard.rs
@@ -1,11 +1,5 @@
-use embassy_rp::{
-    i2c::{Async, I2c},
-    peripherals::I2C1,
-};
-use embassy_sync::{
-    blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex},
-    channel::Sender,
-};
+
+use crate::peripherals::PERIPHERAL_BUS;

 const REG_ID_KEY: u8 = 0x04;
 const REG_ID_FIF: u8 = 0x09;
@@ -14,10 +8,10 @@ const KEY_CAPSLOCK: u8 = 1 << 5;
 const KEY_NUMLOCK: u8 = 1 << 6;
 const KEY_COUNT_MASK: u8 = 0x1F; // 0x1F == 31

-pub async fn read_keyboard_fifo(
-    i2c: &mut I2c<'static, I2C1, Async>,
-    channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>,
-) {
+pub async fn read_keyboard_fifo() -> Option<KeyEvent> {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
    let mut key_status = [0_u8; 1];

    if i2c
@@ -25,9 +19,8 @@ pub async fn read_keyboard_fifo(
        .await
        .is_ok()
    {
-        // TODO: use caps & num lock
-        let caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
-        let num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
+        let _caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
+        let _num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
        let fifo_count = key_status[0] & KEY_COUNT_MASK;

        if fifo_count >= 1 {
@@ -38,78 +31,98 @@ pub async fn read_keyboard_fifo(
                .await
                .is_ok()
            {
-                if let Ok(state) = KeyState::try_from(event[0]) {
-                    if let Ok(key) = KeyCode::try_from(event[1]) {
-                        let _ = channel.try_send(KeyEvent { key, state });
-                    }
-                }
+                return Some(KeyEvent {
+                    state: KeyState::from(event[0]),
+                    key: KeyCode::from(event[1]),
+                    mods: Modifiers::NONE,
+                });
            }
        }
    }
+    None
 }

+const REG_ID_DEB: u8 = 0x06;
+const REG_ID_FRQ: u8 = 0x07;
+
+pub async fn configure_keyboard(debounce: u8, poll_freq: u8) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let _ = i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_DEB], &mut [debounce])
+        .await;
+
+    let _ = i2c
+        .write_read_async(super::MCU_ADDR, [REG_ID_FRQ], &mut [poll_freq])
+        .await;
+}
+
+bitflags::bitflags! {
+    #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
+    pub struct Modifiers: u8 {
+        const NONE = 0;
+        const CTRL = 1;
+        const ALT = 2;
+        const LSHIFT = 4;
+        const RSHIFT = 8;
+        const SYM = 16;
+    }
+}
+
+#[derive(Debug)]
 pub struct KeyEvent {
    pub key: KeyCode,
    pub state: KeyState,
+    pub mods: Modifiers,
 }

+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum KeyState {
    Idle = 0,
-    Pressed,
-    Hold,
-    Released,
+    Pressed = 1,
+    Hold = 2,
+    Released = 3,
 }

-impl TryFrom<u8> for KeyState {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
+impl From<u8> for KeyState {
+    fn from(value: u8) -> Self {
        match value {
-            0 => Ok(KeyState::Idle),
-            1 => Ok(KeyState::Pressed),
-            2 => Ok(KeyState::Hold),
-            3 => Ok(KeyState::Released),
-            _ => Err(()),
+            1 => KeyState::Pressed,
+            2 => KeyState::Hold,
+            3 => KeyState::Released,
+            0 | _ => KeyState::Idle,
        }
    }
 }

+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
 pub enum KeyCode {
-    // Joystick
    JoyUp = 0x01,
    JoyDown = 0x02,
    JoyLeft = 0x03,
    JoyRight = 0x04,
    JoyCenter = 0x05,
-
-    // Buttons
    BtnLeft1 = 0x06,
    BtnRight1 = 0x07,
    BtnLeft2 = 0x11,
    BtnRight2 = 0x12,
-
-    // Basic Keys
    Backspace = 0x08,
    Tab = 0x09,
    Enter = 0x0A,
-
-    // Modifiers
    ModAlt = 0xA1,
    ModShiftLeft = 0xA2,
    ModShiftRight = 0xA3,
    ModSym = 0xA4,
    ModCtrl = 0xA5,
-
-    // Navigation
    Esc = 0xB1,
    Left = 0xB4,
    Up = 0xB5,
    Down = 0xB6,
    Right = 0xB7,
-
-    // Specials
    Break = 0xD0,
    Insert = 0xD1,
    Home = 0xD2,
@@ -117,11 +130,7 @@ pub enum KeyCode {
    End = 0xD5,
    PageUp = 0xD6,
    PageDown = 0xD7,
-
-    // Locks
    CapsLock = 0xC1,
-
-    // Function keys
    F1 = 0x81,
    F2 = 0x82,
    F3 = 0x83,
@@ -132,55 +141,57 @@ pub enum KeyCode {
    F8 = 0x88,
    F9 = 0x89,
    F10 = 0x90,
+    Char(char),
+    Unknown(u8),
 }

-impl TryFrom<u8> for KeyCode {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        use KeyCode::*;
+impl From<u8> for KeyCode {
+    fn from(value: u8) -> Self {
        match value {
-            0x01 => Ok(JoyUp),
-            0x02 => Ok(JoyDown),
-            0x03 => Ok(JoyLeft),
-            0x04 => Ok(JoyRight),
-            0x05 => Ok(JoyCenter),
-            0x06 => Ok(BtnLeft1),
-            0x07 => Ok(BtnRight1),
-            0x08 => Ok(Backspace),
-            0x09 => Ok(Tab),
-            0x0A => Ok(Enter),
-            0x11 => Ok(BtnLeft2),
-            0x12 => Ok(BtnRight2),
-            0xA1 => Ok(ModAlt),
-            0xA2 => Ok(ModShiftLeft),
-            0xA3 => Ok(ModShiftRight),
-            0xA4 => Ok(ModSym),
-            0xA5 => Ok(ModCtrl),
-            0xB1 => Ok(Esc),
-            0xB4 => Ok(Left),
-            0xB5 => Ok(Up),
-            0xB6 => Ok(Down),
-            0xB7 => Ok(Right),
-            0xC1 => Ok(CapsLock),
-            0xD0 => Ok(Break),
-            0xD1 => Ok(Insert),
-            0xD2 => Ok(Home),
-            0xD4 => Ok(Del),
-            0xD5 => Ok(End),
-            0xD6 => Ok(PageUp),
-            0xD7 => Ok(PageDown),
-            0x81 => Ok(F1),
-            0x82 => Ok(F2),
-            0x83 => Ok(F3),
-            0x84 => Ok(F4),
-            0x85 => Ok(F5),
-            0x86 => Ok(F6),
-            0x87 => Ok(F7),
-            0x88 => Ok(F8),
-            0x89 => Ok(F9),
-            0x90 => Ok(F10),
-            _ => Err(()),
+            0x01 => Self::JoyUp,
+            0x02 => Self::JoyDown,
+            0x03 => Self::JoyLeft,
+            0x04 => Self::JoyRight,
+            0x05 => Self::JoyCenter,
+            0x06 => Self::BtnLeft1,
+            0x07 => Self::BtnRight1,
+            0x08 => Self::Backspace,
+            0x09 => Self::Tab,
+            0x0A => Self::Enter,
+            0x11 => Self::BtnLeft2,
+            0x12 => Self::BtnRight2,
+            0xA1 => Self::ModAlt,
+            0xA2 => Self::ModShiftLeft,
+            0xA3 => Self::ModShiftRight,
+            0xA4 => Self::ModSym,
+            0xA5 => Self::ModCtrl,
+            0xB1 => Self::Esc,
+            0xB4 => Self::Left,
+            0xB5 => Self::Up,
+            0xB6 => Self::Down,
+            0xB7 => Self::Right,
+            0xC1 => Self::CapsLock,
+            0xD0 => Self::Break,
+            0xD1 => Self::Insert,
+            0xD2 => Self::Home,
+            0xD4 => Self::Del,
+            0xD5 => Self::End,
+            0xD6 => Self::PageUp,
+            0xD7 => Self::PageDown,
+            0x81 => Self::F1,
+            0x82 => Self::F2,
+            0x83 => Self::F3,
+            0x84 => Self::F4,
+            0x85 => Self::F5,
+            0x86 => Self::F6,
+            0x87 => Self::F7,
+            0x88 => Self::F8,
+            0x89 => Self::F9,
+            0x90 => Self::F10,
+            _ => match char::from_u32(value as u32) {
+                Some(c) => Self::Char(c),
+                None => Self::Unknown(value),
+            },
        }
    }
 }
--- a/src/peripherals/mod.rs
+++ b/src/peripherals/mod.rs
@@ -1,72 +1,98 @@
 //! handles all the peripherals exposed by mcu through i2c (keyboard & battery registers)
 //!

-use embassy_futures::join::join;
 use embassy_rp::{
    i2c::{Async, I2c},
    peripherals::I2C1,
 };
-use embassy_sync::{blocking_mutex::raw::NoopRawMutex, channel::Sender, mutex::Mutex};
-use embassy_time::{Duration, Timer};
-
-#[cfg(feature = "defmt")]
-use defmt::info;
+use embassy_sync::{blocking_mutex::raw::NoopRawMutex, lazy_lock::LazyLock, mutex::Mutex};
+use embassy_time::Timer;

 pub mod keyboard;
-use keyboard::{KeyCode, KeyEvent, KeyState};
-mod battery;
-pub use battery::BATTERY_PCT;
-use battery::read_battery;

-use crate::peripherals::keyboard::read_keyboard_fifo;
+use crate::peripherals::keyboard::{configure_keyboard, read_keyboard_fifo};

 const MCU_ADDR: u8 = 0x1F;

-const REG_ID_VER: u8 = 0x01;
-const REG_ID_CFG: u8 = 0x02;
-const REG_ID_INT: u8 = 0x03;
-const REG_ID_KEY: u8 = 0x04;
-const REG_ID_BKL: u8 = 0x05;
-const REG_ID_DEB: u8 = 0x06;
-const REG_ID_FRQ: u8 = 0x07;
-const REG_ID_RST: u8 = 0x08;
-const REG_ID_FIF: u8 = 0x09;
-const REG_ID_BK2: u8 = 0x0A;
-const REG_ID_C64_MTX: u8 = 0x0c;
-const REG_ID_C64_JS: u8 = 0x0d;
+type I2CBUS = I2c<'static, I2C1, Async>;
+pub static PERIPHERAL_BUS: LazyLock<Mutex<NoopRawMutex, Option<I2CBUS>>> =
+    LazyLock::new(|| Mutex::new(None));

-#[embassy_executor::task]
-pub async fn peripherals_task(
-    mut i2c: I2c<'static, I2C1, Async>,
-    mut keyboard_channel: Sender<'static, NoopRawMutex, KeyEvent, 10>,
-) {
+const REG_ID_VER: u8 = 0x01;
+const REG_ID_RST: u8 = 0x08;
+const REG_ID_INT: u8 = 0x03;
+
+pub async fn conf_peripherals(i2c: I2CBUS) {
    Timer::after(embassy_time::Duration::from_millis(100)).await;

-    #[cfg(feature = "defmt")]
-    {
-        let mut ver = [0_u8; 1];
-        if let Ok(firm_ver) = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await {
-            info!("stm32 firmware version: v{}", ver[0]);
-        }
-    }
+    PERIPHERAL_BUS.get().lock().await.replace(i2c);

-    let i2c: Mutex<NoopRawMutex, I2c<'static, I2C1, Async>> = Mutex::new(i2c);
+    configure_keyboard(200, 100).await;

-    join(
-        async {
-            loop {
-                Timer::after(Duration::from_secs(10)).await;
-                let mut guard = i2c.lock().await;
-                read_battery(&mut guard).await;
-            }
-        },
-        async {
-            loop {
-                Timer::after(Duration::from_millis(50)).await;
-                let mut guard = i2c.lock().await;
-                read_keyboard_fifo(&mut guard, &mut keyboard_channel).await;
-            }
-        },
-    )
-    .await;
+    // empty keys
+    while read_keyboard_fifo().await.is_some() {}
+
+    // set_lcd_backlight(255).await;
+    set_key_backlight(0).await;
+}
+
+/// return major & minor mcu version
+async fn get_version() -> (u8, u8) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut ver = [0_u8; 1];
+    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await;
+
+    (ver[0] >> 4, ver[0] & 0x0F)
+}
+
+const REG_ID_BKL: u8 = 0x05;
+pub async fn set_lcd_backlight(brightness: u8) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let _ = i2c
+        .write_read_async(MCU_ADDR, [REG_ID_BKL], &mut [brightness])
+        .await;
+}
+pub async fn get_lcd_backlight() -> u8 {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut buf = [0_u8; 2];
+
+    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BKL], &mut buf).await;
+    buf[1]
+}
+
+const REG_ID_BK2: u8 = 0x0A;
+pub async fn set_key_backlight(brightness: u8) {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let _ = i2c
+        .write_read_async(MCU_ADDR, [REG_ID_BK2], &mut [brightness])
+        .await;
+}
+pub async fn get_key_backlight() -> u8 {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut buf = [0_u8; 2];
+
+    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BK2], &mut buf).await;
+    buf[1]
+}
+
+const REG_ID_BAT: u8 = 0x0b;
+pub async fn get_battery() -> u8 {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
+    let i2c = i2c.as_mut().unwrap();
+
+    let mut buf = [0_u8; 2];
+
+    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_BAT], &mut buf).await;
+
+    buf[1]
 }
--- a/src/scsi/mod.rs
+++ b/src/scsi/mod.rs
@@ -0,0 +1,308 @@
+use crate::format;
+use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
+use embassy_usb::types::StringIndex;
+use embassy_usb::{Builder, Config};
+use embedded_sdmmc::{Block, BlockIdx};
+use heapless::Vec;
+
+mod scsi_types;
+use scsi_types::*;
+
+use crate::storage::SdCard;
+
+const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
+
+pub struct MassStorageClass<'d, D: Driver<'d>> {
+    sdcard: SdCard,
+    bulk_out: D::EndpointOut,
+    bulk_in: D::EndpointIn,
+}
+
+impl<'d, D: Driver<'d>> MassStorageClass<'d, D> {
+    pub fn new(builder: &mut Builder<'d, D>, sdcard: SdCard) -> Self {
+        let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
+        let mut interface = function.interface();
+        let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
+
+        let bulk_out = alt.endpoint_bulk_out(BULK_ENDPOINT_PACKET_SIZE as u16);
+        let bulk_in = alt.endpoint_bulk_in(BULK_ENDPOINT_PACKET_SIZE as u16);
+
+        Self {
+            bulk_out,
+            bulk_in,
+            sdcard,
+        }
+    }
+
+    pub async fn poll(&mut self) {
+        loop {
+            let mut cbw_buf = [0u8; 31];
+            if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
+                if n == 31 {
+                    if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
+                        // TODO: validate cbw
+                        if self.handle_command(&cbw.CBWCB).await.is_ok() {
+                            self.send_csw_success(cbw.dCBWTag).await
+                        } else {
+                            self.send_csw_fail(cbw.dCBWTag).await
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    async fn handle_command(&mut self, cbw: &[u8]) -> Result<(), ()> {
+        let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
+        let mut block = [Block::new(); 1];
+
+        match parse_cb(cbw) {
+            ScsiCommand::Unknown => {
+                #[cfg(feature = "defmt")]
+                defmt::warn!("Got unexpected scsi command: {}", cbw);
+                Err(())
+            }
+            ScsiCommand::Inquiry {
+                evpd,
+                page_code,
+                alloc_len,
+            } => {
+                if !evpd {
+                    response.push(0x00).map_err(|_| ())?; // Direct-access block device
+                    response.push(0x80).map_err(|_| ())?; // Removable
+                    response.push(0x05).map_err(|_| ())?; // SPC-3 compliance
+                    response.push(0x02).map_err(|_| ())?; // Response data format
+                    response.push(0x00).map_err(|_| ())?; // Additional length - edited later
+                    response.push(0x00).map_err(|_| ())?; // FLAGS
+                    response.push(0x00).map_err(|_| ())?; // FLAGS
+                    response.push(0).map_err(|_| ())?; // FLAGS
+                    assert!(response.len() == 8);
+
+                    let vendor = b"LEGTCMPR";
+                    assert!(vendor.len() == 8);
+                    response.extend_from_slice(vendor)?;
+
+                    let product = b"Pico Calc Sdcard";
+                    assert!(product.len() == 16);
+                    response.extend_from_slice(product)?;
+
+                    let version = b"1.00";
+                    assert!(version.len() == 4);
+                    response.extend_from_slice(version)?; // 4-byte firmware version
+
+                    let addl_len = response.len() - 5;
+                    response[4] = addl_len as u8;
+                    assert!(response.len() == 36);
+                } else {
+                    match page_code {
+                        0x00 => {
+                            response
+                                .extend_from_slice(&[
+                                    0x00, // Peripheral Qualifier + Peripheral Device Type (0x00 = Direct-access block device)
+                                    0x00, // Page Code (same as requested: 0x00)
+                                    0x00, 0x03, // Page Length: 3 bytes follow
+                                    0x00, // Supported VPD Page: 0x00 (this one — the "Supported VPD Pages" page itself)
+                                    0x80, // Supported VPD Page: 0x80 (Unit Serial Number)
+                                    0x83, // Supported VPD Page: 0x83 (Device Identification)
+                                ])
+                                .map_err(|_| ())?
+                        }
+                        0x80 => {
+                            let serial = b"Pico Calc";
+                            response.extend_from_slice(&[
+                                0x00, // Peripheral Qualifier & Device Type
+                                0x80, // Page Code = 0x80 (Unit Serial Number)
+                                0x00, // Reserved
+                                serial.len() as u8,
+                            ])?;
+                            response.extend_from_slice(serial)?;
+                        }
+                        0x83 => {
+                            let id = b"SdCard";
+                            response.extend_from_slice(&[
+                                0x00,
+                                0x83, // Page code
+                                0x00,
+                                (4 + id.len()) as u8, // Length
+                                0x02,                 // ASCII identifier
+                                0x01,                 // Identifier type
+                                0x00,                 // Reserved
+                                id.len() as u8,
+                            ])?;
+                            response.extend_from_slice(id)?;
+                        }
+                        _ => (),
+                    }
+                };
+
+                let len = core::cmp::min(alloc_len as usize, response.len());
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::TestUnitReady => {
+                if self.sdcard.is_attached() {
+                    Ok(())
+                } else {
+                    Err(())
+                }
+            }
+            ScsiCommand::RequestSense { desc, alloc_len } => Ok(()),
+            ScsiCommand::ModeSense6 {
+                dbd,
+                page_control,
+                page_code,
+                subpage_code,
+                alloc_len,
+            } => {
+                // DBD=0, no block descriptors; total length = 4
+                let response = [
+                    0x03, // Mode data length (excluding this byte): 3
+                    0x00, // Medium type
+                    0x00, // Device-specific parameter
+                    0x00, // Block descriptor length = 0 (DBD = 1)
+                ];
+
+                let len = alloc_len.min(response.len() as u8) as usize;
+
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::ModeSense10 {
+                dbd,
+                page_control,
+                page_code,
+                subpage_code,
+                alloc_len,
+            } => {
+                let response = [
+                    0x00, 0x06, // Mode data length = 6
+                    0x00, // Medium type
+                    0x00, // Device-specific parameter
+                    0x00, 0x00, // Reserved
+                    0x00, 0x00, // Block descriptor length = 0
+                ];
+
+                let len = alloc_len.min(response.len() as u16) as usize;
+
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::ReadCapacity10 => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.sdcard.size() / block_size;
+
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+
+                response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
+
+                self.bulk_in.write(&response).await.map_err(|_| ())
+            }
+            ScsiCommand::ReadCapacity16 { alloc_len } => {
+                let block_size = SdCard::BLOCK_SIZE as u64;
+                let total_blocks = self.sdcard.size() / block_size;
+
+                let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
+
+                response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
+                response.extend_from_slice(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
+                response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
+
+                let len = alloc_len.min(response.len() as u32) as usize;
+                self.bulk_in.write(&response[..len]).await.map_err(|_| ())
+            }
+            ScsiCommand::Read { lba, len } => {
+                for i in 0..len {
+                    let block_idx = BlockIdx(lba as u32 + i as u32);
+                    self.sdcard.read_blocks(&mut block, block_idx)?;
+                    for chunk in block[0].contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
+                        self.bulk_in.write(chunk).await.map_err(|_| ())?;
+                    }
+                }
+                Ok(())
+            }
+            ScsiCommand::Write { lba, len } => {
+                for i in 0..len {
+                    let block_idx = BlockIdx(lba as u32 + i as u32);
+                    for chunk in block[0]
+                        .contents
+                        .chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
+                    {
+                        self.bulk_out.read(chunk).await.map_err(|_| ())?;
+                    }
+                    self.sdcard.write_blocks(&mut block, block_idx)?;
+                }
+                Ok(())
+            }
+            ScsiCommand::ReadFormatCapacities { alloc_len } => {
+                let block_size = SdCard::BLOCK_SIZE as u32;
+                let num_blocks = (self.sdcard.size() / block_size as u64) as u32;
+
+                let mut response = [0u8; 12];
+
+                // Capacity List Length (8 bytes follows)
+                response[3] = 8;
+
+                // Descriptor
+                response[4..8].copy_from_slice(&num_blocks.to_be_bytes());
+                response[8] = 0x03; // formatted media
+                response[9..12].copy_from_slice(&block_size.to_be_bytes()[1..4]); // only 3 bytes
+
+                let response_len = alloc_len.min(response.len() as u16) as usize;
+                self.bulk_in
+                    .write(&response[..response_len])
+                    .await
+                    .map_err(|_| ())
+            }
+            ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
+            ScsiCommand::StartStopUnit { start, load_eject } => Ok(()),
+        }
+    }
+
+    pub async fn send_csw_success(&mut self, tag: u32) {
+        self.send_csw(tag, 0x00, 0).await;
+    }
+
+    pub async fn send_csw_fail(&mut self, tag: u32) {
+        defmt::error!("Command Failed");
+        self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
+    }
+
+    pub async fn send_csw(&mut self, tag: u32, status: u8, residue: u32) {
+        let mut csw = [0u8; 13];
+        csw[0..4].copy_from_slice(&0x53425355u32.to_le_bytes()); // Signature "USBS"
+        csw[4..8].copy_from_slice(&tag.to_le_bytes());
+        csw[8..12].copy_from_slice(&residue.to_le_bytes());
+        csw[12] = status;
+        let _ = self.bulk_in.write(&csw).await;
+    }
+}
+
+#[repr(C, packed)]
+struct CommandBlockWrapper {
+    dCBWSignature: u32,
+    dCBWTag: u32,
+    dCBWDataTransferLength: u32,
+    bmCBWFlags: u8,
+    bCBWLUN: u8,
+    bCBWCBLength: u8,
+    CBWCB: [u8; 16],
+}
+
+impl CommandBlockWrapper {
+    fn parse(buf: &[u8]) -> Option<Self> {
+        if buf.len() < 31 {
+            return None;
+        }
+        let dCBWSignature = u32::from_le_bytes(buf[0..4].try_into().ok()?);
+        if dCBWSignature != 0x43425355 {
+            return None; // invalid signature
+        }
+        Some(Self {
+            dCBWSignature,
+            dCBWTag: u32::from_le_bytes(buf[4..8].try_into().ok()?),
+            dCBWDataTransferLength: u32::from_le_bytes(buf[8..12].try_into().ok()?),
+            bmCBWFlags: buf[12],
+            bCBWLUN: buf[13],
+            bCBWCBLength: buf[14],
+            CBWCB: buf[15..31].try_into().ok()?,
+        })
+    }
+}
--- a/src/scsi/scsi_types.rs
+++ b/src/scsi/scsi_types.rs
@@ -0,0 +1,164 @@
+use num_enum::TryFromPrimitive;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ScsiError {
+    NotReady,
+}
+
+/// THE CODE BELOW ORIGINATES FROM: https://github.com/apohrebniak/usbd-storage/blob/master/usbd-storage/src/subclass/scsi.rs
+
+/// SCSI device subclass code
+pub const SUBCLASS_SCSI: u8 = 0x06; // SCSI Transparent command set
+
+/* SCSI codes */
+
+/* SPC */
+const TEST_UNIT_READY: u8 = 0x00;
+const REQUEST_SENSE: u8 = 0x03;
+const INQUIRY: u8 = 0x12;
+const MODE_SENSE_6: u8 = 0x1A;
+const MODE_SENSE_10: u8 = 0x5A;
+
+/* SBC */
+const READ_10: u8 = 0x28;
+const READ_16: u8 = 0x88;
+const READ_CAPACITY_10: u8 = 0x25;
+const READ_CAPACITY_16: u8 = 0x9E;
+const WRITE_10: u8 = 0x2A;
+
+/* MMC */
+const READ_FORMAT_CAPACITIES: u8 = 0x23;
+
+const PREVENT_ALLOW_MEDIUM_REMOVAL: u8 = 0x1E;
+const START_STOP_UNIT: u8 = 0x1B;
+
+/// SCSI command
+///
+/// Refer to specifications (SPC,SAM,SBC,MMC,etc.)
+#[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum ScsiCommand {
+    Unknown,
+
+    /* SPC */
+    Inquiry {
+        evpd: bool,
+        page_code: u8,
+        alloc_len: u16,
+    },
+    TestUnitReady,
+    RequestSense {
+        desc: bool,
+        alloc_len: u8,
+    },
+    ModeSense6 {
+        dbd: bool,
+        page_control: PageControl,
+        page_code: u8,
+        subpage_code: u8,
+        alloc_len: u8,
+    },
+    ModeSense10 {
+        dbd: bool,
+        page_control: PageControl,
+        page_code: u8,
+        subpage_code: u8,
+        alloc_len: u16,
+    },
+
+    /* SBC */
+    ReadCapacity10,
+    ReadCapacity16 {
+        alloc_len: u32,
+    },
+    Read {
+        lba: u64,
+        len: u64,
+    },
+    Write {
+        lba: u64,
+        len: u64,
+    },
+
+    /* MMC */
+    ReadFormatCapacities {
+        alloc_len: u16,
+    },
+
+    PreventAllowMediumRemoval {
+        prevent: bool,
+    },
+
+    StartStopUnit {
+        start: bool,
+        load_eject: bool,
+    },
+}
+
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, TryFromPrimitive)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum PageControl {
+    CurrentValues = 0b00,
+    ChangeableValues = 0b01,
+    DefaultValues = 0b10,
+    SavedValues = 0b11,
+}
+
+#[allow(dead_code)]
+pub fn parse_cb(cb: &[u8]) -> ScsiCommand {
+    match cb[0] {
+        TEST_UNIT_READY => ScsiCommand::TestUnitReady,
+        INQUIRY => ScsiCommand::Inquiry {
+            evpd: (cb[1] & 0b00000001) != 0,
+            page_code: cb[2],
+            alloc_len: u16::from_be_bytes([cb[3], cb[4]]),
+        },
+        REQUEST_SENSE => ScsiCommand::RequestSense {
+            desc: (cb[1] & 0b00000001) != 0,
+            alloc_len: cb[4],
+        },
+        READ_CAPACITY_10 => ScsiCommand::ReadCapacity10,
+        READ_CAPACITY_16 => ScsiCommand::ReadCapacity16 {
+            alloc_len: u32::from_be_bytes([cb[10], cb[11], cb[12], cb[13]]),
+        },
+        READ_10 => ScsiCommand::Read {
+            lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
+            len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
+        },
+        READ_16 => ScsiCommand::Read {
+            lba: u64::from_be_bytes((&cb[2..10]).try_into().unwrap()),
+            len: u32::from_be_bytes((&cb[10..14]).try_into().unwrap()) as u64,
+        },
+        WRITE_10 => ScsiCommand::Write {
+            lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
+            len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
+        },
+        MODE_SENSE_6 => ScsiCommand::ModeSense6 {
+            dbd: (cb[1] & 0b00001000) != 0,
+            page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
+            page_code: cb[2] & 0b00111111,
+            subpage_code: cb[3],
+            alloc_len: cb[4],
+        },
+        MODE_SENSE_10 => ScsiCommand::ModeSense10 {
+            dbd: (cb[1] & 0b00001000) != 0,
+            page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
+            page_code: cb[2] & 0b00111111,
+            subpage_code: cb[3],
+            alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
+        },
+        READ_FORMAT_CAPACITIES => ScsiCommand::ReadFormatCapacities {
+            alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
+        },
+        PREVENT_ALLOW_MEDIUM_REMOVAL => ScsiCommand::PreventAllowMediumRemoval {
+            prevent: (cb[1] & 0b00000001) != 0,
+        },
+        START_STOP_UNIT => ScsiCommand::StartStopUnit {
+            start: (cb[4] & 0b00000001) != 0,
+            load_eject: (cb[4] & 0b00000010) != 0,
+        },
+        _ => ScsiCommand::Unknown,
+    }
+}
--- a/src/storage.rs
+++ b/src/storage.rs
@@ -0,0 +1,100 @@
+use embassy_rp::gpio::{Input, Output};
+use embassy_rp::peripherals::SPI0;
+use embassy_rp::spi::{Blocking, Spi};
+use embassy_time::Delay;
+use embedded_hal_bus::spi::ExclusiveDevice;
+use embedded_sdmmc::{
+    Block, BlockCount, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource,
+    Timestamp, Volume, VolumeIdx, VolumeManager, sdcard::Error,
+};
+
+pub const MAX_DIRS: usize = 4;
+pub const MAX_FILES: usize = 5;
+pub const MAX_VOLUMES: usize = 1;
+
+type Device = ExclusiveDevice<Spi<'static, SPI0, Blocking>, Output<'static>, embassy_time::Delay>;
+type SD = SdmmcSdCard<Device, Delay>;
+type VolMgr = VolumeManager<SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
+type Vol<'a> = Volume<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
+type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
+
+pub struct DummyTimeSource {}
+impl TimeSource for DummyTimeSource {
+    fn get_timestamp(&self) -> Timestamp {
+        Timestamp::from_calendar(2022, 1, 1, 0, 0, 0).unwrap()
+    }
+}
+
+pub struct SdCard {
+    det: Input<'static>,
+    volume_mgr: VolMgr,
+}
+
+impl SdCard {
+    pub const BLOCK_SIZE: u16 = 512;
+
+    pub fn new(sdcard: SD, det: Input<'static>) -> Self {
+        let volume_mgr = VolumeManager::<_, _, MAX_DIRS, MAX_FILES, MAX_VOLUMES>::new_with_limits(
+            sdcard,
+            DummyTimeSource {},
+            5000,
+        );
+        Self {
+            det: det,
+            volume_mgr,
+        }
+    }
+
+    /// Returns true if an SD card is inserted.
+    /// The DET pin is active-low via mechanical switch in the socket.
+    pub fn is_attached(&self) -> bool {
+        self.det.is_low()
+    }
+
+    pub fn open_volume(&mut self) -> Result<Vol<'_>, ()> {
+        if self.is_attached() {
+            return Ok(self.volume_mgr.open_volume(VolumeIdx(0)).map_err(|_| ())?);
+        }
+        Err(())
+    }
+
+    pub fn size(&self) -> u64 {
+        let mut result = 0;
+
+        self.volume_mgr.device(|sd| {
+            result = sd.num_bytes().unwrap_or(0);
+            DummyTimeSource {}
+        });
+
+        result
+    }
+
+    pub fn num_blocks(&self) -> u32 {
+        let mut result = 0;
+
+        self.volume_mgr.device(|sd| {
+            result = sd.num_blocks().unwrap_or(BlockCount(0)).0;
+            DummyTimeSource {}
+        });
+
+        result
+    }
+
+    pub fn read_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
+        let mut res: Result<(), Error> = Ok(());
+        self.volume_mgr.device(|sd| {
+            res = sd.read(blocks, start_block_idx);
+            DummyTimeSource {}
+        });
+        res.map_err(|_| ())
+    }
+
+    pub fn write_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
+        let mut res: Result<(), Error> = Ok(());
+        self.volume_mgr.device(|sd| {
+            let res = sd.write(blocks, start_block_idx);
+            DummyTimeSource {}
+        });
+        res.map_err(|_| ())
+    }
+}
--- a/src/usb.rs
+++ b/src/usb.rs
@@ -0,0 +1,36 @@
+use crate::{scsi::MassStorageClass, storage::SdCard};
+use embassy_futures::select::select;
+use embassy_rp::{peripherals::USB, usb::Driver};
+use embassy_usb::{Builder, Config};
+
+pub async fn usb_handler(driver: Driver<'static, USB>, sdcard: SdCard) {
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("LegitCamper");
+    config.product = Some("PicoCalc");
+    config.serial_number = Some("01001100");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 64];
+    let mut control_buf = [0; 64];
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut [],
+        &mut control_buf,
+    );
+
+    let mut scsi = MassStorageClass::new(&mut builder, sdcard);
+    let mut usb = builder.build();
+
+    loop {
+        select(usb.run(), scsi.poll()).await;
+
+        defmt::warn!("rebuilding usb");
+        usb.disable().await;
+    }
+}
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -0,0 +1,11 @@
+#[macro_export]
+macro_rules! format {
+    ($len:literal, $($arg:tt)*) => {{
+        use heapless::String;
+        use core::fmt::Write;
+
+        let mut s: String<$len> = String::new();
+        let _ = write!(&mut s, $($arg)*);
+        s
+    }}
+}
Author	SHA1	Message	Date
sawyer bristol	f8fb1b81c2	stateless scsi	2025-07-30 14:59:53 -06:00
sawyer bristol	1d03640d5b	automount works after reformat!	2025-07-29 14:52:50 -06:00
sawyer bristol	0d77321bb3	can unmount now	2025-07-29 13:49:58 -06:00
sawyer bristol	2bddec08e6	can mount and transfer files!	2025-07-29 13:21:06 -06:00
sawyer bristol	7ed35fb771	troubleshooting scsi block errors	2025-07-29 01:02:54 -06:00
sawyer bristol	60ed910a88	can mount but not access	2025-07-28 12:57:50 -06:00
sawyer bristol	a9e1120247	WIP, sd fails to init	2025-07-26 21:17:58 -06:00
sawyer bristol	beae5b2fd9	WIP	2025-07-21 23:12:16 -06:00
sawyer bristol	2d31e62d82	Squash merge keyboard-writer into main	2025-07-17 23:34:20 -06:00
sawyer bristol	5e537be5a3	keyboard & peripheral enhancement	2025-06-26 20:00:44 -06:00
sawyer bristol	b3e721a8be	working keyboard	2025-06-26 16:33:16 -06:00
sawyer bristol	8aa7a40fa5	half display resolution	2025-06-25 19:22:37 -06:00
sawyer bristol	8f3c3053c8	use full rp2350 ram	2025-06-25 14:33:43 -06:00