nixos: use usb_block_drv for USB storage

nixos-modules/hardware/usb.nix

@@ -3,24 +3,27 @@
 with lib;
 
 {
-  options = {
+  options.hardware.genode.usb = {
 
-    hardware.usb.genode.enable = lib.mkEnableOption "USB driver";
+    enable = lib.mkEnableOption "USB driver";
+    storage.enable = lib.mkEnableOption "USB mass storage driver";
 
-    hardware.usb.genode.storage.enable =
-      lib.mkEnableOption "USB mass storage driver";
+    ehciSupport = lib.mkEnableOption "EHCI support" // { default = true; };
+    ohciSupport = lib.mkEnableOption "OHCI support" // { default = true; };
+    uhciSupport = lib.mkEnableOption "UHCI support" // { default = false; };
+    xhciSupport = lib.mkEnableOption "XHCI support" // { default = true; };
 
   };
 
-  config = {
+  config = let cfg = config.hardware.genode.usb;
+  in {
 
-    hardware.usb.genode.storage.enable = config.genode.boot.storeBackend
+    hardware.genode.usb.storage.enable = config.genode.boot.storeBackend
       == "usb";
 
-    hardware.usb.genode.enable = config.hardware.usb.genode.storage.enable;
+    hardware.genode.usb.enable = cfg.storage.enable;
 
-    hardware.genode.platform.policies =
-      lib.optional config.hardware.usb.genode.enable
+    hardware.genode.platform.policies = lib.optional cfg.enable
       (builtins.toFile ("usb.platform-policy.dhall") ''
         let Genode = env:DHALL_GENODE
 
@@ -34,49 +37,84 @@ with lib;
             }
       '');
 
-    genode.core.basePackages = lib.optional config.hardware.usb.genode.enable
-      pkgs.genodePackages.usb_drv;
-
-    genode.init.children.usb_drv = lib.mkIf config.hardware.usb.genode.enable {
-      coreROMs = [ "usb_drv" ];
-      configFile = builtins.toFile "usb_drv.dhall" ''
+    genode.init.children.usb_drv = lib.mkIf cfg.enable {
+      inputs = [ pkgs.genodePackages.usb_drv ];
+      configFile = let toYesNo = b: if b then "yes" else "no";
+      in builtins.toFile "usb_drv.dhall" ''
         let Genode = env:DHALL_GENODE
 
         let XML = Genode.Prelude.XML
 
         let Init = Genode.Init
 
-        let storageEnable = ${
-          if config.hardware.usb.genode.storage.enable then "True" else "False"
-        }
-
         in  Init.Child.flat
               Init.Child.Attributes::{
               , binary = "usb_drv"
-              , provides = [ "Block", "Usb" ]
               , resources = Init.Resources::{ caps = 256, ram = Genode.units.MiB 12 }
+              , romReports = let local = "devices" in [ { local, route = local } ]
               , routes = [ Init.ServiceRoute.parent "IO_MEM" ]
-              , config = Init.Config::{
-                , attributes = toMap { uhci = "yes", ehci = "yes", xhci = "yes" }
-                , content =
-                    if    storageEnable
-                    then  [ XML.leaf
-                              { name = "storage", attributes = XML.emptyAttributes }
-                          ]
-                    else  [] : List XML.Type
-                , policies =
-                    if    storageEnable
-                    then  [ Init.Config.Policy::{
-                            , service = "Block"
-                            , label = Init.LabelSelector.prefix "store_fs"
+              , config =
+                  let storagePolicy =
+                        Init.Config.Policy::{
+                        , service = "Usb"
+                        , label = Init.LabelSelector.prefix "usb_block_drv"
+                        , attributes = toMap { class = "8" }
+                        , diag = Some True
+                        }
+
+                  in  Init.Config::{
+                      , attributes = toMap
+                          { ehci = "${toYesNo cfg.ehciSupport}"
+                          , ohci = "${toYesNo cfg.ohciSupport}"
+                          , uhci = "${toYesNo cfg.uhciSupport}"
+                          , xhci = "${toYesNo cfg.xhciSupport}"
+                          }
+                      , content =
+                        [ XML.element
+                            { name = "raw"
+                            , attributes = XML.emptyAttributes
+                            , content =
+                              [ XML.leaf
+                                  { name = "report"
+                                  , attributes = toMap { devices = "yes" }
+                                  }
+                              , Init.Config.Policy.toXML storagePolicy
+                              ]
                             }
-                          ]
-                    else  [] : List Init.Config.Policy.Type
-                }
+                        ]
+                      , policies = [ storagePolicy ]
+                      }
               }
       '';
     };
 
+    genode.core.children.usb_block_drv =
+      mkIf config.hardware.genode.usb.storage.enable {
+        inputs = [ pkgs.genodePackages.usb_block_drv ];
+        configFile = builtins.toFile "usb_block_drv.dhall" ''
+          let Genode = env:DHALL_GENODE
+
+          let XML = Genode.Prelude.XML
+
+          let Init = Genode.Init
+
+          in  Init.Child.flat
+                Init.Child.Attributes::{
+                , binary = "usb_block_drv"
+                , resources = Init.Resources::{ caps = 256, ram = Genode.units.MiB 4 }
+                , config = Init.Config::{
+                  , attributes = toMap { writeable = "yes" }
+                  , policies =
+                    [ Init.Config.Policy::{
+                      , service = "Block"
+                      , label = Init.LabelSelector.prefix "part_block"
+                      }
+                    ]
+                  }
+                }
+        '';
+      };
+
   };
 
 }