initial commit (based on artiq 322861225e)

artiq/artiq-board.nix

@@ -0,0 +1,61 @@
+# Install Vivado in /opt and add to /etc/nixos/configuration.nix:
+#  nix.sandboxPaths = ["/opt"];
+
+{ pkgs ? import <nixpkgs> {}}:
+{ target, variant, buildCommand ? "python -m artiq.gateware.targets.${target} -V ${variant}" }:
+
+let
+  artiqPkgs = import ./default.nix { inherit pkgs; };
+  fetchcargo = import ./fetchcargo.nix {
+    inherit (pkgs) stdenv cacert git cargo cargo-vendor;
+  };
+  artiqSrc = import ./pkgs/artiq-src.nix { fetchgit = pkgs.fetchgit; };
+  cargoDeps = fetchcargo rec {
+    name = "artiq-firmware-cargo-deps";
+    src = "${artiqSrc}/artiq/firmware";
+    sha256 = "1xzjn9i4rkd9124v2gbdplsgsvp1hlx7czdgc58n316vsnrkbr86";
+  };
+
+  cargoVendored = pkgs.stdenv.mkDerivation {
+    name = "artiq-firmware-cargo-vendored";
+    src = cargoDeps;
+    phases = [ "unpackPhase" "installPhase" ];
+    installPhase =
+      ''
+      mkdir -p $out/registry
+      cat << EOF > $out/config
+        [source.crates-io]
+        registry = "https://github.com/rust-lang/crates.io-index"
+        replace-with = "vendored-sources"
+
+        [source."https://github.com/m-labs/libfringe"]
+        git = "https://github.com/m-labs/libfringe"
+        rev = "b8a6d8f"
+        replace-with = "vendored-sources"
+
+        [source.vendored-sources]
+        directory = "$out/registry"
+      EOF
+      cp -R * $out/registry
+      '';
+  };
+
+  buildenv = import ./artiq-dev.nix { inherit pkgs; };
+
+in pkgs.stdenv.mkDerivation {
+  name = "artiq-board-${target}-${variant}";
+  src = null;
+  phases = [ "buildPhase" "installPhase" ];
+  buildPhase = 
+    ''
+    ${buildenv}/bin/artiq-dev -c "CARGO_HOME=${cargoVendored} ${buildCommand}"
+    '';
+  installPhase =
+    ''
+    TARGET_DIR=$out/${pkgs.python3Packages.python.sitePackages}/artiq/binaries/${target}-${variant}
+    mkdir -p $TARGET_DIR
+    cp artiq_${target}/${variant}/gateware/top.bit $TARGET_DIR
+    cp artiq_${target}/${variant}/software/bootloader/bootloader.bin $TARGET_DIR
+    cp artiq_${target}/${variant}/software/runtime/runtime.{elf,fbi} $TARGET_DIR
+    '';
+}

artiq/artiq-dev.nix

@@ -0,0 +1,35 @@
+{ pkgs ? import <nixpkgs> {}}:
+
+let 
+  artiqpkgs = import ./default.nix { inherit pkgs; };
+in
+  pkgs.buildFHSUserEnv {
+    name = "artiq-dev";
+    targetPkgs = pkgs: (
+      with pkgs; [
+        ncurses5
+        gnumake
+        zlib
+        libuuid
+        xorg.libSM
+        xorg.libICE
+        xorg.libXrender
+        xorg.libX11
+        xorg.libXext
+        xorg.libXtst
+        xorg.libXi
+        (python3.withPackages(ps: with ps; [ jinja2 numpy artiqpkgs.migen artiqpkgs.microscope artiqpkgs.misoc artiqpkgs.jesd204b artiqpkgs.artiq ]))
+        git
+        cargo
+      ] ++
+      (with artiqpkgs; [
+        rustc
+        binutils-or1k
+        llvm-or1k
+        openocd
+      ])
+    );
+    profile = ''
+      export TARGET_AR=${artiqpkgs.binutils-or1k}/bin/or1k-linux-ar
+    '';
+  }

artiq/conda-board.nix

@@ -0,0 +1,57 @@
+{ pkgs ? import <nixpkgs> {}}:
+{ artiqSrc, boardBinaries, target, variant }:
+
+with pkgs;
+
+let
+  fakeCondaSource = runCommand "fake-conda-source-${target}-${variant}" { }
+    ''
+    cp --no-preserve=mode,ownership -R ${artiqSrc} $out
+    mkdir $out/fake-conda;
+
+    cat << EOF > $out/fake-conda/meta.yaml
+    package:
+      name: artiq-board-${target}-${variant}
+      version: {{ environ["GIT_DESCRIBE_TAG"] }}
+
+    source:
+      git_url: ..
+
+    build:
+      noarch: python
+      number: {{ environ["GIT_DESCRIBE_NUMBER"] }}
+      string: {{ environ["GIT_DESCRIBE_NUMBER"] }}+git{{ environ["GIT_FULL_HASH"][:8] }}
+      ignore_prefix_files: True
+
+    outputs:
+      - name: artiq-board-${target}-${variant}
+        noarch: python
+        files:
+          - site-packages
+        requirements:
+          run:
+            - artiq
+        ignore_prefix_files: True
+
+    about:
+      home: https://m-labs.hk/artiq
+      license: LGPL
+      summary: 'Bitstream, BIOS and firmware for the ${target}-${variant} board variant'
+    EOF
+
+    cat << EOF > $out/fake-conda/build.sh
+    #!/bin/bash
+    set -e
+    SOC_PREFIX=\$PREFIX/site-packages/artiq/binaries/${target}-${variant}
+    mkdir -p \$SOC_PREFIX
+    cp ${boardBinaries}/${pkgs.python3Packages.python.sitePackages}/artiq/binaries/${target}-${variant}/* \$SOC_PREFIX
+    EOF
+    chmod 755 $out/fake-conda/build.sh
+    '';
+  conda-board = import ./conda-build.nix { inherit pkgs; } {
+    name = "conda-artiq-board-${target}-${variant}";
+    src = fakeCondaSource;
+    recipe = "fake-conda";
+  };
+in
+  conda-board

artiq/conda-build.nix

@@ -0,0 +1,65 @@
+# We need to pass the whole source to conda for the git variables to work.
+# recipe must be a string pointing to a path within the source.
+
+{ pkgs ? import <nixpkgs> {}}:
+{ name, src, recipe }:
+
+with pkgs;
+
+let
+  condaDeps = [ stdenv.cc xorg.libSM xorg.libICE xorg.libXrender libselinux ];
+  # Use the full Anaconda distribution, which already contains conda-build and its many dependencies,
+  # so we don't have to manually deal with them.
+  condaInstaller = fetchurl {
+    url = "https://repo.anaconda.com/archive/Anaconda3-2018.12-Linux-x86_64.sh";
+    sha256 = "006fgyz75ihd00qzbr1cny97xf1mwnzibbqyhskghraqgs2x068h";
+  };
+  condaSrcChmod = runCommand "conda-src-chmod" { } "mkdir $out; cp ${condaInstaller} $out/conda-installer.sh; chmod +x $out/conda-installer.sh";
+  condaInstallerEnv = buildFHSUserEnv {
+    name = "conda-installer-env";
+    targetPkgs = pkgs: ([ condaSrcChmod ] ++ condaDeps);
+  };
+
+  # Git depends on libiconv
+  condaIconv = fetchurl {
+    url = "https://anaconda.org/conda-forge/libiconv/1.15/download/linux-64/libiconv-1.15-h14c3975_1004.tar.bz2";
+    sha256 = "167j8jpr6mnyrzwp18dr52xr3xjsf39q452ag247ijlmp092v8ns";
+  };
+  condaGit = fetchurl {
+    url = "https://anaconda.org/conda-forge/git/2.20.1/download/linux-64/git-2.20.1-pl526hc122a05_1001.tar.bz2";
+    sha256 = "03s01xq2jj7zbx7jfzz6agy40jj7xkq6dwar3lw1z5j2rbmh8h0h";
+  };
+  condaInstalled = runCommand "conda-installed" { }
+    ''
+    ${condaInstallerEnv}/bin/conda-installer-env -c "${condaSrcChmod}/conda-installer.sh -p $out -b"
+    ${condaInstallerEnv}/bin/conda-installer-env -c "$out/bin/conda install ${condaIconv}"
+    ${condaInstallerEnv}/bin/conda-installer-env -c "$out/bin/conda install ${condaGit}"
+    '';
+  condaBuilderEnv = buildFHSUserEnv {
+    name = "conda-builder-env";
+    targetPkgs = pkgs: [ condaInstalled ] ++ condaDeps;
+  };
+
+in stdenv.mkDerivation {
+  inherit name src;
+  buildInputs = [ condaBuilderEnv ];
+  buildCommand =
+    ''
+    HOME=`pwd`
+    # Build requirements make conda-build fail when disconnected from the internet, e.g. in the nix sandbox.
+    # Just ignore them - python and setuptools are installed anyway.
+    cat << EOF > clobber.yaml
+      requirements:
+        build:
+
+      build:
+        script_env:
+          - PYTHON
+    EOF
+    mkdir $out
+    ${condaBuilderEnv}/bin/conda-builder-env -c "PYTHON=python conda build --clobber-file clobber.yaml --no-anaconda-upload --no-test --output-folder $out $src/${recipe}"
+
+    mkdir -p $out/nix-support
+    echo file conda $out/noarch/*.tar.bz2 >> $out/nix-support/hydra-build-products
+    '';
+}

artiq/default.nix

@@ -0,0 +1,18 @@
+{ pkgs ? import <nixpkgs> {}}:
+with pkgs;
+let
+  # this code was copied from nipxkgs rev. ffafe9 (nixcloud team) and slightly modified
+  rust = callPackage ./pkgs/rust
+    (stdenv.lib.optionalAttrs (stdenv.cc.isGNU && stdenv.hostPlatform.isi686) {
+      stdenv = overrideCC stdenv gcc6; # with gcc-7: undefined reference to `__divmoddi4'
+    });
+  llvm-src = callPackage ./fetch-llvm-clang.nix {};
+in rec {
+  inherit (rust) rustc;
+  inherit (callPackage ./pkgs/python3Packages.nix {}) migen microscope misoc jesd204b;
+  binutils-or1k = callPackage ./pkgs/binutils-or1k.nix {};
+  llvm-or1k = callPackage ./pkgs/llvm-or1k.nix { inherit llvm-src; };
+  llvmlite = callPackage ./pkgs/llvmlite.nix { inherit llvm-or1k; };
+  artiq = callPackage ./pkgs/artiq.nix { inherit binutils-or1k; inherit llvm-or1k; inherit llvmlite; };
+  openocd = callPackage ./pkgs/openocd.nix {};
+}

artiq/fetch-llvm-clang.nix

@@ -0,0 +1,22 @@
+{ runCommand, fetchFromGitHub, git }:
+
+let
+llvm-src = fetchFromGitHub {
+  rev = "527aa86b578da5dfb9cf4510b71f0f46a11249f7";
+  owner = "m-labs";
+  repo = "llvm-or1k";
+  sha256 = "0lmcg9xj66pf4mb6racipw67vm8kwm84dl861hyqnywd61kvhrwa";
+};
+clang-src = fetchFromGitHub {
+  rev = "9e996136d52ed506ed8f57ef8b13b0f0f735e6a3";
+  owner = "m-labs";
+  repo = "clang-or1k";
+  sha256 = "0w5f450i76y162aswi2c7jip8x3arzljaxhbqp8qfdffm0rdbjp4";
+};
+in
+runCommand "llvm_or1k_src" {}''
+mkdir -p $out
+mkdir -p $out/tools/clang
+cp -r ${llvm-src}/* $out/
+cp -r ${clang-src}/* $out/tools/clang
+''

artiq/fetchcargo.nix

@@ -0,0 +1,35 @@
+{ stdenv, cacert, git, cargo, cargo-vendor }:
+{ name, src, sha256 }:
+stdenv.mkDerivation {
+  name = "${name}-vendor";
+  nativeBuildInputs = [ cacert git cargo cargo-vendor ];
+  inherit src;
+
+  phases = "unpackPhase patchPhase installPhase";
+
+  installPhase = ''
+    if [[ ! -f Cargo.lock ]]; then
+        echo
+        echo "ERROR: The Cargo.lock file doesn't exist"
+        echo
+        echo "Cargo.lock is needed to make sure that cargoSha256 doesn't change"
+        echo "when the registry is updated."
+        echo
+
+        exit 1
+    fi
+
+    export CARGO_HOME=$(mktemp -d cargo-home.XXX)
+
+    cargo vendor
+
+    cp -ar vendor $out
+  '';
+
+  outputHashAlgo = "sha256";
+  outputHashMode = "recursive";
+  outputHash = sha256;
+
+  impureEnvVars = stdenv.lib.fetchers.proxyImpureEnvVars;
+  preferLocalBuild = true;
+}

artiq/pkgs/artiq-src.nix

@@ -0,0 +1,7 @@
+{ pkgs ? import <nixpkgs> {}}:
+pkgs.fetchgit {
+  url = "https://github.com/m-labs/artiq";
+  rev = import ./artiq-rev.nix;
+  sha256 = import ./artiq-hash.nix;
+  deepClone = true;
+}

artiq/pkgs/artiq.nix

@@ -0,0 +1,79 @@
+{ stdenv, git, fetchFromGitHub, fetchgit, python3Packages, qt5Full, binutils-or1k, llvm-or1k, llvmlite, python3 }:
+
+let
+
+levenshtein = python3Packages.buildPythonPackage rec {
+  name = "levenshtein";
+  src = fetchFromGitHub {
+    owner = "ztane";
+    repo = "python-Levenshtein";
+    rev = "854e61a05bb8b750e990add96df412cd5448b75e";
+    sha256 = "1yf21kg1g2ivm5a4dx1jra9k0c33np54d0hk5ymnfyc4f6pg386q";
+  };
+  doCheck = false;
+};
+
+pythonparser = python3Packages.buildPythonPackage rec {
+  name = "pythonparser";
+  src = fetchFromGitHub {
+    owner = "m-labs";
+    repo = "pythonparser";
+    rev = "5b391fe86f43bb9f4f96c5bc0532e2a112db2936";
+    sha256 = "1gw1fk4y2l6bwq0fg2a9dfc1rvq8cv492dyil96amjdhsxvnx35b";
+  };
+  propagatedBuildInputs = with python3Packages; [ regex ];
+};
+
+asyncserial = python3Packages.buildPythonPackage rec {
+  name = "asyncserial";
+  src = fetchFromGitHub {
+    owner = "m-labs";
+    repo = "asyncserial";
+    rev = "d95bc1d6c791b0e9785935d2f62f628eb5cdf98d";
+    sha256 = "0yzkka9jk3612v8gx748x6ziwykq5lr7zmr9wzkcls0v2yilqx9k";
+  };
+  propagatedBuildInputs = with python3Packages; [ pyserial ];
+  doCheck = false;
+};
+
+quamash = python3Packages.buildPythonPackage rec {
+  name = "quamash";
+  src = fetchFromGitHub {
+    owner = "harvimt";
+    repo = "quamash";
+    rev = "e513b30f137415c5e098602fa383e45debab85e7";
+    sha256 = "117rp9r4lz0kfz4dmmpa35hp6nhbh6b4xq0jmgvqm68g9hwdxmqa";
+  };
+  propagatedBuildInputs = with python3Packages; [ pyqt5 ];
+  doCheck = false;
+};
+
+pyqtgraph-qt5 = python3Packages.buildPythonPackage rec {
+  name = "pyqtgraph_qt5-${version}";
+  version = "0.10.0";
+  doCheck = false;
+  src = fetchFromGitHub {
+    owner = "pyqtgraph";
+    repo = "pyqtgraph";
+    rev = "1426e334e1d20542400d77c72c132b04c6d17ddb";
+    sha256 = "1079haxyr316jf0wpirxdj0ry6j8mr16cqr0dyyrd5cnxwl7zssh";
+  };
+  propagatedBuildInputs = with python3Packages; [ scipy numpy pyqt5 pyopengl ];
+};
+
+in
+
+python3Packages.buildPythonPackage rec {
+  name = "artiq";
+  src = import ./artiq-src.nix { inherit fetchgit; };
+  buildInputs = [ git ];
+  propagatedBuildInputs = with python3Packages; [ binutils-or1k llvm-or1k llvmlite levenshtein pyqtgraph-qt5 aiohttp pygit2 pythonparser numpy dateutil quamash scipy prettytable pyserial asyncserial h5py cython regex qt5Full pyqt5 ];
+  checkPhase = "python -m unittest discover -v artiq.test";
+  meta = with stdenv.lib; {
+    description = "A leading-edge control system for quantum information experiments";
+    homepage = https://m-labs/artiq;
+    license = licenses.lgpl3;
+    #maintainers = [ maintainers.sb0 ];
+    platforms = [ "x86_64-linux" ];
+  };
+}

artiq/pkgs/binutils-or1k.nix

@@ -0,0 +1,34 @@
+{ stdenv, buildPackages
+, fetchurl, zlib
+}:
+
+stdenv.mkDerivation rec {
+  basename = "binutils";
+  platform = "or1k";
+  version = "2.30";
+  name = "${basename}_${platform}-${version}";
+  src = fetchurl {
+    url = "https://ftp.gnu.org/gnu/binutils/binutils-${version}.tar.bz2";
+    sha256 = "028cklfqaab24glva1ks2aqa1zxa6w6xmc8q34zs1sb7h22dxspg";
+  };
+  configureFlags =
+    [ "--enable-shared" "--enable-deterministic-archives" "--target=or1k-linux"];
+  outputs = [ "out" "info" "man" ];
+  depsBuildBuild = [ buildPackages.stdenv.cc ];
+  buildInputs = [ zlib ];
+  enableParallelBuilding = true;
+  meta = {
+    description = "Tools for manipulating binaries (linker, assembler, etc.)";
+    longDescription = ''
+      The GNU Binutils are a collection of binary tools.  The main
+      ones are `ld' (the GNU linker) and `as' (the GNU assembler).
+      They also include the BFD (Binary File Descriptor) library,
+      `gprof', `nm', `strip', etc.
+    '';
+    homepage = http://www.gnu.org/software/binutils/;
+    license = stdenv.lib.licenses.gpl3Plus;
+    /* Give binutils a lower priority than gcc-wrapper to prevent a
+       collision due to the ld/as wrappers/symlinks in the latter. */
+    priority = "10";
+  };
+}

artiq/pkgs/llvm-or1k.nix

@@ -0,0 +1,45 @@
+{ stdenv
+, git
+, llvm-src
+,  perl, groff, cmake, libxml2, python, libffi, valgrind
+, ...
+}:
+
+stdenv.mkDerivation rec {
+  name = "llvm_or1k";
+  src = llvm-src;
+
+ buildInputs = [ perl groff cmake libxml2 python libffi ] ++ stdenv.lib.optional stdenv.isLinux valgrind;
+
+  preBuild = ''
+    NIX_BUILD_CORES=4
+    makeFlagsArray=(-j''$NIX_BUILD_CORES)
+    mkdir -p $out/
+  '';
+
+  cmakeFlags = with stdenv; [
+    "-DCMAKE_BUILD_TYPE=Release"
+    "-DLLVM_BUILD_LLVM_DYLIB=ON"
+    "-DLLVM_LINK_LLVM_DYLIB=ON"
+    "-DLLVM_TARGETS_TO_BUILD=X86"
+    "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=OR1K"
+    "-DLLVM_ENABLE_ASSERTIONS=OFF"
+    "-DLLVM_INSTALL_UTILS=ON"
+    "-DLLVM_INCLUDE_TESTS=OFF"
+    "-DLLVM_INCLUDE_DOCS=OFF"
+    "-DLLVM_INCLUDE_EXAMPLES=OFF"
+    "-DCLANG_ENABLE_ARCMT=OFF"
+    "-DCLANG_ENABLE_STATIC_ANALYZER=OFF"
+    "-DCLANG_INCLUDE_TESTS=OFF"
+    "-DCLANG_INCLUDE_DOCS=OFF"
+  ];
+
+  enableParallelBuilding = true;
+  meta = {
+    description = "Collection of modular and reusable compiler and toolchain technologies";
+    homepage = http://llvm.org/;
+    license = stdenv.lib.licenses.bsd3;
+    #maintainers = with stdenv.lib.maintainers; [ sb0 ];
+    platforms = stdenv.lib.platforms.all;
+  };
+}

artiq/pkgs/llvmlite.nix

@@ -0,0 +1,25 @@
+{ stdenv, fetchFromGitHub, llvm-or1k, makeWrapper, python3, ncurses, zlib, python3Packages }:
+stdenv.mkDerivation rec {
+  name = "llvmlite";
+  src = fetchFromGitHub {
+    rev = "1d167be4eec5d6c32498952be8b3ac17dd30df8d";
+    owner = "m-labs";
+    repo = "llvmlite";
+    sha256 = "0ranbjhcz2v3crmdbw1sxdwqwqbbm7dd53d8qaqb69ma9fkxy8x7";
+  };
+
+  buildInputs = [ makeWrapper python3 ncurses zlib llvm-or1k python3Packages.setuptools ];
+
+  installPhase = ''
+    LLVM_CONFIG=${llvm-or1k}/bin/llvm-config
+    python3 setup.py install --prefix=$out
+  '';
+
+  meta = with stdenv.lib; {
+      description = "A lightweight LLVM python binding for writing JIT compilers";
+      homepage    = "http://llvmlite.pydata.org/";
+      #maintainers = with maintainers; [ sb0 ];
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+  };
+}

artiq/pkgs/openocd.nix

@@ -0,0 +1,72 @@
+{ stdenv, fetchFromGitHub, autoreconfHook, libftdi, libusb1, pkgconfig, hidapi }:
+
+stdenv.mkDerivation rec {
+  name = "openocd-mlabs-${version}";
+  version = "0.10.0";
+
+  src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "openocd";
+      fetchSubmodules = true;
+      rev = "c383a57adcff332b2c5cf8d55a84626285b42c2c";
+      sha256 = "0xlj9cs72acx3zqagvr7f1c0v6lnqhl8fgrlhgmhmvk5n9knk492";
+  };
+  bscan_spi_bitstreams = fetchFromGitHub {
+      owner = "quartiq";
+      repo = "bscan_spi_bitstreams";
+      rev = "a628956da7dc794e6e3c95b31ff9ce3af58bc763";
+      sha256 = "1cydbym3wv9jwxh6lw9im1mjzr7w8rzzx95bxkjschmzjq4h13vk";
+  };
+
+  nativeBuildInputs = [ pkgconfig ];
+  buildInputs = [ autoreconfHook libftdi libusb1 hidapi ];
+
+  configureFlags = [
+    "--enable-jtag_vpi"
+    "--enable-usb_blaster_libftdi"
+    "--enable-amtjtagaccel"
+    "--enable-gw16012"
+    "--enable-presto_libftdi"
+    "--enable-openjtag_ftdi"
+    "--enable-oocd_trace"
+    "--enable-buspirate"
+    "--enable-sysfsgpio"
+    "--enable-remote-bitbang"
+  ];
+
+  NIX_CFLAGS_COMPILE = [
+    "-Wno-implicit-fallthrough"
+    "-Wno-format-truncation"
+    "-Wno-format-overflow"
+  ];
+
+  postInstall = ''
+    mkdir -p "$out/etc/udev/rules.d"
+    rules="$out/share/openocd/contrib/60-openocd.rules"
+    if [ ! -f "$rules" ]; then
+        echo "$rules is missing, must update the Nix file."
+        exit 1
+    fi
+    ln -s "$rules" "$out/etc/udev/rules.d/"
+
+    mkdir -p "$out/share/bscan-spi-bitstreams"
+    cp ${bscan_spi_bitstreams}/*.bit "$out/share/bscan-spi-bitstreams"
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Free and Open On-Chip Debugging, In-System Programming and Boundary-Scan Testing";
+    longDescription = ''
+      OpenOCD provides on-chip programming and debugging support with a layered
+      architecture of JTAG interface and TAP support, debug target support
+      (e.g. ARM, MIPS), and flash chip drivers (e.g. CFI, NAND, etc.).  Several
+      network interfaces are available for interactiving with OpenOCD: HTTP,
+      telnet, TCL, and GDB.  The GDB server enables OpenOCD to function as a
+      "remote target" for source-level debugging of embedded systems using the
+      GNU GDB program.
+    '';
+    homepage = http://openocd.sourceforge.net/;
+    license = licenses.gpl2Plus;
+    #maintainers = with maintainers; [ sb0 ];
+    platforms = platforms.linux;
+  };
+}

artiq/pkgs/python3Packages.nix

@@ -0,0 +1,107 @@
+{ pkgs, stdenv, fetchFromGitHub, python, python3Packages }:
+
+rec { 
+  asyncserial = python3Packages.buildPythonPackage rec {
+    name = "asyncserial";
+
+    src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "asyncserial";
+      rev = "d95bc1d6c791b0e9785935d2f62f628eb5cdf98d";
+      sha256 = "0yzkka9jk3612v8gx748x6ziwykq5lr7zmr9wzkcls0v2yilqx9k";
+      fetchSubmodules = true;
+    };
+
+    propagatedBuildInputs = with python3Packages; [ pyserial ] ++ (with pkgs; [ ]);
+
+    meta = with stdenv.lib; {
+      description = "asyncio support for pyserial";
+      homepage    = "https://m-labs.hk";
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+    };
+  };
+  misoc = python3Packages.buildPythonPackage rec {
+    name = "misoc";
+    
+    src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "misoc";
+      rev = "8e033c2cb77f78c95d2b2e08125324891d07fa34";
+      sha256 = "0pv1akhvr85iswqmhzcqh9gfnyha11k68qmhqizma8fdccvvzm4y";
+      fetchSubmodules = true;
+    };
+
+    # TODO: fix misoc bitrot and re-enable tests
+    doCheck = false;
+    
+    propagatedBuildInputs = with python3Packages; [ pyserial jinja2 numpy asyncserial migen ];
+
+    meta = with stdenv.lib; {
+      description = "A high performance and small footprint system-on-chip based on Migen";
+      homepage    = "https://m-labs.hk/migen";
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+    };
+  };
+  migen = python3Packages.buildPythonPackage rec {
+    name = "migen";
+
+    src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "migen";
+      rev = "afe4405becdbc76539f0195c319367187012b05e";
+      sha256 = "1f288a7ll1d1gjmml716wsjf1jyq9y903i2312bxb8pwrg7fwgvz";
+    };
+
+    # TODO: fix migen platform issues and re-enable tests
+    doCheck = false;
+
+    propagatedBuildInputs = with python3Packages; [ colorama sphinx sphinx_rtd_theme ] ++ (with pkgs; [ verilator ]);
+
+    meta = with stdenv.lib; {
+      description = "A Python toolbox for building complex digital hardware";
+      homepage    = "https://m-labs.hk/migen";
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+    };
+  };
+  microscope = python3Packages.buildPythonPackage rec {
+    name = "microscope";
+
+    src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "microscope";
+      rev = "02cffc360ec5a234c589de6cb9616b057ed22253";
+      sha256 = "09yvgk16xfv5r5cf55vcg0f14wam42w53r4snlalcyw5gkm0rlhq";
+    };
+
+    propagatedBuildInputs = with python3Packages; [ pyserial prettytable msgpack-python migen ];
+
+    meta = with stdenv.lib; {
+      description = "Finding the bacteria in rotting FPGA designs";
+      homepage    = "https://m-labs.hk/migen";
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+    };
+  };
+  jesd204b = python3Packages.buildPythonPackage rec {
+    name = "jesd204b";
+
+    src = fetchFromGitHub {
+      owner = "m-labs";
+      repo = "jesd204b";
+      rev = "2fd6391c0a9197580d60f7d8a146191dc7337b03";
+      sha256 = "1lhw8f0dp42xx4g6d7hyhqhrnd6i5ll4a1wcg265rqz3600i4009";
+    };
+
+    propagatedBuildInputs = with python3Packages; [ migen misoc ];
+
+    meta = with stdenv.lib; {
+      description = "JESD204B core for Migen/MiSoC";
+      homepage    = "https://m-labs.hk/migen";
+      license     = licenses.bsd2;
+      platforms   = platforms.unix;
+    };
+  };
+}

artiq/pkgs/rust/binaryBuild.nix

@@ -0,0 +1,117 @@
+{ stdenv, makeWrapper, bash, buildRustPackage, curl, darwin
+, version
+, src
+, platform
+, versionType
+}:
+
+let
+  inherit (stdenv.lib) optionalString;
+  inherit (darwin.apple_sdk.frameworks) Security;
+
+  bootstrapping = versionType == "bootstrap";
+
+  installComponents
+    = "rustc,rust-std-${platform}"
+    + (optionalString bootstrapping ",cargo")
+    ;
+in
+
+rec {
+  inherit buildRustPackage;
+
+  rustc = stdenv.mkDerivation rec {
+    name = "rustc-${versionType}-${version}";
+
+    inherit version;
+    inherit src;
+
+    meta = with stdenv.lib; {
+      homepage = http://www.rust-lang.org/;
+      description = "A safe, concurrent, practical language";
+      #maintainers = with maintainers; [ sb0 ];
+      license = [ licenses.mit licenses.asl20 ];
+    };
+
+    buildInputs = [ bash ] ++ stdenv.lib.optional stdenv.isDarwin Security;
+
+    postPatch = ''
+      patchShebangs .
+    '';
+
+    installPhase = ''
+      ./install.sh --prefix=$out \
+        --components=${installComponents}
+
+      ${optionalString (stdenv.isLinux && bootstrapping) ''
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/rustc"
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/rustdoc"
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/cargo"
+      ''}
+
+      ${optionalString (stdenv.isDarwin && bootstrapping) ''
+        install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/rustc"
+        install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/rustdoc"
+        install_name_tool -change /usr/lib/libiconv.2.dylib '${darwin.libiconv}/lib/libiconv.2.dylib' "$out/bin/cargo"
+        install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/cargo"
+        install_name_tool -change /usr/lib/libcurl.4.dylib '${stdenv.lib.getLib curl}/lib/libcurl.4.dylib' "$out/bin/cargo"
+        for f in $out/lib/lib*.dylib; do
+          install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$f"
+        done
+      ''}
+
+      # Do NOT, I repeat, DO NOT use `wrapProgram` on $out/bin/rustc
+      # (or similar) here. It causes strange effects where rustc loads
+      # the wrong libraries in a bootstrap-build causing failures that
+      # are very hard to track down. For details, see
+      # https://github.com/rust-lang/rust/issues/34722#issuecomment-232164943
+    '';
+  };
+
+  cargo = stdenv.mkDerivation rec {
+    name = "cargo-${versionType}-${version}";
+
+    inherit version;
+    inherit src;
+
+    meta = with stdenv.lib; {
+      homepage = http://www.rust-lang.org/;
+      description = "A safe, concurrent, practical language";
+      #maintainers = with maintainers; [ sb0 ];
+      license = [ licenses.mit licenses.asl20 ];
+    };
+
+    buildInputs = [ makeWrapper bash ] ++ stdenv.lib.optional stdenv.isDarwin Security;
+
+    postPatch = ''
+      patchShebangs .
+    '';
+
+    installPhase = ''
+      patchShebangs ./install.sh
+      ./install.sh --prefix=$out \
+        --components=cargo
+
+      ${optionalString (stdenv.isLinux && bootstrapping) ''
+        patchelf \
+          --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \
+          "$out/bin/cargo"
+      ''}
+
+      ${optionalString (stdenv.isDarwin && bootstrapping) ''
+        install_name_tool -change /usr/lib/libiconv.2.dylib '${darwin.libiconv}/lib/libiconv.2.dylib' "$out/bin/cargo"
+        install_name_tool -change /usr/lib/libresolv.9.dylib '${darwin.libresolv}/lib/libresolv.9.dylib' "$out/bin/cargo"
+        install_name_tool -change /usr/lib/libcurl.4.dylib '${stdenv.lib.getLib curl}/lib/libcurl.4.dylib' "$out/bin/cargo"
+      ''}
+
+      wrapProgram "$out/bin/cargo" \
+        --suffix PATH : "${rustc}/bin"
+    '';
+  };
+}

artiq/pkgs/rust/bootstrap.nix

@@ -0,0 +1,42 @@
+{ stdenv, fetchurl, callPackage }:
+
+let
+  # Note: the version MUST be one version prior to the version we're
+  # building
+  version = "1.28.0";
+
+  # fetch hashes by running `print-hashes.sh 1.24.1`
+  hashes = {
+    i686-unknown-linux-gnu = "de7cdb4e665e897ea9b10bf6fd545f900683296456d6a11d8510397bb330455f";
+    x86_64-unknown-linux-gnu = "2a1390340db1d24a9498036884e6b2748e9b4b057fc5219694e298bdaa37b810";
+    armv7-unknown-linux-gnueabihf = "346558d14050853b87049e5e1fbfae0bf0360a2f7c57433c6985b1a879c349a2";
+    aarch64-unknown-linux-gnu = "9b6fbcee73070332c811c0ddff399fa31965bec62ef258656c0c90354f6231c1";
+    i686-apple-darwin = "752e2c9182e057c4a54152d1e0b3949482c225d02bb69d9d9a4127dc2a65fb68";
+    x86_64-apple-darwin = "5d7a70ed4701fe9410041c1eea025c95cad97e5b3d8acc46426f9ac4f9f02393";
+  };
+
+  platform =
+    if stdenv.hostPlatform.system == "i686-linux"
+    then "i686-unknown-linux-gnu"
+    else if stdenv.hostPlatform.system == "x86_64-linux"
+    then "x86_64-unknown-linux-gnu"
+    else if stdenv.hostPlatform.system == "armv7l-linux"
+    then "armv7-unknown-linux-gnueabihf"
+    else if stdenv.hostPlatform.system == "aarch64-linux"
+    then "aarch64-unknown-linux-gnu"
+    else if stdenv.hostPlatform.system == "i686-darwin"
+    then "i686-apple-darwin"
+    else if stdenv.hostPlatform.system == "x86_64-darwin"
+    then "x86_64-apple-darwin"
+    else throw "missing bootstrap url for platform ${stdenv.hostPlatform.system}";
+
+  src = fetchurl {
+     url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz";
+     sha256 = hashes."${platform}";
+  };
+
+in callPackage ./binaryBuild.nix
+  { inherit version src platform;
+    buildRustPackage = null;
+    versionType = "bootstrap";
+  }

artiq/pkgs/rust/default.nix

@@ -0,0 +1,88 @@
+{ stdenv, callPackage, recurseIntoAttrs, makeRustPlatform, llvm, fetchurl
+, targets ? []
+, targetToolchains ? []
+, targetPatches ? []
+, fetchFromGitHub
+}:
+
+let
+  rustPlatform = recurseIntoAttrs (makeRustPlatform (callPackage ./bootstrap.nix {}));
+  version = "1.28.0";
+  src = fetchFromGitHub {
+    owner = "m-labs";
+    repo = "rust";
+    sha256 = "03lfps3xvvv7wv1nnwn3n1ji13z099vx8c3fpbzp9rnasrwzp5jy";
+    rev = "f305fb024318e96997fbe6e4a105b0cc1052aad4"; #  artiq-1.28.0 branch
+    fetchSubmodules = true;
+  };
+in rec {
+  # nixcloud team code
+  or1k-crates = stdenv.mkDerivation {
+    name = "or1k-crates";
+    inherit src;
+    phases = [ "unpackPhase" "buildPhase" ];
+    buildPhase = ''
+      destdir=$out
+      rustc="${rustc_internal}/bin/rustc --out-dir ''${destdir} -L ''${destdir} --target or1k-unknown-none -g -C target-feature=+mul,+div,+ffl1,+cmov,+addc -C opt-level=s --crate-type rlib"
+      
+      mkdir -p ''${destdir}
+      ''${rustc} --crate-name core src/libcore/lib.rs
+      ''${rustc} --crate-name compiler_builtins src/libcompiler_builtins/src/lib.rs --cfg 'feature="compiler-builtins"' --cfg 'feature="mem"'
+      ''${rustc} --crate-name std_unicode src/libstd_unicode/lib.rs
+      ''${rustc} --crate-name alloc src/liballoc/lib.rs
+      ''${rustc} --crate-name libc src/liblibc_mini/lib.rs
+      ''${rustc} --crate-name unwind src/libunwind/lib.rs
+      ''${rustc} -Cpanic=abort --crate-name panic_abort src/libpanic_abort/lib.rs
+      ''${rustc} -Cpanic=unwind --crate-name panic_unwind src/libpanic_unwind/lib.rs --cfg llvm_libunwind
+    '';
+  };
+  # nixcloud team code
+  # this is basically a wrapper, which uses rustc_internal and inserts or1k-crates into it
+  rustc = stdenv.mkDerivation {
+    name = "rustc";
+    src = ./.;
+    installPhase = ''
+      mkdir $out
+      mkdir -p $out/lib/rustlib/or1k-unknown-none/lib/
+      cp -r ${or1k-crates}/* $out/lib/rustlib/or1k-unknown-none/lib/
+      cp -r ${rustc_internal}/* $out
+    '';
+    meta = with stdenv.lib; {
+      homepage = https://www.rust-lang.org/;
+      description = "A safe, concurrent, practical language";
+      #maintainers = with maintainers; [ sb0 ];
+      license = [ licenses.mit licenses.asl20 ];
+      platforms = platforms.linux ++ platforms.darwin;
+    };
+  };
+  # nixcloud team code
+  # originally rustc but now renamed to rustc_internal
+  rustc_internal = callPackage ./rustc.nix {
+    inherit stdenv llvm targets targetPatches targetToolchains rustPlatform version src;
+
+    patches = [
+      ./patches/net-tcp-disable-tests.patch
+
+      # Re-evaluate if this we need to disable this one
+      #./patches/stdsimd-disable-doctest.patch
+
+      # Fails on hydra - not locally; the exact reason is unknown.
+      # Comments in the test suggest that some non-reproducible environment
+      # variables such $RANDOM can make it fail.
+      ./patches/disable-test-inherit-env.patch
+    ];
+
+    forceBundledLLVM = true;
+
+    #configureFlags = [ "--release-channel=stable" ];
+
+    # 1. Upstream is not running tests on aarch64:
+    # see https://github.com/rust-lang/rust/issues/49807#issuecomment-380860567
+    # So we do the same.
+    # 2. Tests run out of memory for i686
+    #doCheck = !stdenv.isAarch64 && !stdenv.isi686;
+
+    # Disabled for now; see https://github.com/NixOS/nixpkgs/pull/42348#issuecomment-402115598.
+    doCheck = false;
+  };
+}

artiq/pkgs/rust/patches/disable-test-inherit-env.patch

@@ -0,0 +1,10 @@
+--- rustc-1.26.2-src.org/src/libstd/process.rs	2018-06-01 21:40:11.000000000 +0100
++++ rustc-1.26.2-src/src/libstd/process.rs	2018-06-08 07:50:23.023828658 +0100
+@@ -1745,6 +1745,7 @@
+     }
+ 
+     #[test]
++    #[ignore]
+     fn test_inherit_env() {
+         use env;
+ 

artiq/pkgs/rust/patches/net-tcp-disable-tests.patch

@@ -0,0 +1,104 @@
+diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs
+index 0f60b5b3e..9b08415e7 100644
+--- a/src/libstd/net/tcp.rs
++++ b/src/libstd/net/tcp.rs
+@@ -962,6 +962,7 @@ mod tests {
+         }
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn listen_localhost() {
+         let socket_addr = next_test_ip4();
+@@ -1020,6 +1021,7 @@ mod tests {
+         })
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn read_eof() {
+         each_ip(&mut |addr| {
+@@ -1039,6 +1041,7 @@ mod tests {
+         })
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn write_close() {
+         each_ip(&mut |addr| {
+@@ -1065,6 +1068,7 @@ mod tests {
+         })
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn multiple_connect_serial() {
+         each_ip(&mut |addr| {
+@@ -1087,6 +1091,7 @@ mod tests {
+         })
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn multiple_connect_interleaved_greedy_schedule() {
+         const MAX: usize = 10;
+@@ -1123,6 +1128,7 @@ mod tests {
+     }
+ 
+     #[test]
++    #[cfg_attr(target_os = "macos", ignore)]
+     fn multiple_connect_interleaved_lazy_schedule() {
+         const MAX: usize = 10;
+         each_ip(&mut |addr| {
+@@ -1401,6 +1407,7 @@ mod tests {
+     }
+ 
+     #[test]
++    #[cfg_attr(target_os = "macos", ignore)]
+     fn clone_while_reading() {
+         each_ip(&mut |addr| {
+             let accept = t!(TcpListener::bind(&addr));
+@@ -1421,7 +1422,10 @@ mod tests {
+ 
+     // FIXME: re-enabled bitrig/openbsd tests once their socket timeout code
+     //        no longer has rounding errors.
+-    #[cfg_attr(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"), ignore)]
++    #[cfg_attr(any(target_os = "bitrig",
++                   target_os = "netbsd",
++                   target_os = "openbsd",
++                   target_os = "macos"), ignore)]
+     #[test]
+     fn timeouts() {
+         let addr = next_test_ip4();
+@@ -1596,6 +1603,7 @@ mod tests {
+         drop(listener);
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn nodelay() {
+         let addr = next_test_ip4();
+@@ -1610,6 +1618,7 @@ mod tests {
+         assert_eq!(false, t!(stream.nodelay()));
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn ttl() {
+         let ttl = 100;
+@@ -1647,6 +1656,7 @@ mod tests {
+         }
+     }
+ 
++    #[cfg_attr(target_os = "macos", ignore)]
+     #[test]
+     fn peek() {
+         each_ip(&mut |addr| {
+@@ -1679,6 +1689,7 @@ mod tests {
+     }
+ 
+     #[test]
++    #[cfg_attr(any(target_os = "linux", target_os = "macos"), ignore)]
+     fn connect_timeout_unroutable() {
+         // this IP is unroutable, so connections should always time out,
+         // provided the network is reachable to begin with.

artiq/pkgs/rust/patches/stdsimd-disable-doctest.patch

@@ -0,0 +1,20 @@
+diff --git a/src/stdsimd/coresimd/x86/mod.rs b/src/stdsimd/coresimd/x86/mod.rs
+index 32915c332..7cb54f31e 100644
+--- a/src/stdsimd/coresimd/x86/mod.rs
++++ b/src/stdsimd/coresimd/x86/mod.rs
+@@ -279,7 +279,6 @@ types! {
+     ///
+     /// # Examples
+     ///
+-    /// ```
+     /// # #![feature(cfg_target_feature, target_feature, stdsimd)]
+     /// # #![cfg_attr(not(dox), no_std)]
+     /// # #[cfg(not(dox))]
+@@ -301,7 +300,6 @@ types! {
+     /// # }
+     /// # if is_x86_feature_detected!("sse") { unsafe { foo() } }
+     /// # }
+-    /// ```
+     pub struct __m256(f32, f32, f32, f32, f32, f32, f32, f32);
+ 
+     /// 256-bit wide set of four `f64` types, x86-specific

artiq/pkgs/rust/print-hashes.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# All rust-related downloads can be found at
+# https://static.rust-lang.org/dist/index.html.  To find the date on
+# which a particular thing was last updated, look for the *-date.txt
+# file, e.g.
+# https://static.rust-lang.org/dist/channel-rust-beta-date.txt
+
+PLATFORMS=(
+  i686-unknown-linux-gnu
+  x86_64-unknown-linux-gnu
+  armv7-unknown-linux-gnueabihf
+  aarch64-unknown-linux-gnu
+  i686-apple-darwin
+  x86_64-apple-darwin
+)
+BASEURL=https://static.rust-lang.org/dist
+VERSION=${1:-}
+DATE=${2:-}
+
+if [[ -z $VERSION ]]
+then
+    echo "No version supplied"
+    exit -1
+fi
+
+if [[ -n $DATE ]]
+then
+    BASEURL=$BASEURL/$DATE
+fi
+
+for PLATFORM in "${PLATFORMS[@]}"
+do
+    URL="$BASEURL/rust-$VERSION-$PLATFORM.tar.gz.sha256"
+    SHA256=$(curl -sSfL $URL | cut -d ' ' -f 1)
+    echo "$PLATFORM = \"$SHA256\";"
+done

artiq/pkgs/rust/rust-src.nix

@@ -0,0 +1,11 @@
+{ stdenv, rustc }:
+
+stdenv.mkDerivation {
+  name = "rust-src";
+  src = rustc.src;
+  phases = [ "unpackPhase" "installPhase" ];
+  installPhase = ''
+    mv src $out
+    rm -rf $out/{ci,doc,driver,etc,grammar,llvm,rt,rtstartup,rustllvm,test,tools,vendor}
+  '';
+}

artiq/pkgs/rust/rustc.nix

@@ -0,0 +1,199 @@
+{ stdenv, targetPackages
+, fetchurl, fetchgit, fetchzip, file, python2, tzdata, ps
+, llvm, jemalloc, ncurses, darwin, rustPlatform, git, cmake, curl
+, which, libffi, gdb
+, version
+, forceBundledLLVM ? false
+, src
+, configureFlags ? []
+, patches
+, targets
+, targetPatches
+, targetToolchains
+, doCheck ? true
+, broken ? false
+, pkgs
+}:
+
+let
+  inherit (stdenv.lib) optional optionalString;
+  inherit (darwin.apple_sdk.frameworks) Security;
+
+  llvmShared = llvm.override { enableSharedLibraries = true; };
+  llvmOR1k = (import ../../default.nix {}).llvm-or1k;
+
+  target = builtins.replaceStrings [" "] [","] (builtins.toString targets);
+  src_rustc = fetchurl {
+    url = "https://static.rust-lang.org/dist/rustc-1.28.0-src.tar.gz";
+    sha256 = "11k4rn77bca2rikykkk9fmprrgjswd4x4kaq7fia08vgkir82nhx";
+  };
+
+in
+
+stdenv.mkDerivation {
+  name = "rustc-${version}";
+  inherit version;
+
+  inherit src;
+
+  __darwinAllowLocalNetworking = true;
+
+  # rustc complains about modified source files otherwise
+  dontUpdateAutotoolsGnuConfigScripts = true;
+
+  # Running the default `strip -S` command on Darwin corrupts the
+  # .rlib files in "lib/".
+  #
+  # See https://github.com/NixOS/nixpkgs/pull/34227
+  stripDebugList = if stdenv.isDarwin then [ "bin" ] else null;
+
+  NIX_LDFLAGS = optionalString stdenv.isDarwin "-rpath ${llvmShared}/lib";
+