Chromebook (Anywhere)

Chromebooks were an obvious target for Ultramarine Anywhere, despite being mostly standard hardware, they have custom EC and strange firmware.

Chromebook support in Ultramarine Linux is provided in partnership with the Chrultrabook Project.

x86

How it Works

Ultramarine Chromebook Edition uses a special bootloader called Submarine to load the kernel.

Under the hood, Submarine is an incredibly minimal Linux OS based on u-root, it’s only really usable for debug and booting a full distribution. Once Submarine is loaded, we use LinuxBoot to boot a full copy of Ultramarine (and hopefully more distros in the future).

Now for the big question, how do we do this without modifying the firmware? We take advantage of the way Depthcharge (the ChromeOS firmware) works. We store Submarine in a 16MiB partition on disk, this is normally used by ChromeOS to store a full ChromeOS Kernel and initramfs. Depthcharge doesn’t actually check if the contents of the partition are a valid kernel, it just checks for a GPT Header and runs whatever code is found in the partition, in our case, Submarine.

By default, Depthcharge will only boot code with Google’s signing keys, we get around this by enabling the built-in ChromeOS developer mode.

To summarise, we boot a tiny Linux distribution (Submarine) and use it to launch Ultramarine’s vmlinuz and initramfs using kexec.

Userland Changes

Devices in Ultramarine Anywhere try to stick very closely to the standard Ultramarine userland, sometimes we have to deviate from this to make the experience better.

Audio Support

We use WeirdTreeThing’s audio script and kernel patch to make audio work properly.

Default Partitions

On Chromebooks, we disable swap to extend the life of the eMMC found in most Chromebooks. We create a 16MiB partition containing Submarine at the start of the disk instead of /boot/EFI and /boot

Keyboard Mapping

We use keyd to map keys on Chromebooks.

Feature Matrix

Unsupported Devices

These are among the first few generations of Chromebooks, and either use an unsupported firmware, or have limitations preventing us from booting a partition large enough to fit Submarine.

Installation

Chromebook Edition will be released soon, installation guide for that will be found on a seperate menu in this wiki at the time of release.

Manual Installation - Note that Ultramarine Chromebook Edition will be a much easier experience once released

This guide assumes you are on x86 and have Developer Mode and USB Booting Enabled. We also assume you are using GParted for partitioning tasks. There are alterations you could make to these instructions and still get the same result, this is just what we think is the easiest way.

Raw (.img) images:

1. Download, decompress, and flash an Ultramarine Raw Image with a desktop environment (for example, flagship-base-disk-x86_64.img), to a USB Drive or SD Card smaller then the internal disk of your Chromebook.
2. Create a 16MB partition at the END of the disk (for proper resizing after installation). In GParted, do this by making a new partition in the unallocated space, and dragging it all the way to the right while still in the ‘Create new Partition’ menu. If GParted gives you a ‘Libparted Warning,’ select ‘Fix.‘
3. Flash the submarine-x86.kpart file to the new partition.
4. Set the partition flags with cgpt (may have to install vboot-utils).

sudo cgpt add -i <Submarine partition number> -t kernel -P 15 -T 1 -S 1 /dev/sdX

5. Boot the image on the Chromebook.

You’re now inside the Ultramarine install on your USB/SD card. Slowness and lag is expected behavior and does not reflect how Ultramarine will run from internal storage.

6. Use dd to copy the contents of the USB/SD card to the internal storage of the Chromebook.

If you need help with dd syntax, here are some pointers -

You’re most likely using a USB stick to install to an eMMC Chromebook, which is the command listed below. If you would like to see what devices you have, run lsblk in the terminal. If both show as the same device type, remember the USB/SD Card should be the smaller one. To see what different devices present as, go here.

dd if=/dev/sda of=/dev/mmcblk0 bs=4M status=progress

‘if’ is the input file. ‘/dev/sda’ is the USB stick. ‘of’ is the output file. ‘/dev/mmcblk0’ is the Chromebook’s internal eMMC storage. ‘bs=4M’ changes the block size from the default 512Bs to 4MBs (makes it transfer faster). ‘status=progress’ shows the transfer progress in real time.

If you’re using other devices, adjust accordingly. If your’re using an SD card to install to eMMC, or a USB stick to install to UFS, both devices will show as ‘mmcblkX’ (mmcblk 0/1/2), and ‘sdX’ (sd a/b/c). Adjust the numbers/letters accordingly.

7. Once dd is done, verify the Submarine partition on the internal storage shows ‘ChromeOS Kernel’ as a flag. You can use the Disks app on Flagship, GNOME, and Xfce, or, KDE Partition Manager on KDE. Simply select the disk and partition, the label should appear under the logical view.

ISO Images:

1. Flash an Ultramarine ISO Image to a USB Drive or SD Card.
2. Flash submarine.bin to another USB Drive or SD Card.
3. Plug in both drives you just flashed to the Chromebook (a USB hub works!).
4. Boot to the installer’s live emvironment by pressing Ctrl+U (You shouldn’t boot to a boot option that lists a kernel version (ex ultramarine-linux-6.10.0-X-X-X), just boot to ‘Ultramarine Linux EDITION.’ If you still have ChromeOS on the internel disk, it is likely that this will be the 14th entry, if not, it may be the 3rd). If it does not boot, restart and try a different Ultramarine Linux entry.
5. In the live enviornment of the ISO, install as normal.
6. Once the install is done, return to the live environment desktop. Make a new 16MiB ext4 partition, this can be done by resizing the ‘root’ partition (the largest one).
7. flash submarine.kpart to the new partition, and set flags with cgpt (may have to install vboot-utils).

cgpt add -i <partition number> -t kernel -P 15 -T 1 -S 1 /dev/sdX

11. Done!

ARM

ARM Chromebooks are in heavy development. If you’d like to help test, check out the ARM Beta Program.