Chromebook
Related articles
This article was created to provide information on how to get Arch installed on the Chromebook series of laptops built by Acer, HP, Samsung, Toshiba, and Google. Currently this page is being overhauled, and more model specific pages are being built with some of the information listed below.
Contents
- 1 Introduction
- 2 Chromebook Models
- 3 Installation
- 4 Post Installation Configuration
- 5 Firmware Write Protection
- 6 Custom Firmware
- 7 Known issues
- 8 See also
Introduction
Legacy Boot
Newer Chromebooks feature a "legacy boot" mode that makes it easier to boot Linux and other operating systems. The legacy boot mode is provided by the SeaBIOS payload of Coreboot, which is the firmware for the Intel based Chromebooks (with the exception of the first generation of Chromebooks). SeaBIOS behaves like a traditional BIOS that boots into the MBR of the disk, and from there into standard bootloaders like Syslinux and GRUB.
On the Chromebooks that shipped with SeaBIOS, the installation process of Arch Linux should be similar with a few minor adjustments.
Models Without SeaBIOS
Older models, as well as some newer models, aren't shipped with SeaBIOS as part of the installed firmware. There are three approaches that can be taken when installing Arch Linux on these devices:
- Flash a custom firmware with SeaBIOS.
- Take the ChrUbuntu approach which uses the Chrome OS kernel and modules.
- Build and sign your own kernel, see [1] [2].
The Installation process described on this page tries to cover the method of installing Arch Linux on these non SeaBIOS models by flashing a custom firmware.
First Generation of Chromebooks
The first generation of Chromebooks: Google Cr-48, Samsung Series 5 500 and Acer AC700 use Insyde H2O firmware and not Coreboot firmware. There are three approaches how to install Arch Linux on these devices:
- Flash a custom H2C firmware (only available for Google Cr-48) and install Arch as on any other UEFI laptop.
- Take the ChrUbuntu approach which uses the Chrome OS kernel and modules.
- Build and sign your own kernel, see [3].
Firmware Write Protection Intro
All Chromebooks features a firmware write protection. It's important to be aware of it as one might need to disable the write protection as part of the installation process (to update GBB flags or flash a custom firmware).
For more details see Firmware Write Protection.
Prerequisites
- You should claim your free 100GB-1TB of Google Drive space before you install Arch. This needs to happen from ChromeOS(version > 23), not linux. This will sync/backup ChromeOS, as designed
- Visit the ArchWiki page for your Chromebook, see Chromebook Models.
- If there's no ArchWiki page for your device then before proceeding, gather information about the device and if you succeed in installing Arch Linux, then consider adding a new ArchWiki page for your model (you can use the Acer C720 as an example for device shipped with SeaBios or the Acer C710 as device that didn't shipped with it).
- Read this guide completely and make sure you understand all the steps before making any changes.
Chromebook Models
Hardware Comparisons
Available | Brand | Model | Processor | RAM | Storage | Upgradable | Screen | Resolution | Weight | SeaBIOS | Remarks |
---|---|---|---|---|---|---|---|---|---|---|---|
Dec 2010 | Cr-48 | 1.66 GHz Intel Atom N455 | 2GB DDR3 |
16GB SSD | mSATA | 12.1 in (30.7 cm) |
1280x800 (16:10) |
3.8 lb (1.7 kg) |
Unavailable for 1st generation |
Custom H2C firmware available |
|
Jun 2011 | Samsung | Series 5 XE500C21 |
1.66 GHz Intel Atom N570 | mSATA | 3.06-3.26 lb (1.4–1.5 kg) |
Unavailable for 1st generation |
|||||
Jul 2011 | Acer | AC700 | mSATA Mini |
11.6 in (29.5 cm) |
1366x768 (16:9) |
3.19 lb (1.4 kg) |
Unavailable for 1st generation |
||||
May 2012 | Samsung | Series 5 XE550C22 |
1.3 GHz Intel Celeron 867 1.6 Ghz Intel Core i5 2467M |
4GB DDR3 |
mSATA | 12.1 in (30.7 cm) |
1280x800 (16:10) |
3.3 lb (1.5 kg) |
In custom firmware only |
||
Oct 2012 | Series 3 XE303C12 |
1.7 GHz Samsung Exynos 5250 | 2GB DDR3 |
16GB eMMC | No | 11.6 in (29.5 cm) |
1366x768 (16:9) |
2.43 lb (1.1 kg) |
Unavailable on ARM |
Supported by Arch Linux ARM |
|
Nov 2012 | Acer | C710 | 1.1 GHz Intel Celeron 847 1.5 GHz Intel Celeron 1007U |
2-4GB DDR3 |
320GB HDD 16GB SSD |
SATA 2.5" 7,9.5mm |
3-3.05 lb (1.4 kg) |
In custom firmware only |
|||
Feb 2013 | HP | Pavilion 14 Chromebook |
1.1 GHz Intel Celeron 847 | SATA 2.5" 7,9.5mm |
14 in (35.6 cm) |
3.96 lb (1.8 kg) |
In custom firmware only |
Service Manual | |||
Lenovo | ThinkPad X131e Chromebook |
1.5 GHz Intel Celeron 1007U | 4GB DDR3 |
16GB SSD | mSATA | 11.6 in (29.5 cm) |
3.92 lb (1.8 kg) |
In custom firmware only |
|||
Chromebook Pixel |
1.8 GHz Intel Core i5 3427U | 4GB DDR3 |
32GB iSSD 64GB iSSD |
No | 12.85 in (32.6 cm) |
2560x1700 (3:2) |
3.35 lb (1.5 kg) |
Yes | |||
Oct 2013 | HP | Chromebook 11 | 1.7 GHz Samsung Exynos 5250 | 2GB DDR3 |
16GB eMMC | No | 11.6 in (29.5 cm) |
1366x768 (16:9) |
2.3 lb (1.04 kg) |
Unavailable on ARM |
Unsupported by Arch Linux ARM installation identical to Samsung XE303C12 |
Nov 2013 | Chromebook 14 | 1.4 GHz Intel Celeron 2955U | 2GB DDR3 4GB DDR3 |
16GB SSD 32GB SSD |
42mm M.2 NGFF |
14 in ( 35.6 cm) |
4.07 lb (1.84 kg) |
Yes | |||
Acer | C720/C720P Chromebook |
1.4 GHz Intel Celeron 2955U 1.7 GHz Intel Core i3-4005U |
42mm M.2 NGFF |
11.6 in (29.5 cm) |
2.76 lb (1.25 kg) |
Yes | |||||
Jan 2014 | Toshiba | CB30/CB35 Chromebook |
1.4 GHz Intel Celeron 2955U | 2GB DDR3 | 16GB eMMC | No | 13.3 in (33.8 cm) |
3.3 lb (1.5 kg) |
Yes | ||
Apr 2014 | Dell | Chromebook 11 | 1.4 GHz Intel Celeron 2955U 1.7 GHz Intel Core i3-4005U |
2GB DDR3 4GB DDR3 |
16GB | No | 11.6 in (29.5 cm) |
2.9 lb (1.31 kg) |
Yes | Requires stock SeaBIOS patching |
|
Jun 2014 | Lenovo | N20/N20P Chromebook |
2.1 GHz Intel BayTrail-M N2830 | 2GB DDR3 | 16GB eMMC | No | 11.6 in (29.5 cm) |
2.86 lb (1.3 kg) |
No | Custom firmware not available yet |
|
Asus | Chromebook C200/C300 |
2GB DDR3 4GB DDR3 |
16GB eMMC 32GB eMMC |
No | 11.6 in (29.5 cm) 13.3 in (33.8 cm) |
2.5 lb (1.13 kg) 3.1 lb (1.4 kg) |
No | Custom firmware not available yet |
|||
Lenovo | ThinkPad 11e Chromebook |
1.83 GHz Intel BayTrail-M N2930 | 4GB DDR3 | 16GB eMMC | No | 11.6 in (29.5 cm) |
3.1 lb (1.4 kg) |
No | Custom firmware not available yet |
||
ThinkPad Yoga 11e Chromebook |
No | No | Custom firmware not available yet |
||||||||
Samsung | Chromebook 2 XE503C12/C32 |
1.9 GHz Exynos 5 Octa 5420 2 GHz Exynos 5 Octa 5800 |
No | 11.6 in (29.5 cm) 13.3 in (33.8 cm) |
1366x768 (16:9) 1920x1080 (16:9) |
2.65 lb (1.2 kg) 3.06 lb (1.39 kg) |
Unavailable on ARM |
Supported by Arch Linux ARM |
|||
Jul 2014 | HEXA | Chromebook Pi | 2.1 GHz Intel BayTrail-M N2830 | 32GB eMMC | No | 11.6 in (29.5 cm) |
1366x768 (16:9) |
2.6 lb (1.18 kg) |
No | Custom firmware not available yet |
|
Aug 2014 | Acer | CB5-311 Chromebook 13 |
2.1 GHz Nvidia Tegra K1 | 2GB DDR3 4GB DDR3 |
16GB eMMC 32GB eMMC |
No | 13.3 in (33.8 cm) |
1366x768 (16:9) 1920x1080 (16:9) |
3.3 lb (1.5 kg) |
Unavailable on ARM |
Unsupported by Arch Linux ARM |
Sep 2014 | Toshiba | CB30/CB35 Chromebook 2 |
2.16 GHz Intel BayTrail-M N2840 | 16GB eMMC | No | 2.96 lb (1.34 kg) |
No | Custom firmware not available yet |
|||
Acer | CB3-111 Chromebook 11 |
2.1 GHz Intel BayTrail-M N2830 | 2GB DDR3 | 16GB eMMC | No | 11.6 in (29.5 cm) |
1366x768 (16:9) |
2.4 lb (1.09 kg) |
No | Custom firmware not available yet |
|
Oct 2014 | HP | Chromebook 14 G3 |
2.1 GHz Nvidia Tegra K1 | 2GB DDR3 4GB DDR3 |
16GB eMMC 32GB eMMC |
No | 14 in (35.6 cm) |
1366x768 (16:9) 1920x1080 (16:9) |
3.79 lb (1.72 kg) |
Unavailable on ARM |
Unsupported by Arch Linux ARM |
Chromebook 11 G3 |
2.16 GHz Intel BayTrail-M N2840 | 16GB eMMC | No | 11.6 in (29.5 cm) |
1366x768 (16:9) |
2.8 lb (1.28 kg) |
No | Custom firmware not available yet |
|||
Samsung | Chromebook 2 XE500C12 |
2GB DDR3 | No | 2.65 lb (1.2 kg) |
No | Custom firmware not available yet |
Remarks for the Hardware Comparison Table
- Bay-Trail-M models: It seems like all the models missing SeaBIOS payload of Coreboot.
- Bay-Trail-M models: There was no success yet in compiling a working custom Coreboot firmware with SeaBIOS payload that can run a mainline kernel. Attempts to solve the existing issues are being made, more info available at the coreboot on Chromebooks Google+ community.
- MyDigitalSSD M.2 NGFF SSD drives are probably the most popular choice when upgrading the internal SSD of a Chromebook. There are multiple accounts of failing MyDigitalSSD SSD drives at the Acer C720 topic on the Arch forums [4] [5] [6] and much more on the web. If the SSD was upgraded to a MyDigitalSSD model then it's highly recommended to backup the system and data frequently. It might be advisable to upgrade the SDD with a different brand.
Installation
The general installation procedure:
- Enable developer mode.
- Chromebook with SeaBIOS:
- Enable legacy boot / SeaBIOS.
- Set SeaBIOS as default (optional but recommended, requires disabling the write protection).
- Chromebook without SeaBIOS:
- Flash a custom firmware.
- Prepare the installation media, another Linux machine may be needed to manually create the 64-bit media.
- Boot Arch Linux installation media and install Arch.
Enabling Developer Mode
Developer Mode is necessary in order to access the superuser shell inside Chrome OS, which is required for making changes to the system like allow booting through SeaBIOS.
To enable Developer Mode:
- Turn on the Chromebook.
- Press and hold the
Esc + F3 (Refresh)
keys, then press thePower
button. This enters Recovery Mode. - Press
Ctrl + D
(no prompt). It will ask you to confirm, then the system will revert its state and enable Developer Mode.
Accessing the superuser shell
After you have enabled the Developer Mode you will need to access the superuser shell. How you do this depends on whether you've configured Chrome OS or not.
Accessing the Superuser shell without Chrome OS configuration
If you haven't configured Chrome OS, just press Ctrl + Alt + F2
(F2 is the "forward" arrow on the top row, →), you'll see a login prompt.
- Use
chronos
as the username, it should not prompt you for a password. - Become superuser with
sudo bash
.
Accessing the superuser shell with Chrome OS configuration
If you have configured Chrome OS already:
- Open a crosh window with
Ctrl + Alt + T
. - Open a bash shell with the
shell
command. - Become superuser with
sudo bash
Enabling SeaBIOS
If your Chromebook didn't ship with SeaBIOS or you prefer to install a custom firmware, then continue to Custom Firmware.
This method will allow you to access the pre-installed version of SeaBIOS through the Developer Mode screen in Coreboot.
- Inside your superuser shell enter:
# crossystem dev_boot_usb=1 dev_boot_legacy=1
- Reboot the machine.
You can now start SeaBIOS by pressing Ctrl + L
at the white boot splash screen.
You should now have SeaBIOS enabled on your Chromebook, if you choose to not set it as default then you can continue to Installing Arch Linux.
Boot to SeaBIOS by default
To boot SeaBIOS by default, you will need to run set_gbb_flags.sh
in Chrome OS (already included in Chrome OS, it won't work correctly in Arch Linux).
- Disable the hardware write protection.
See the Disabling the Hardware Write Protection at the Firmware Write Protection topic.
- Inside your superuser shell enter:
# sudo su
- Disable the software write protection.
# flashrom --wp-disable
- Check that write protection is disabled.
# flashrom --wp-status
- Run
set_gbb_flags.sh
with no parameters.
# set_gbb_flags.sh
- Make sure you get the following output, see [7].
GBB_FLAG_DEV_SCREEN_SHORT_DELAY 0x00000001 GBB_FLAG_FORCE_DEV_SWITCH_ON 0x00000008 GBB_FLAG_FORCE_DEV_BOOT_LEGACY 0x00000080 GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY 0x00000400
- Now set SeaBIOS as default.
# set_gbb_flags.sh 0x489
- Enable back the software write protection.
# flashrom --wp-enable
Your Chromebook now will boot to SeaBIOS by default, you can continue to Installing Arch Linux, if your device is booting correctly then you should re-enable the hardware write protection.
Flashing Custom Firmware
Follow the Custom Firmware topic which explains how to flash a custom firmware.
After flashing the firmware you can continue to Installing Arch Linux.
Installing Arch Linux
Preparing the installation media
32-bit installation
Create an Arch Linux Installer USB drive.
64-bit installation
Option 1: Adding GRUB to the installation image
The instructions below outline a method of modifying the image so that it will boot properly and a 64-bit installation can be performed.
Create a new FAT32 partition on your USB drive e.g. with gparted and label it as ArchLinux
.
- Mount the new partition (replace x with the correct letter as shown with sudo fdisk -l and username with your own username)
# mount /dev/sdx1 /mnt/ -o uid=username,gid=users
Install GRUB2 on the USB drive
# grub-install --no-floppy --root-directory=/mnt /dev/sdx
Create a new directory in /mnt/boot where 'YYYYMMDD' is the year, month, and day, of the ISO being used, respectively
# /mnt/boot/archlinux-YYYYMMDD-dual
Mount the ISO
$ mkdir ~/iso # mount -o loop archlinux-YYYY.MM.DD-dual.iso ~/iso
Copy the mounted files to the usb drive
$ cp -r ~/iso/arch/* /mnt/boot/archlinux-YYYYMMDD-dual
Create the grub.cfg file
/mnt/boot/grub/grub.cfg
menuentry "Arch Linux 64 Bit" { linux /boot/archlinux-YYYYMMDD-dual/boot/x86_64/vmlinuz archisobasedir=/boot/archlinux-YYYYMMDD-dual archisolabel=ArchLinux initrd /boot/archlinux-YYYYMMDD-dual/boot/x86_64/archiso.img }
You can then boot the installation image as normal and follow the normal installation instructions.
Option 2: Flashing John Lewis' Firmware
It has been reported that flashing John Lewis's coreboot first has allowed installation from the official image to be made possible without modifying the install image. Read the section on flashing custom firmware and follow the instructions on flashing using John Lewis' script. Especially pay careful attention to the disadvantages of flashing custom firmware. If you decide to proceed with this option, you will just create a USB drive with the installation medium as normal after flashing the new coreboot and install as normal.
Booting the installation media
- Plug the USB drive to the Chromebook and start SeaBIOS with
Ctrl + L
at the white boot splash screen (if SeaBIOS isn't set as default). - Press
Esc
to get a boot menu and select the number corresponding to your USB drive.
The Arch Linux installer boot menu should appear and the installation process can proceed as normal.
After finishing installing Arch Linux continue by following the Post Installation Configuration.
Alternative Installation, Install Arch Linux in addition to Chrome OS
It's possible to have both Arch Linux and Chrome OS installed on the internal drive.
Re-Partition the Drive
In order to partition the drive, we will run the first stage of the ChruBuntu script in Chrome OS. After logging in, open a shell with Ctrl + Alt + T
, run shell
, then cd ~/
to enter the home directory. Once there, run the following:
curl -L -O http://goo.gl/9sgchs; sudo bash 9sgchs
It will ask how much space to partition for the alternate partition. 8GB is a safe number for the 16GB SSD. More than 9 may not work.
Fixing the Filesystem
Reboot the system so Chrome OS will repair the filesystem after the previous re-partitioning process. Once this is done, verify that the disk space has been reduced by opening a file manager and clicking the gear in the top right of the window.
Continue the Installation Process
Continue the installation process but instead of wiping the internal drive and creating a new filesystem you should install Arch to the existing empty partition that we designated for Arch in the previous step.
So after booting the installation media:
- Run the command
fdisk -l
to list drives and partitions. Find the internal drive and note the name of the partition matching the size you specified in the ChrUbuntu script. - Use
mkfs.ext4 /dev/sdxY
(where xY is drive letter and partition number, eg. /dev/sda7) This will create the filesystem for arch. - Following the instructions for installing GRUB on GPT, use gdisk to create a 1007kb partition and set the type to EF02.
Choosing Between Arch Linux and Chrome OS
Reboot your system and press Ctrl + l
to load SeaBIOS in order to boot into Arch, or press Ctrl + d
in order to boot into ChromeOS.
Now you can also set SeaBIOS as default (or even later as you are keeping Chrome OS).
Post Installation Configuration
Patched Kernels
linux-chromebook includes different patches which didn't accepted yet to Linux's upstream sources for better support Chromebook models, including:
- TPM related patch, will save you from setting a kernel module parameter for proper recovery from suspend with stock firmware.
- Backlight display support for Dell Chromebook 11, only needed when using stock firmware. The reason this wasn't added to the upstream kernel sources is probably due to lack of confirmation that the patch needed and works, if you need it then it's advisable to report it in freedesktop as DRI/DRM-Intel bug.
- Patches for kernel 3.18 (already included in 3.19rc2) which fix GPU hangs.
These packages will limit the extra configuration needed and also save you from manually building and installing different modules.
It is advised to review the list of patches and decide if the packages needed as the list is slowly getting smaller while the patches being accepted to the upstream sources.
Installing the patched kernel package
- Build from AUR or download pre-built packages (if you're using Yaourt then you probably want to point
TMPDIR
in/etc/yaourtrc
to somewhere else than/tmp
). - You might want to remove linux package.
# pacman -R linux
- Install the patched kernel package.
# pacman -U linux*chromebook*.pkg.tar.xz
Video Driver
See Intel Graphics.
Touchpad and Touchscreen
See Touchpad Synaptics and Touchscreen.
Touchpad and Touchscreen kernel modules
Since kernel 3.17 all the related patches merged into the upstream sources, meaning the linux package in core supports these devices.
If your touchpad or touchscreen is not supported then review the list of patches in linux-chromebook, if a related patch for your Chromebook model exist then install this package. If there's no such patch don't worry as the developers should be able to add such patch by request as the Chromium OS sources includes the related changes and are open source.
Touchpad Configuration
There are few options how to set the touchpad:
- Visit the ArchWiki page for your Chromebook model (see Chromebook Models) for touchpad xorg.conf.d file.
- Use a touchpad configuration tool like Synaptiks for KDE, although it is said to be currently unmaintained and seems to crash under KDE 4.11, it works well with KDE 4.12.2. Another utility, kcm_touchpad, does not work at all.
See also:
- Touchpad config files for Chromium OS, you can find out your touchpad model by running
cat /proc/bus/input/devices
. - Chromium OS touchpad driver port for Linux.
Fixing suspend
The following are instructions to fix the suspend functionality. Depending if you use the pre-installed SeaBIOS or John Lewis' pre-built custom ROMs with linux-chromebook you might not need the following fix. With the recent 3.17 kernel the suspend fix still needed.
There have been a few alternatives discussed and those may work better for some. [8] [9]
When using the stock coreboot included on Haswell Chromebooks, the general idea is to disable the EHCI_PCI and TPM modules, which cause the suspend/resume cycle to fail. There are multiple ways to achieve this.
With a patched kernel
Install a Patched Kernel which provides these fixes without the need for any additional kernel parameters.
With kernel parameters
Add the following to your GRUB configuration
/etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="tpm_tis.interrupts=0 modprobe.blacklist=ehci_pci"
Then rebuild your grub config.
With systemd
Sometimes the synaptics touchpad, and various other parts of the laptop are used as wakeup devices causing certain movements of the laptop during suspend to end suspend. In order to disable all wakeup devices except for the laptop lid sensor, create the following suspend-device-fix.sh
file.
/usr/local/sbin/suspend-device-fix.sh
#!/bin/bash awk '{if ($1 != "LID0" && $3 == "*enabled") print $1}' < /proc/acpi/wakeup | while read NAME do echo "$NAME" > /proc/acpi/wakeup done exit 0
Now give the file executable permissions:
# chmod +x /usr/local/sbin/suspend-device-fix.sh
Create a systemd service to execute the script on every boot.
/etc/systemd/system/suspend-fix.service
[Unit] Description=Suspend Fix [Service] Type=simple ExecStart=/usr/local/sbin/suspend-device-fix.sh [Install] WantedBy=multi-user.target
First start the service.
# systemctl start suspend-fix.service
If it properly starts, then allow it to be started on bootup.
# systemctl enable suspend-fix.service
Add the following line at the end of /etc/rc.d/rc.local
(if it does not exist, just create it) to prevent bad handling of EHCI USB:
/etc/rc.d/rc.local
echo 1 > /sys/devices/pci0000\:00/0000\:00\:1d.0/remove
Then, create the following cros-sound-suspend.sh
file. Only the Ath9k binding/unbinding lines are listed below; see the alternatives linked above for additional sound suspend handling if you experience issues.
/usr/lib/systemd/system-sleep/cros-sound-suspend.sh
#!/bin/bash case $1/$2 in pre/*) # Unbind ath9k for preventing error and full sleep mode (wakeup by LID after hibernating) echo -n "0000:01:00.0" | tee /sys/bus/pci/drivers/ath9k/unbind # Unbind snd_hda_intel for sound echo -n "0000:00:1b.0" | tee /sys/bus/pci/drivers/snd_hda_intel/unbind echo -n "0000:00:03.0" | tee /sys/bus/pci/drivers/snd_hda_intel/unbind ;; post/*) # Bind ath9k for preventing error and and full sleep mode (wakeup by LID after hibernating) echo -n "0000:01:00.0" | tee /sys/bus/pci/drivers/ath9k/bind # bind snd_hda_intel for sound echo -n "0000:00:1b.0" | tee /sys/bus/pci/drivers/snd_hda_intel/bind echo -n "0000:00:03.0" | tee /sys/bus/pci/drivers/snd_hda_intel/bind ;; esac
Make sure to make the script executable:
# chmod +x /usr/lib/systemd/system-sleep/cros-sound-suspend.sh
This method also requires the tpm_tis.interrupts=0
kernel parameter in your GRUB configuration.
/etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="quiet tpm_tis.interrupts=0"
Then rebuild your grub config.
Fixing Audio
Haswell based models
One or more of followings might help solving audio related issues, setting snd_hda_intel
module index reported the most useful. It's highly possible that you won't need to make any change.
- Create
/etc/modprobe.d/alsa.conf
, the optionindex
will make sure the analog output is the default (and not HDMI), the optionmodel
will notify the driver our board model which will make the built-in microphone usable (you can try insteadmodel=alc283-sense-combo
).
/etc/modprobe.d/alsa.conf
options snd_hda_intel index=1 model=alc283-dac-wcaps
- Use the
~/.asoundrc
file from [10].
Hotkeys
The Chromebook function keys recognized as standard F1-F10 by the kernel, it's preferable to map them accordingly to their appearance. It would also be nice to get the keys Delete, Home, End, PgUp, PgDown
which in Chrome OS mapped to Alt + : BackSpace, Right, Left, Up, Down
.
Sxhkd configuration
One way to set the hotkeys would be by using the Sxhkd daemon. Besides sxhkd, this also requires amixer, xorg-xbacklight, and xautomation.
- See [12] for an example configuration in
~/.config/sxhkd/sxhkdrc
.
Xbindkeys configuration
Another way to configure hotkeys would be by using Xbindkeys. Besides xbindkeys this requires amixer and xorg-xbacklight and xvkbd.
- See [13] for an example configuration in
~/.xbindkeysrc
. - See vilefridge's xbindkeys configuration for another example.
Alternate xbindkeys configuration
Volchange (originated in the Debian User Forums)) can manipulate the volume with PulseAudio instead of using amixer. Besides Volchange this requires xorg-xbacklight and xvkbd.
- Download the script from [14].
- Make it executable
$ chmod u+x ~/.local/bin/volchange
See [15] for a matching ~/.xbindkeysrc
.
Patch xkeyboard-config
Another option is to install xkeyboard-config-chromebook, for more details visit [16].
Gnome configuration
Some of the keys can be mapped in Gnome if one chooses to use it as a DE. The advantage of this that there is a HUD notification of changes (volume up / down, screen brightness changes). The following adds Gnome keyboard shortcuts for the brightness and volume (xdotool is required):
gsettings set org.gnome.settings-daemon.plugins.media-keys volume-down F9 gsettings set org.gnome.settings-daemon.plugins.media-keys volume-mute F8 gsettings set org.gnome.settings-daemon.plugins.media-keys volume-up F10 gsettings set org.gnome.settings-daemon.plugins.media-keys custom-keybindings "['/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom1/','/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom2/']" gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom1/ name 'BrightnessDown' gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom1/ binding 'F6' gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom1/ command 'xdotool key XF86MonBrightnessDown' gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom2/ name 'BrightnessUp' gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom2/ binding 'F7' gsettings set org.gnome.settings-daemon.plugins.media-keys.custom-keybinding:/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/custom2/ command 'xdotool key XF86MonBrightnessUp'
This can supplement another method above.
Power key and lid switch handling
Ignore using logind
Out of the box, systemd-logind
will catch power key and lid switch events and handle them: it will shut down the Chromebook on a power key press, and a suspend on a lid close. However, this policy might be a bit harsh given that the power key is an ordinary key at the top right of the keyboard that might be pressed accidentally.
To configure logind to ignore power key presses and lid switches, add the lines to logind.conf
below.
/etc/systemd/logind.conf
HandlePowerKey=ignore HandleLidSwitch=ignore
Then restart logind for the changes to take effect.
Power key and lid switch events will still be logged to journald by logind. See [[17]].
Ignore by Gnome
Install gnome-tweak-tool, open the Tweak Tool and under Power change the Power Button Action.
Firmware Write Protection
The firmware (Coreboot and its payloads) stored on a SPI chip (usually SOIC8) that some of its storage is protected from writing (mostly Coreboot).
As long as the write protection wasn't disabled or the protected range wasn't set to (0,0) any change made to the unprotected part of the firmware (mainly SeaBIOS) should be recoverable with Chrome OS recovery media.
There are two parts of the write protection: hardware and software.
Hardware Write Protection
The hardware write protection is an electrical circuit that when it's closed or open it prevent writing to the software protection special registers, thus the hardware write protection only protect directly these special registers but indirectly also the data in the firmware chip.
To disable the hardware write protection you may need to remove a screw, press a switch or short a jumper.
Software Write Protection
The software write protection are special registers which determining if the data stored in the firmware chip is protected and also holds the range of addresses of the protected data.
Understanding the Process of Disabling the Write Protection
To disable the write protection one would need to:
- Disable the hardware write protection of the special software register.
- Change the value of the special software register to disable software write protection or change the range of the protected addresses so no data will be protected (start and end at 0).
Conclusion: If we will disable the software write protection and won't enable it back, then even if we will enable the hardware write protection the firmware chip will stay unprotected.
Disabling the Hardware Write Protection
To find the location of the hardware write-protect screw/switch/jumper and how to disable it visit the ArchWiki page for your Chromebook model (see Chromebook Models). If there's no information about your device on the ArchWiki then turn to Information for Chrome OS Devices and Coreboot's Chromebooks page.
Disabling the Software Write Protection
Chromium OS's flashrom
can manipulate the software write protection special registers.
- Read the status of the software write protection special registers.
# flashrom --wp-status
- Disable or enable the software write protection.
# flashrom --wp-disable
- Change software write protection addresses range.
# flashrom --wp-range 0 0
For more details on Chromium OS's flashrom
and how to obtain it, see Manually Flash Custom Firmware with flashrom
.
Custom Firmware
Why Flash a Custom Firmware ?
Pros
- Adds a much recent version of SeaBIOS
- Adds SeaBIOS payload of coreboot to Chromebook models that didn't shipped with SeaBIOS.
- Reduce boot time.
- Remove developer Mode screen.
- Enables VMX.
- Fixes some issues (like suspend) without further modifications.
Cons
- Dangerous, might brick your device.
- Cannot boot stock Chrome OS (you can install Arnold the Bat’s Chromium OS build and it should be possible upgrade it to full blown Chrome OS with a script).
- It's possible that some quirks will be added, [18].
Flashing the Custom Firmware
There are two approaches for flashing a custom firmware:
- Use John Lewis' script which will save you time finding the correct firmware.
- Manually with
flashrom
, in this case you'll need to obtain the firmware by yourself or to compile it from the Coreboot sources (official or Chromium OS fork).
Disable the Hardware Write Protection
See the Disabling the Hardware Write Protection at the Firmware Write Protection.
Flashing With John Lewis' Script
Understanding the script
What John Lewis' getnflash_johnlewis_rom.sh
script does ?
- Automatically downloads Chromium OS 32bit version of
flashrom
. - Backup your current firmware.
- Disables software write protection by running
# ./flashrom --wp-disable
. - Checks the Chromebook product name with dmidecode and download the proper custom firmware.
- Writes the custom firmware.
What the script doesn't do ?
- Doesn't ask for confirmation.
- Doesn't check if the hardware write protection is disabled.
- Doesn't confirm the compatibility of a custom firmware to a specific Chromebook sub-model.
Conclusions
- Make sure you disabled the hardware write protection.
- Read the FAQ.
- Confirm that your Chromebook model is supported, if your model is untested then visit the coreboot on Chromebooks Google+ community and ask for advice.
Running the script in Chrome OS
- Access your superuser shell.
- Enter the command shown on the Download ROM page at John Lewis site.
- After the script exited copy the backed up firmware to an external storage before rebooting the system.
You should now have a custom firmware installed on your device, cross your fingers and reboot.
If you flashed the firmware as part of the installation process then continue by following Installing Arch Linux, if the custom firmware boots the installation media correctly then you might want to enable back the hardware write protection.
Running the script in Arch Linux
- In Arch Linux on 64bit envirmonment youll need to enable the Multilib repository (if it isn't already enabled) in pacman.conf and install lib32-glibc.
# pacman -S lib32-glibc
- Install dmidecode.
# pacman -S dmidecode
- Enter the command shown on the Download ROM page at John Lewis site.
- After the script exited copy the backed up firmware to an external storage before rebooting the system.
You should now have a custom firmware installed on your device, cross you fingers and reboot.
If the custom firmware boots Arch Linux correctly then you might want to enable back the hardware write protection, although John Lewis states that it's not necessary and will only make upgrading more difficult later. However, if you do not re-enable it you want to be careful not to use flashrom.
Manually With flashrom
The use of the upstream flashrom package is discourage as it's missing operations like --wp-disable
, --wp-status
and it will not write firmware successfully to the ROM of the Chromebook unless it already been programmed externally (i.e. flashing by another device over SPI with SOIC clip), this is why it's recommended to use Chromium OS's flashrom
.
Get flashrom for Arch Linux
- Download a 32bit statically linked Chromium OS's
flashrom
version, enable the Multilib repository in pacman.conf and install lib32-glibc
# pacman -S lib32-glibc # wget --no-check-certificate https://johnlewis.ie/flashrom # chmod +x flashrom
Don't forget that flashrom
's location isn't in $PATH
, to execute it you'll need to precede the command with ./
, e.g. # ./flashrom
.
Get flashrom for Chrome OS
Chrome OS already includes flashrom
.
Basic use of flashrom
- Disable software write protection before writing to the firmware chip.
# flashrom --wp-disable
- Backup firmware from the firmware chip.
# flashrom -r old_firmware.bin
- Write firmware to the firmware chip.
# flashrom -w new_firmware.bin
Flashing Back Stock Firmware
Disable the hardware write protection and follow the how to manually flash firmware with flashrom
to flash the backup of your stock firmware.
Unbricking Your Chromebook
Required Tools
- Programmer, both the Raspberry Pi and the Bus Pirate are mentioned as compatible devices on the flashrom wiki. The Bus Pirate is preferable as it'll allow you to use Chromium OS's version of
flashrom
that supports--wp-disable
and--wp-status
flags. - SOIC clip is recommended, see [19].
- Female jumper wires.
- If you want to use Chromium OS's
flashrom
another Linux machine (32bit or 64bit) is required.
General Idea on the Unbricking Process
- Connect the jumper wires to the programmer and the SOIC clip.
- Connect the SOIC clip to the ROM chip.
- If your programmer is running Linux (Raspberry Pi) then modprobe the spi modules.
- If your programmer isn't running Linux then connect it to your Linux machine.
- Write the firmware with
flashrom
, you might need to disable software write protection by runningflashrom
with the--wp-disable
flag (this is why Chromium OS'sflashrom
is handy).
Recommended Reading About Unbricking
- Flashrom's wiki pages on ISP, Bus Pirate, Raspberry Pi and SOIC8.
- Coreboot's wiki page on Chromebooks.
- Examples of unbricking the C720: guide, pictures.
- Example of unbricking HP Chromebox: guide
Known issues
Syslinux
Follow Syslinux installation instructions carefully. Try manual installation to see where the problem comes from. If you see Missing Operation System then it may be because you need to use correct bootloader binary. If syslinux does not work try other bootloader such as GRUB.
GPU hangs and system freezes with Haswell processors
See Intel graphics, since 3.18 linux-chromebook includes the related fixes and from 3.19 it will be fixed in mainline.
See also
- Developer Information for Chrome OS Devices at the Chromium Projects site
- BBS topic about the Acer C720 which include generic information on Haswell Based Chromebooks.
- Re-partitioning in Chrome OS [20], [21]
- Constantly updating list of Chrome OS devices
- Google Chromebook Comparison Chart