![[travel_laptop.png]] I wanted an affordable laptop to take traveling. Even though I have a Lemur Pro at home, I mostly use it as a desktop -- rarely undocking it (I'm just so much more productive at my desk!). I maxed out the specs when I bought it, and it's still running nicely. While my previous laptop had NixOS, this one is just running PopOS out of the box. I've appreciated reduced tinkering, but also I feel like there is so much configuration state on the machine that I'd lose a huge amount of time if I lost it. For our upcoming Europe trip I wanted something small and inexpensive. I considered an m4 macbook but I kept finding myself both maxing out the specs, and also feeling sad about the state of linux. I ended going the oposite direction and focusing on price -- I'll just get a chromebook! After some research, I was pleasantly surprised by the pricepoint, size, and build quality of the Pixelbook Go. Last time I had the original chromebook pixel I absolutely loved it -- unfortunately I had to run it in "debug" mode. Debug mode required pressing ctrl + D at boot, which seemed fine at the time except that my girlfriend at the time (now wife) saw the "Danger" screen and pressed spacebar.... this of course formats the hard-drive to drop back into chrome os :( :( :(. Needless to say, this time around I wanted to make sure that couldn't happen. Luckily there has been a lot of progress since 2013 -- I came across mr. chromebox which is a great resource, as well as chrultrabooks. I saw that there was a mechanism to flash the bios with a special cable -- nice! but the cable didn't arrive in time, so I had to disable the FW write protect which is tied into the battery (smart). I found myself detaching this tiny battery cable/connector from the motherboard in order to start the flashing process. The real challenge was *reconnecting* the battery, but we got through that too with only a few minutes of swearing and a couple tiny sparks (yikes!). I really like that Matte finish of the device, and I found a black Obsidian vinyl sticker that I got from their swag store. A little bit of Electrical tape and the thing is all blacked out with no logos. Perfect. I decided to go with PopOS. I had a lot of work to do to get the device up and running -- I knew most of this when I bought the device, but it still took a bit more time than I expected (4 hours?) - Audio fixing script - Keyboard mapping (the pixelbook has a funky function key row) - Trackpad fixes - Webcam support (I skipped this) - USB fixing script > [!Audio Fixes] Fixing Audio > I ended up having to deviate from the guide -- I discovered through [this ticket](https://github.com/WeirdTreeThing/chromebook-linux-audio/issues/228) that I needed to use: > `./setup-audio --branch old-syntax` > [!USB] Fixing USB > I'm not sure if this would have resolved on its own with a reboot, but I ended up following After I was convinced it was working, I did a couple of my usual setup things... - Firefox sync - Tailscale - Fly wireguard - Atuin - Obsidian (+ relay) - Nord theme (nordic-darker-v40) - New yubikey > [!side note] A note on passkeys > It's a huge pain to know all of the places to add a new yubikey to. I ended up doing what I could remember, and then traveling with one of my other yubikeys so I could enroll the new one if needed. > ----- # Journal ### Disabling the touch-screen in PopOS How do I disable the touch screen? > [!ai]+ AI > > Based on your post, here are a few methods to disable the touchscreen in PopOS: > ## Method 1: Using xinput (temporary) > ```bash > # First, find your touchscreen device > xinput list > # Look for something like "touchscreen" or similar device name > # Then disable it (replace "Device Name" with actual name) > xinput disable "Device Name" > ``` > ## Method 2: Create a persistent xinput script > Create a script that runs at startup: > ```bash > # Create the script > sudo nano /usr/local/bin/disable-touchscreen.sh > # Add this content (adjust device name): > #!/bin/bash > xinput disable "Your Touchscreen Device Name" > # Make it executable > sudo chmod +x /usr/local/bin/disable-touchscreen.sh > ``` > Then add it to your startup applications. > ## Method 3: Blacklist the kernel module > This is more permanent but requires identifying the specific driver: > ```bash > # Find loaded modules related to touchscreen > lsmod | grep -i touch > # Create blacklist file > sudo nano /etc/modprobe.d/blacklist-touchscreen.conf > # Add line like: > blacklist module_name_here > ``` > ## Method 4: Udev rule approach > Create a udev rule to disable the device: > ```bash > sudo nano /etc/udev/rules.d/99-disable-touchscreen.rules > ``` > Given that you've already done a lot of hardware tweaking on the Pixelbook Go, the xinput method is probably the safest starting point. You can make it permanent once you confirm it works correctly. > What touchscreen device shows up when you run `xinput list`? ⎡ Virtual core pointer id=2 [master pointer (3)] ⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)] ⎜ ↳ ACPI0C50:00 0483:1058 id=9 [slave pointer (2)] ⎜ ↳ ACPI0C50:01 04F3:30C5 Mouse id=10 [slave pointer (2)] ⎜ ↳ ACPI0C50:01 04F3:30C5 Touchpad id=11 [slave pointer (2)] ⎜ ↳ keyd virtual pointer id=15 [slave pointer (2)] > [!ai]+ AI > > Looking at your `xinput list` output, I can see the touchscreen device: **ACPI0C50:01 04F3:30C5 Mouse** (id=10). This is actually the touchscreen - on many laptops, the touchscreen shows up as a "Mouse" device in xinput. > Here's how to disable it: > ## Quick Test (temporary) > ```bash > xinput disable "ACPI0C50:01 04F3:30C5 Mouse" > ``` > To re-enable it later: > ```bash > xinput enable "ACPI0C50:01 04F3:30C5 Mouse" > ``` > ## Make it Permanent > Once you confirm that works, create a startup script: > ```bash > # Create the script > sudo nano /usr/local/bin/disable-touchscreen.sh > # Add this content: > #!/bin/bash > xinput disable "ACPI0C50:01 04F3:30C5 Mouse" > # Make it executable > sudo chmod +x /usr/local/bin/disable-touchscreen.sh > ``` > Then add it to your startup applications in PopOS settings, or create a desktop entry: > ```bash > # Create autostart entry > mkdir -p ~/.config/autostart > cat > ~/.config/autostart/disable-touchscreen.desktop << EOF > [Desktop Entry] > Type=Application > Name=Disable Touchscreen > Exec=/usr/local/bin/disable-touchscreen.sh > Hidden=false > NoDisplay=false > X-GNOME-Autostart-enabled=true > EOF > ``` > This should disable the touchscreen on every boot. Given all the other tweaks you've done to get the Pixelbook Go working perfectly, this should be a straightforward addition! hmm I don't think that it disabled it though. > [!ai]+ AI > > You're right - let me help you figure out which device is actually the touchscreen. The xinput output can be misleading on Chromebooks. > Let's try a different approach to identify the touchscreen: > ## Method 1: Test each device > Try disabling each pointer device one by one to see which one affects the touchscreen: > ```bash > # Try the first ACPI device > xinput disable "ACPI0C50:00 0483:1058" > # Test touchscreen - if it still works, re-enable and try next > xinput enable "ACPI0C50:00 0483:1058" > # Try the "Mouse" device > xinput disable "ACPI0C50:01 04F3:30C5 Mouse" > # Test touchscreen > xinput enable "ACPI0C50:01 04F3:30C5 Mouse" > ``` > ## Method 2: Get more detailed device info > ```bash > # Get detailed info about each device > xinput list-props "ACPI0C50:00 0483:1058" > xinput list-props "ACPI0C50:01 04F3:30C5 Mouse" > ``` > Look for properties like "Device Enabled" or anything mentioning "touch" in the output. > ## Method 3: Check kernel input devices > ```bash > # This shows all input devices > cat /proc/bus/input/devices | grep -A 5 -B 5 -i touch > ``` > ## Method 4: Use libinput if available > ```bash > # List all input devices with libinput > libinput list-devices | grep -A 10 -B 2 -i touch > ``` > Can you try these and let me know what you find? The Pixelbook Go might have the touchscreen showing up differently than expected, or it might need a different approach entirely. ok so this is the device: ACPI0C50:00 0483:1058 but I think I want to just disable it at the USB level -- does that ID give me enough info to disable it? > [!ai]+ AI > > [!ai]+ AI > Yes! That device ID gives us exactly what we need. The format `0483:1058` is the USB Vendor ID:Product ID pair. > ## Method 1: Blacklist the USB device (most reliable) > Create a udev rule to disable it at the USB level: > ```bash > sudo nano /etc/udev/rules.d/99-disable-touchscreen.rules > ``` > Add this line: > ``` > SUBSYSTEM=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="1058", ATTR{authorized}="0" > ``` > ## Method 2: Alternative udev rule (if the above doesn't work) > ``` > SUBSYSTEM=="input", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="1058", RUN+="/bin/sh -c 'echo 1 > /sys$devpath/device/remove'" > ``` > ## Method 3: USB quirks (kernel parameter) > Add this to your kernel boot parameters: > ``` > usbcore.quirks=0483:1058:i > ``` > Edit `/etc/default/grub` and add it to `GRUB_CMDLINE_LINUX_DEFAULT`, then run `sudo update-grub`. > ## Apply the changes > After creating the udev rule: > ```bash > # Reload udev rules > sudo udevadm control --reload-rules > # Trigger udev to reprocess devices > sudo udevadm trigger > # Or just reboot > sudo reboot > ``` > The first method (udev rule with `authorized="0"`) is usually the cleanest approach - it prevents the USB device from being authorized/activated at all, which is exactly what you want for permanently disabling the touchscreen at the hardware level. I added it to udev -- what will actually happen from that rule? (in terms of the kernel, startup, etc) > [!ai]+ AI > > Great question! Here's exactly what happens with that udev rule: > ## When the rule triggers > The udev rule activates during the **device enumeration phase** of boot (or when USB devices are hotplugged). This happens after the kernel loads but before userspace fully starts up. > ## The specific action > ``` > ATTR{authorized}="0" > ``` > This writes `0` to the USB device's `authorized` attribute in sysfs (specifically `/sys/bus/usb/devices/[device-path]/authorized`). > ## What "authorized=0" means > - The USB device is **detected** and **enumerated** by the kernel > - The device shows up in `lsusb` output > - But the kernel **refuses to load drivers** for it > - No `/dev/input/` entries are created for the touchscreen > - The device essentially becomes "present but inert" > ## Boot sequence impact > 1. **Kernel USB subsystem**: "I see device 0483:1058" > 2. **udev**: "That matches my rule - setting authorized=0" > 3. **Kernel**: "Device present but not authorized - skipping driver binding" > 4. **Input subsystem**: Never sees the touchscreen device > 5. **X11/Wayland**: No touchscreen to configure > ## Verification > After reboot, you can check: > ```bash > # Device should appear but show authorized=0 > lsusb | grep 0483:1058 > find /sys -name "*0483*1058*" -exec cat {}/authorized \; > ``` > This is cleaner than xinput because it prevents the touchscreen from ever becoming an input device in the first place, rather than disabling it after the fact. is there a way to test it without rebooting? > [!ai]+ AI > > Yes! You can test it by manually triggering the udev rule on the existing device: > ## Method 1: Manually set authorized=0 > First, find the device path: > ```bash > # Find the USB device path > find /sys -name "authorized" -path "*0483*1058*" 2>/dev/null > # or > lsusb -v | grep -A 5 -B 5 "0483:1058" > ``` > Then directly write to the authorized file: > ```bash > # This should be something like: > echo 0 | sudo tee /sys/bus/usb/devices/[device-path]/authorized > ``` > ## Method 2: Trigger udev to reprocess the device > ```bash > # Reload udev rules first > sudo udevadm control --reload-rules > # Find the device and trigger udev on it > udevadm info --export-db | grep -A 10 -B 10 "0483.*1058" > # Look for the DEVPATH, then trigger it: > sudo udevadm trigger --action=add --subsystem-match=usb --attr-match=idVendor=0483 --attr-match=idProduct=1058 > ``` > ## Method 3: Unbind and rebind the USB device > ```bash > # Find the USB device > lsusb | grep 0483:1058 > # Find its bus and device number, then: > echo "1-X" | sudo tee /sys/bus/usb/drivers/usb/unbind > echo "1-X" | sudo tee /sys/bus/usb/drivers/usb/bind > ``` > ## Quick test > The fastest way is probably: > ```bash > # Find the exact path > find /sys -path "*0483*1058*/authorized" 2>/dev/null > # Then manually set it to 0 > echo 0 | sudo tee [that-path] > ``` > This should immediately disable the touchscreen without rebooting. Test it, and if it works, you know your udev rule will work on the next boot! wait it doesn't show up in lsusb -- that's not good. could it be a different kind of device? > [!ai]+ AI > > Ah, you're absolutely right! If it doesn't show up in `lsusb`, it's not a USB device. On Chromebooks/laptops, touchscreens are often connected via **I2C** or **SPI**, not USB. > The `ACPI0C50:00 0483:1058` format is misleading - those numbers might not be USB vendor:product IDs at all. > ## Let's identify what it actually is: > ```bash > # Check what kind of device this really is > udevadm info --export-db | grep -A 20 -B 5 "0483.*1058" > # Or check input devices more thoroughly > cat /proc/bus/input/devices | grep -A 10 -B 5 "0483\|1058" > # Check I2C devices > ls /sys/bus/i2c/devices/ > # Check what's actually behind that xinput device > xinput list-props "ACPI0C50:00 0483:1058" | head -20 > ``` > ## For I2C touchscreens, you'd need a different approach: > ```bash > # Find the actual kernel module > lsmod | grep -i touch > lsmod | grep -i i2c > # Check dmesg for touchscreen initialization > dmesg | grep -i touch | tail -10 > ``` > ## Alternative: Blacklist by input device path > ```bash > # Create udev rule for input device instead > sudo nano /etc/udev/rules.d/99-disable-touchscreen.rules > ``` > Add: > ``` > SUBSYSTEM=="input", ATTRS{name}=="ACPI0C50:00 0483:1058", RUN+="/bin/sh -c 'echo remove > /sys$devpath/uevent'" > ``` > Can you run those identification commands? That'll tell us whether it's I2C, SPI, or some other connection type, and then we can disable it properly. Device 'ACPI0C50:00 0483:1058': Device Enabled (177): 0 Coordinate Transformation Matrix (179): 1.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 1.000000 libinput Calibration Matrix (315): 1.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 1.000000 libinput Calibration Matrix Default (316): 1.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 1.000000 libinput Send Events Modes Available (298): 1, 0 libinput Send Events Mode Enabled (299): 0, 0 libinput Send Events Mode Enabled Default (300): 0, 0 Device Node (301): "/dev/input/event6" Device Product ID (302): 1155, 4184 > [!ai]+ AI > > Perfect! Looking at the output, I can see two key things: > 1. **Device Enabled (177): 0** - The touchscreen is already disabled via xinput! > 2. **Device Node (301): "/dev/input/event6"** - It's an input device, not USB > ## The touchscreen is actually already disabled! > The `xinput disable` command you ran earlier **did work** - see "Device Enabled (177): 0". If you want to test that it's really disabled, try touching the screen. > ## To make this permanent across reboots: > Since it's an input device (not USB), let's use the input subsystem approach: > ```bash > # Remove the USB udev rule since it won't work > sudo rm /etc/udev/rules.d/99-disable-touchscreen.rules > # Create the correct input device rule > sudo nano /etc/udev/rules.d/99-disable-touchscreen.rules > ``` > Add this content: > ``` > SUBSYSTEM=="input", ATTRS{name}=="ACPI0C50:00 0483:1058", ENV{LIBINPUT_IGNORE_DEVICE}="1" > ``` > Or the simpler xinput approach you had before: > ```bash > # Create the startup script > sudo nano /usr/local/bin/disable-touchscreen.sh > ``` > Add: > ```bash > #!/bin/bash > sleep 2 # Give X11 time to start > xinput disable "ACPI0C50:00 0483:1058" > ``` > ```bash > # Make executable > sudo chmod +x /usr/local/bin/disable-touchscreen.sh > # Add to autostart > mkdir -p ~/.config/autostart > cat > ~/.config/autostart/disable-touchscreen.desktop << EOF > [Desktop Entry] > Type=Application > Name=Disable Touchscreen > Exec=/usr/local/bin/disable-touchscreen.sh > Hidden=false > NoDisplay=false > X-GNOME-Autostart-enabled=true > EOF > ``` > The touchscreen should already be disabled right now - try touching it to confirm!