move all output modules to subdirectory, trash standard.nix

standard.nix isn't, is the essence here. Not all devices
support flashimage as it is currently defined - some
have diskimage, some have neither

modules/outputs/initramfs.nix

@@ -0,0 +1,58 @@
+{
+  config
+, pkgs
+, lib
+, ...
+}:
+let
+  inherit (lib) mkEnableOption mkOption mkIf types;
+  inherit (pkgs) runCommand callPackage writeText;
+in
+{
+  options = {
+    boot.initramfs = {
+      enable = mkEnableOption "initramfs";
+    };
+    system.outputs = {
+      initramfs = mkOption {
+        type = types.package;
+        internal = true;
+        description = ''
+          Initramfs image capable of mounting the real root
+          filesystem
+        '';
+      };
+      systemConfiguration = mkOption {
+        type = types.package;
+        description = ''
+          pkgs.systemconfig for the configured filesystem,
+          contains 'activate' and 'init' commands
+        '';
+        internal = true;
+      };
+    };
+  };
+  config = mkIf config.boot.initramfs.enable {
+    kernel.config = {
+      BLK_DEV_INITRD = "y";
+      INITRAMFS_SOURCE = builtins.toJSON "${config.system.outputs.initramfs}";
+#      INITRAMFS_COMPRESSION_LZO = "y";
+    };
+
+    system.outputs = {
+      initramfs =
+        let inherit (pkgs.pkgsBuildBuild) gen_init_cpio;
+        in runCommand "initramfs.cpio" {} ''
+          cat << SPECIALS | ${gen_init_cpio}/bin/gen_init_cpio /dev/stdin > $out
+          dir /proc 0755 0 0
+          dir /dev 0755 0 0
+          nod /dev/console 0600 0 0 c 5 1
+          dir /target 0755 0 0
+          dir /target/persist 0755 0 0
+          dir /target/nix 0755 0 0
+          file /init ${pkgs.preinit}/bin/preinit 0755 0 0
+          SPECIALS
+        '';
+    };
+  };
+}

modules/outputs/jffs2.nix

@@ -0,0 +1,46 @@
+{
+  config
+, pkgs
+, lib
+, ...
+}:
+let
+  inherit (lib) mkIf mkOption types;
+  o = config.system.outputs;
+in
+{
+  imports = [
+    ./initramfs.nix
+  ];
+
+  config = mkIf (config.rootfsType == "jffs2") {
+    kernel.config = {
+      JFFS2_FS = "y";
+      JFFS2_LZO = "y";
+      JFFS2_RTIME = "y";
+      JFFS2_COMPRESSION_OPTIONS = "y";
+      JFFS2_ZLIB = "y";
+      JFFS2_CMODE_SIZE = "y";
+    };
+    boot.initramfs.enable = true;
+    system.outputs = {
+      systemConfiguration =
+        pkgs.systemconfig config.filesystem.contents;
+      rootfs =
+        let
+          inherit (pkgs.pkgsBuildBuild) runCommand mtdutils;
+          endian = if pkgs.stdenv.isBigEndian
+                   then "--big-endian" else "--little-endian";
+        in runCommand "make-jffs2" {
+          depsBuildBuild = [ mtdutils ];
+        } ''
+          cp -a ${o.rootfsFiles} tmp
+          ${if config.boot.loader.extlinux.enable
+            then "(cd tmp && ln -s ${o.extlinux} boot)"
+            else ""
+          }
+          (cd tmp && mkfs.jffs2 --compression-mode=size ${endian} -e ${toString config.hardware.flash.eraseBlockSize} --enable-compressor=lzo --pad --root . --output $out --squash --faketime )
+        '';
+    };
+  };
+}

modules/outputs/kexecboot.nix

@@ -0,0 +1,63 @@
+{
+  config
+, pkgs
+, lib
+, ...
+}:
+let
+  inherit (lib) mkOption mkForce types concatStringsSep;
+in {
+  imports = [ ../ramdisk.nix ];
+  options.system.outputs = {
+    kexecboot = mkOption {
+      type = types.package;
+      description = ''
+        Directory containing files needed for kexec booting.
+        Can be copied onto the target device using ssh or similar
+      '';
+    };
+    boot-sh = mkOption {
+      type = types.package;
+      description = ''
+        Shell script to run on the target device that invokes
+        kexec with appropriate options
+      '';
+    };
+  };
+  config = {
+    boot.ramdisk.enable = true;
+    system.outputs = {
+      kexecboot =
+        let o = config.system.outputs; in
+        pkgs.runCommand "kexecboot" {} ''
+          mkdir $out
+          cd $out
+          ln -s ${o.rootfs} rootfs
+          ln -s ${o.kernel} kernel
+          ln -s ${o.manifest} manifest
+          ln -s ${o.boot-sh} boot.sh
+          ln -s ${pkgs.kexec-tools-static}/bin/kexec ./kexec
+          ln -s ${o.dtb} dtb
+       '';
+
+      boot-sh =
+        let
+          inherit (pkgs.lib.trivial) toHexString;
+          inherit (config.system.outputs) rootfs kernel;
+          cmdline = concatStringsSep " " config.boot.commandLine;
+        in
+          pkgs.buildPackages.runCommand "boot.sh.sh" {
+          } ''
+            rootfsStart=${toString (100 * 1024 * 1024)}
+            rootfsBytes=$(stat -L -c %s ${rootfs})
+            append_cmd="mtdparts=phram0:''${rootfsBytes}(rootfs) phram.phram=phram0,''${rootfsStart},''${rootfsBytes} memmap=''${rootfsBytes}\$''${rootfsStart}";
+            cat > $out <<EOF
+            #!/bin/sh
+            test -d \$1
+            cd \$1
+            ./kexec -f -d --map-file rootfs@$rootfsStart --dtb dtb --command-line '${cmdline} $append_cmd' kernel
+            EOF
+          '';
+    };
+  };
+}

modules/outputs/tftpboot.nix

@@ -0,0 +1,98 @@
+{
+  config
+, pkgs
+, lib
+, ...
+}:
+let
+  inherit (lib) mkOption types concatStringsSep;
+  cfg = config.boot.tftp;
+in {
+  imports = [ ../ramdisk.nix ];
+  options.boot.tftp.freeSpaceBytes = mkOption {
+    type = types.int;
+    default = 0;
+  };
+  options.system.outputs = {
+    tftpboot = mkOption {
+      type = types.package;
+      description = ''
+        tftpboot
+        ********
+
+        This output is intended for developing on a new device.
+        It assumes you have a serial connection and a
+        network connection to the device and that your
+        build machine is running a TFTP server.
+
+        The output is a directory containing kernel and
+        root filesystem image, and a script :file:`boot.scr` of U-Boot
+        commands that will load the images into memory and
+        run them directly,
+        instead of first writing them to flash. This saves
+        time and erase cycles.
+
+        It uses the Linux `phram <https://github.com/torvalds/linux/blob/master/drivers/mtd/devices/phram.c>`_ driver to emulate a flash device using a segment of physical RAM.
+      '';
+    };
+    boot-scr = mkOption {
+      type = types.package;
+      internal = true;
+      description = ''
+        U-Boot commands to load and boot a kernel and rootfs over TFTP.
+        Copy-paste into the device boot monitor
+      '';
+    };
+  };
+  config = {
+    boot.ramdisk.enable = true;
+
+    system.outputs = rec {
+      tftpboot =
+        let o = config.system.outputs; in
+        pkgs.runCommand "tftpboot" {} ''
+          mkdir $out
+          cd $out
+          ln -s ${o.rootfs} rootfs
+          ln -s ${o.kernel} vmlinux
+          ln -s ${o.manifest} manifest
+          ln -s ${o.kernel.headers} build
+          ln -s ${o.uimage} uimage
+          ln -s ${o.boot-scr}/dtb dtb
+          ln -s ${o.boot-scr}/script boot.scr
+       '';
+
+      boot-scr =
+        let
+          inherit (pkgs.lib.trivial) toHexString;
+          o = config.system.outputs;
+          cmdline = concatStringsSep " " config.boot.commandLine;
+        in
+          pkgs.buildPackages.runCommand "boot-scr" { nativeBuildInputs = [ pkgs.pkgsBuildBuild.dtc ];  } ''
+            uimageSize=$(($(stat -L -c %s ${o.uimage}) + 0x1000 &(~0xfff)))
+            rootfsStart=0x$(printf %x $((${toString cfg.loadAddress} + 0x100000 + $uimageSize   &(~0xfffff) )))
+            rootfsBytes=$(($(stat -L -c %s ${o.rootfs}) + 0x100000 &(~0xfffff)))
+            rootfsBytes=$(($rootfsBytes + ${toString cfg.freeSpaceBytes} ))
+            rootfsMb=$(($rootfsBytes >> 20))
+            cmd="mtdparts=phram0:''${rootfsMb}M(rootfs) phram.phram=phram0,''${rootfsStart},''${rootfsBytes},${toString config.hardware.flash.eraseBlockSize} root=/dev/mtdblock0";
+
+            dtbStart=$(printf %x $((${toString cfg.loadAddress} + $rootfsBytes + 0x100000 + $uimageSize )))
+
+            mkdir $out
+            cat ${o.dtb} > $out/dtb
+            fdtput -p -t s $out/dtb /reserved-memory/phram-rootfs compatible phram
+            fdtput -p -t lx $out/dtb /reserved-memory/phram-rootfs reg 0 $rootfsStart 0 $(printf %x $rootfsBytes)
+
+            dtbBytes=$(($(stat -L -c %s $out/dtb) + 0x1000 &(~0xfff)))
+
+            cat > $out/script << EOF
+            setenv serverip ${cfg.serverip}
+            setenv ipaddr ${cfg.ipaddr}
+            setenv bootargs 'liminix ${cmdline} $cmd'
+            tftpboot 0x${lib.toHexString cfg.loadAddress} result/uimage ; tftpboot 0x$(printf %x $rootfsStart) result/rootfs ; tftpboot 0x$dtbStart result/dtb
+            bootm 0x${lib.toHexString cfg.loadAddress} - 0x$dtbStart
+            EOF
+          '';
+    };
+  };
+}

modules/outputs/ubifs.nix

@@ -0,0 +1,48 @@
+{
+  config
+, pkgs
+, lib
+, ...
+}:
+let
+  inherit (lib) mkIf mkOption types;
+  o = config.system.outputs;
+in
+{
+  imports = [
+    ./initramfs.nix
+  ];
+  options.hardware.ubi = {
+    minIOSize = mkOption { type = types.str; };
+    eraseBlockSize = mkOption { type = types.str; }; # LEB
+    maxLEBcount = mkOption { type = types.str; }; # LEB
+  };
+
+  config = mkIf (config.rootfsType == "ubifs") {
+    kernel.config = {
+      MTD_UBI="y";
+      UBIFS_FS = "y";
+      UBIFS_FS_SECURITY = "n";
+    };
+    boot.initramfs.enable = true;
+    system.outputs = {
+      systemConfiguration =
+        pkgs.systemconfig config.filesystem.contents;
+      rootfs =
+        let
+          inherit (pkgs.pkgsBuildBuild) runCommand mtdutils;
+          cfg = config.hardware.ubi;
+        in runCommand "mkfs.ubifs" {
+          depsBuildBuild = [ mtdutils ];
+        } ''
+          mkdir tmp
+          cp -a ${o.rootfsFiles} tmp
+          ${if config.boot.loader.extlinux.enable
+            then "(cd tmp && ln -s ${o.extlinux} boot)"
+            else ""
+           }
+          mkfs.ubifs -x favor_lzo -c ${cfg.maxLEBcount} -m ${cfg.minIOSize} -e ${cfg.eraseBlockSize}  -y -r tmp --output $out  --squash-uids -o $out
+        '';
+    };
+  };
+}