# Firmware configuration file for the Raspberry Pi

# Default paths if not specified via the commandline
define(ROOTFS, "${NERVES_SYSTEM}/images/rootfs.squashfs")

# This configuration file will create an image that
# has an MBR and the following 3 partitions:
#
# +----------------------------+
# | MBR                        |
# +----------------------------+
# | p0: Boot partition (FAT32) |
# | zImage, bootcode.bin,      |
# | config.txt, etc.           |
# +----------------------------+
# | p1*: Rootfs A (squashfs)   |
# +----------------------------+
# | p1*: Rootfs B (squashfs)   |
# +----------------------------+
# | p2: Application (FAT32)    |
# +----------------------------+
#
# The p1 partition points to whichever of Rootfs A or B that
# is active.
#
# The image is sized to be less than 1 GB so that it fits on
# nearly any SDCard around. If you have a larger SDCard and
# need more space, feel free to bump the partition sizes
# below.

# The Raspberry Pi is incredibly picky on the partition sizes
# and in ways that I don't understand. Test changes one at a
# time to make sure that they boot. (Sizes are in 512 byte
# blocks)
define(BOOT_PART_OFFSET, 63)
define(BOOT_PART_COUNT, 77261)

# Let the rootfs have room to grow up to 128 MiB and align
# it to the nearest 1 MB boundary
define(ROOTFS_A_PART_OFFSET, 77324)
define(ROOTFS_A_PART_COUNT, 289044)
define(ROOTFS_B_PART_OFFSET, 366368)
define(ROOTFS_B_PART_COUNT, 289044)

# Application partition. This partition can occupy all of the
# remaining space. Size it to fit the destination.
define(APP_PART_OFFSET, 655412)
define(APP_PART_COUNT, 1048576)

# Firmware metadata
meta-product = "Nerves Firmware"
meta-description = ""
meta-version = ${NERVES_SDK_VERSION}
meta-platform = "rpi"
meta-architecture = "arm"
meta-author = "Frank Hunleth"

# File resources are listed in the order that they are included in the .fw file
# This is important, since this is the order that they're written on a firmware
# update due to the event driven nature of the update system.
file-resource bootcode.bin {
    host-path = "${NERVES_SYSTEM}/images/rpi-firmware/bootcode.bin"
}
file-resource fixup.dat {
    host-path = "${NERVES_SYSTEM}/images/rpi-firmware/fixup.dat"
}
file-resource start.elf {
    host-path = "${NERVES_SYSTEM}/images/rpi-firmware/start.elf"
}
file-resource config.txt {
    host-path = "${NERVES_SYSTEM}/images/config.txt"
}
file-resource cmdline.txt {
    host-path = "${NERVES_SYSTEM}/images/cmdline.txt"
}
file-resource zImage {
    # All Nerves configs use the DT kernel, but if you don't want it, remove
    # the .mkknlimg part of the next line.
    host-path = "${NERVES_SYSTEM}/images/zImage.mkknlimg"
}
file-resource bcm2708-rpi-b.dtb {
    host-path = "${NERVES_SYSTEM}/images/bcm2708-rpi-b.dtb"
}
file-resource bcm2708-rpi-b-plus.dtb {
    host-path = "${NERVES_SYSTEM}/images/bcm2708-rpi-b-plus.dtb"
}
file-resource w1-gpio-pullup-overlay.dtb {
    host-path = "${NERVES_SYSTEM}/images/rpi-firmware/overlays/w1-gpio-pullup-overlay.dtb"
}

file-resource rootfs.img {
    host-path = ${ROOTFS}
}

mbr mbr-a {
    partition 0 {
        block-offset = ${BOOT_PART_OFFSET}
        block-count = ${BOOT_PART_COUNT}
        type = 0xc # FAT32
        boot = true
    }
    partition 1 {
        block-offset = ${ROOTFS_A_PART_OFFSET}
        block-count = ${ROOTFS_A_PART_COUNT}
        type = 0x83 # Linux
    }
    partition 2 {
        block-offset = ${APP_PART_OFFSET}
        block-count = ${APP_PART_COUNT}
        type = 0xc # FAT32
    }
    # partition 3 is unused
}

mbr mbr-b {
    partition 0 {
        block-offset = ${BOOT_PART_OFFSET}
        block-count = ${BOOT_PART_COUNT}
        type = 0xc # FAT32
        boot = true
    }
    partition 1 {
        block-offset = ${ROOTFS_B_PART_OFFSET}
        block-count = ${ROOTFS_B_PART_COUNT}
        type = 0x83 # Linux
    }
    partition 2 {
        block-offset = ${APP_PART_OFFSET}
        block-count = ${APP_PART_COUNT}
        type = 0xc # FAT32
    }
    # partition 3 is unused
}

# This firmware task writes everything to the destination media
task complete {
    # Only match if not mounted
    require-unmounted-destination = true

    # Everything that gets written can be verified on the fly.
    # This speeds things up, since we don't care about detecting
    # errors before data gets written.
    verify-on-the-fly = true

    on-init {
        mbr_write(mbr-a)

        fat_mkfs(${BOOT_PART_OFFSET}, ${BOOT_PART_COUNT})
        fat_setlabel(${BOOT_PART_OFFSET}, "BOOT")
        fat_mkdir(${BOOT_PART_OFFSET}, "overlays")
    }

    on-resource config.txt { fat_write(${BOOT_PART_OFFSET}, "config.txt") }
    on-resource cmdline.txt { fat_write(${BOOT_PART_OFFSET}, "cmdline.txt") }
    on-resource bootcode.bin { fat_write(${BOOT_PART_OFFSET}, "bootcode.bin") }
    on-resource start.elf { fat_write(${BOOT_PART_OFFSET}, "start.elf") }
    on-resource fixup.dat { fat_write(${BOOT_PART_OFFSET}, "fixup.dat") }
    on-resource zImage { fat_write(${BOOT_PART_OFFSET}, "zImage") }
    on-resource bcm2708-rpi-b.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb") }
    on-resource bcm2708-rpi-b-plus.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb") }
    on-resource w1-gpio-pullup-overlay.dtb { fat_write(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb") }

    on-resource rootfs.img {
        # write to the first rootfs partition
        raw_write(${ROOTFS_A_PART_OFFSET})
    }

    on-finish {
        # Initialize a big partition for application data
        # This is done last so that the boot partition can be written to completely
        # before the first write to this partition. Not skipping back and forth between
        # FAT filesystems saves a little time when programming the Flash.
        fat_mkfs(${APP_PART_OFFSET}, ${APP_PART_COUNT})
        fat_setlabel(${APP_PART_OFFSET}, "APPDATA")
    }
}

task upgrade.a {
    # This task upgrades the A partition
    require-partition1-offset = ${ROOTFS_B_PART_OFFSET}

    # Since the upgrade won't run until it has been finalized, it's ok
    # to write data as it is read.
    verify-on-the-fly = true

    on-init {
        # Erase any old saved files from previous upgrades
        fat_rm(${BOOT_PART_OFFSET}, "zImage.pre")
        fat_rm(${BOOT_PART_OFFSET}, "config.txt.pre")
        fat_rm(${BOOT_PART_OFFSET}, "cmdline.txt.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bootcode.bin.pre")
        fat_rm(${BOOT_PART_OFFSET}, "start.elf.pre")
        fat_rm(${BOOT_PART_OFFSET}, "fixup.dat.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.pre")

        # Make the overlays directory in case it isn't already there.
        fat_mkdir(${BOOT_PART_OFFSET}, "overlays")
        fat_rm(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.pre")
    }

    # Write the new firmware and Linux images, but don't
    # commit them. That way if the user aborts midway, we
    # still are using the original firmware.
    on-resource config.txt { fat_write(${BOOT_PART_OFFSET}, "config.txt.new") }
    on-resource cmdline.txt { fat_write(${BOOT_PART_OFFSET}, "cmdline.txt.new") }
    on-resource bootcode.bin { fat_write(${BOOT_PART_OFFSET}, "bootcode.bin.new") }
    on-resource start.elf { fat_write(${BOOT_PART_OFFSET}, "start.elf.new") }
    on-resource fixup.dat { fat_write(${BOOT_PART_OFFSET}, "fixup.dat.new") }
    on-resource zImage { fat_write(${BOOT_PART_OFFSET}, "zImage.new") }
    on-resource bcm2708-rpi-b.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new") }
    on-resource bcm2708-rpi-b-plus.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new") }
    on-resource w1-gpio-pullup-overlay.dtb { fat_write(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new") }

    on-resource rootfs.img {
        # write to the first rootfs partition
        raw_write(${ROOTFS_A_PART_OFFSET})
    }

    on-finish {
	# Switch over to boot the new firmware
        mbr_write(mbr-a)

        fat_mv(${BOOT_PART_OFFSET}, "zImage", "zImage.pre")
        fat_mv(${BOOT_PART_OFFSET}, "config.txt", "config.txt.pre")
        fat_mv(${BOOT_PART_OFFSET}, "cmdline.txt", "cmdline.txt.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bootcode.bin", "bootcode.bin.pre")
        fat_mv(${BOOT_PART_OFFSET}, "start.elf", "start.elf.pre")
        fat_mv(${BOOT_PART_OFFSET}, "fixup.dat", "fixup.dat.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb", "bcm2708-rpi-b.dtb.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb", "bcm2708-rpi-b-plus.dtb.pre")
        fat_mv(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb", "overlays/w1-gpio-pullup-overlay.dtb.pre")

        fat_mv(${BOOT_PART_OFFSET}, "zImage.new", "zImage")
        fat_mv(${BOOT_PART_OFFSET}, "config.txt.new", "config.txt")
        fat_mv(${BOOT_PART_OFFSET}, "cmdline.txt.new", "cmdline.txt")
        fat_mv(${BOOT_PART_OFFSET}, "bootcode.bin.new", "bootcode.bin")
        fat_mv(${BOOT_PART_OFFSET}, "start.elf.new", "start.elf")
        fat_mv(${BOOT_PART_OFFSET}, "fixup.dat.new", "fixup.dat")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new", "bcm2708-rpi-b.dtb")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new", "bcm2708-rpi-b-plus.dtb")
        fat_mv(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new", "overlays/w1-gpio-pullup-overlay.dtb")
    }

    on-error {
        # Clean up in case something goes wrong
        fat_rm(${BOOT_PART_OFFSET}, "zImage.new")
        fat_rm(${BOOT_PART_OFFSET}, "config.txt.new")
        fat_rm(${BOOT_PART_OFFSET}, "cmdline.txt.new")
        fat_rm(${BOOT_PART_OFFSET}, "bootcode.bin.new")
        fat_rm(${BOOT_PART_OFFSET}, "start.elf.new")
        fat_rm(${BOOT_PART_OFFSET}, "fixup.dat.new")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new")
        fat_rm(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new")
    }
}

task upgrade.b {
    # This task upgrades the B partition
    require-partition1-offset = ${ROOTFS_A_PART_OFFSET}

    # Since the upgrade won't run until it has been finalized, it's ok
    # to write data as it is read.
    verify-on-the-fly = true

    on-init {
        fat_rm(${BOOT_PART_OFFSET}, "zImage.pre")
        fat_rm(${BOOT_PART_OFFSET}, "config.txt.pre")
        fat_rm(${BOOT_PART_OFFSET}, "cmdline.txt.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bootcode.bin.pre")
        fat_rm(${BOOT_PART_OFFSET}, "start.elf.pre")
        fat_rm(${BOOT_PART_OFFSET}, "fixup.dat.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.pre")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.pre")

        fat_mkdir(${BOOT_PART_OFFSET}, "overlays")
        fat_rm(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.pre")
    }

    on-resource config.txt { fat_write(${BOOT_PART_OFFSET}, "config.txt.new") }
    on-resource cmdline.txt { fat_write(${BOOT_PART_OFFSET}, "cmdline.txt.new") }
    on-resource bootcode.bin { fat_write(${BOOT_PART_OFFSET}, "bootcode.bin.new") }
    on-resource start.elf { fat_write(${BOOT_PART_OFFSET}, "start.elf.new") }
    on-resource fixup.dat { fat_write(${BOOT_PART_OFFSET}, "fixup.dat.new") }
    on-resource zImage { fat_write(${BOOT_PART_OFFSET}, "zImage.new") }
    on-resource bcm2708-rpi-b.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new") }
    on-resource bcm2708-rpi-b-plus.dtb { fat_write(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new") }
    on-resource w1-gpio-pullup-overlay.dtb { fat_write(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new") }

    on-resource rootfs.img {
        # write to the first rootfs partition
        raw_write(${ROOTFS_B_PART_OFFSET})
    }

    on-finish {
	# Switch over to boot the new firmware
        mbr_write(mbr-b)

        fat_mv(${BOOT_PART_OFFSET}, "zImage", "zImage.pre")
        fat_mv(${BOOT_PART_OFFSET}, "config.txt", "config.txt.pre")
        fat_mv(${BOOT_PART_OFFSET}, "cmdline.txt", "cmdline.txt.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bootcode.bin", "bootcode.bin.pre")
        fat_mv(${BOOT_PART_OFFSET}, "start.elf", "start.elf.pre")
        fat_mv(${BOOT_PART_OFFSET}, "fixup.dat", "fixup.dat.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb", "bcm2708-rpi-b.dtb.pre")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb", "bcm2708-rpi-b-plus.dtb.pre")
        fat_mv(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb", "overlays/w1-gpio-pullup-overlay.dtb.pre")

        fat_mv(${BOOT_PART_OFFSET}, "zImage.new", "zImage")
        fat_mv(${BOOT_PART_OFFSET}, "config.txt.new", "config.txt")
        fat_mv(${BOOT_PART_OFFSET}, "cmdline.txt.new", "cmdline.txt")
        fat_mv(${BOOT_PART_OFFSET}, "bootcode.bin.new", "bootcode.bin")
        fat_mv(${BOOT_PART_OFFSET}, "start.elf.new", "start.elf")
        fat_mv(${BOOT_PART_OFFSET}, "fixup.dat.new", "fixup.dat")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new", "bcm2708-rpi-b.dtb")
        fat_mv(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new", "bcm2708-rpi-b-plus.dtb")
        fat_mv(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new", "overlays/w1-gpio-pullup-overlay.dtb")
    }

    on-error {
        # Clean up in case something goes wrong
        fat_rm(${BOOT_PART_OFFSET}, "zImage.new")
        fat_rm(${BOOT_PART_OFFSET}, "config.txt.new")
        fat_rm(${BOOT_PART_OFFSET}, "cmdline.txt.new")
        fat_rm(${BOOT_PART_OFFSET}, "bootcode.bin.new")
        fat_rm(${BOOT_PART_OFFSET}, "start.elf.new")
        fat_rm(${BOOT_PART_OFFSET}, "fixup.dat.new")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b.dtb.new")
        fat_rm(${BOOT_PART_OFFSET}, "bcm2708-rpi-b-plus.dtb.new")
        fat_rm(${BOOT_PART_OFFSET}, "overlays/w1-gpio-pullup-overlay.dtb.new")
    }
}
