> ## Documentation Index
> Fetch the complete documentation index at: https://dragonwingdocs.qualcomm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect to your target

Before flashing a kernel or verifying a boot, you need two physical connections
to your Qualcomm<sup>®</sup> Linux development kit: a USB connection for fastboot
and ADB, and a serial console connection for early-boot log capture.

## Required hardware

| Item                               | Purpose                                                                   |
| ---------------------------------- | ------------------------------------------------------------------------- |
| USB-C cable                        | Fastboot flashing and ADB access                                          |
| USB-to-serial adapter (3.3 V UART) | Serial console for early-boot output                                      |
| Host machine running Ubuntu 22.04  | Confirmed by [Prerequisites & host setup](./prerequisites-and-host-setup) |

## Set up the serial console

The Qualcomm<sup>®</sup> Linux development kits expose a debug UART over a
USB-to-serial adapter. The serial console is the primary channel for inspecting
early-boot messages, kernel panics, and U-Boot/UEFI output before the network
stack is available.

### Install a terminal emulator

```bash theme={null}
sudo apt install minicom
```

### Connect the USB-to-serial adapter

Plug the adapter into the host and identify the device node:

```bash theme={null}
ls /dev/ttyUSB*
# or, for CP210x/CH340 adapters:
ls /dev/ttyACM*
```

Add your user to the `dialout` group if permission is denied:

```bash theme={null}
sudo usermod -aG dialout $USER
newgrp dialout
```

### Open the serial console

Qualcomm Linux development kits use **115200 baud, 8N1, no hardware flow control**:

```bash theme={null}
minicom -D /dev/ttyUSB0 -b 115200
```

<Note>
  To exit minicom, press **Ctrl-A** then **X**. To disable hardware flow control,
  open minicom settings with **Ctrl-A O → Serial port setup** and set Hardware
  Flow Control to **No**.
</Note>

Alternatively, use `picocom`:

```bash theme={null}
sudo apt install picocom
picocom -b 115200 /dev/ttyUSB0
```

For board-specific UART pin assignments and adapter wiring, refer to the
hardware documentation for your development kit.

## Set up fastboot and ADB

Fastboot is used to flash kernel images; ADB provides shell access after the
device has booted.

### Install platform tools

```bash theme={null}
sudo apt install android-tools-fastboot android-tools-adb
```

### Enter fastboot mode

After powering on the device, select **Volume Down**. The serial console shows:

```text theme={null}
Fastboot mode...
```

<Note>
  The exact button combination varies by board. Refer to your development kit's
  hardware documentation if the above does not work.
</Note>

### Verify fastboot connectivity

```bash theme={null}
fastboot devices
```

Expected output (the serial number varies by board):

```text theme={null}
1234567890abcdef  fastboot
```

If no device appears, check the USB cable, confirm the device is in fastboot
mode, and verify USB permissions:

```bash theme={null}
# Add a udev rule if fastboot requires sudo
echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"' \
    | sudo tee /etc/udev/rules.d/51-android.rules
sudo udevadm control --reload-rules && sudo udevadm trigger
```

### Verify ADB connectivity (post-boot)

After the device has fully booted, ADB should enumerate over the same USB cable:

```bash theme={null}
adb devices
```

Expected output:

```text theme={null}
List of devices attached
1234567890abcdef  device
```

Open a shell:

```bash theme={null}
adb shell
```

## Next steps

With serial console and fastboot confirmed, proceed to
[Install & boot the kernel](./install-and-boot-the-kernel) to flash your build
and verify the running kernel.