How to list PCI devices → lspci
How to List PCI Devices → lspci
Table of Contents
1. [Introduction](#introduction)
2. [Prerequisites](#prerequisites)
3. [Understanding PCI Devices](#understanding-pci-devices)
4. [Basic lspci Usage](#basic-lspci-usage)
5. [Advanced lspci Options](#advanced-lspci-options)
6. [Practical Examples and Use Cases](#practical-examples-and-use-cases)
7. [Understanding lspci Output](#understanding-lspci-output)
8. [Troubleshooting Common Issues](#troubleshooting-common-issues)
9. [Best Practices and Tips](#best-practices-and-tips)
10. [Alternative Methods](#alternative-methods)
11. [Conclusion](#conclusion)
Introduction
The `lspci` command is one of the most essential tools for Linux system administrators, hardware technicians, and anyone working with computer hardware. This powerful utility allows you to list and examine PCI (Peripheral Component Interconnect) devices connected to your system, providing crucial information about hardware components, drivers, and system configuration.
In this comprehensive guide, you'll learn everything you need to know about using `lspci` effectively, from basic device listing to advanced troubleshooting techniques. Whether you're diagnosing hardware issues, checking driver compatibility, or simply inventorying system components, mastering `lspci` will significantly enhance your Linux administration skills.
Prerequisites
Before diving into `lspci` usage, ensure you have the following:
System Requirements
- Linux-based operating system (Ubuntu, CentOS, RHEL, Debian, etc.)
- Terminal access with basic command-line knowledge
- Root or sudo privileges for certain advanced operations
Software Requirements
The `lspci` command is typically included in the `pciutils` package. To install it:
Ubuntu/Debian:
```bash
sudo apt update
sudo apt install pciutils
```
CentOS/RHEL/Fedora:
```bash
sudo yum install pciutils
or for newer versions
sudo dnf install pciutils
```
Arch Linux:
```bash
sudo pacman -S pciutils
```
Verification
Verify the installation by checking the version:
```bash
lspci --version
```
Understanding PCI Devices
What are PCI Devices?
PCI (Peripheral Component Interconnect) is a standard for connecting hardware components to a computer's motherboard. PCI devices include:
- Graphics cards (GPU)
- Network interface cards (NIC)
- Sound cards
- Storage controllers (SATA, NVMe, SCSI)
- USB controllers
- Wireless adapters
- Bluetooth controllers
- Bridge controllers
PCI Bus Architecture
The PCI bus system uses a hierarchical structure:
- Bus: The main communication pathway
- Device: Individual hardware components
- Function: Specific capabilities within a device
Each PCI device is identified by a unique address format: `BB:DD.F`
- `BB`: Bus number (hexadecimal)
- `DD`: Device number (hexadecimal)
- `F`: Function number (hexadecimal)
Basic lspci Usage
Simple Device Listing
The most basic `lspci` command lists all PCI devices:
```bash
lspci
```
Example output:
```
00:00.0 Host bridge: Intel Corporation 8th Gen Core Processor Host Bridge/DRAM Registers
00:02.0 VGA compatible controller: Intel Corporation UHD Graphics 620
00:14.0 USB controller: Intel Corporation Cannon Point-LP USB 3.1 xHCI Controller
00:16.0 Communication controller: Intel Corporation Cannon Point-LP MEI Controller #1
00:1c.0 PCI bridge: Intel Corporation Cannon Point-LP PCI Express Root Port #1
01:00.0 Network controller: Intel Corporation Wireless-AC 9560
02:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168/8411
```
Understanding Basic Output
Each line contains:
1. PCI Address (e.g., `00:02.0`)
2. Device Type (e.g., `VGA compatible controller`)
3. Manufacturer and Model (e.g., `Intel Corporation UHD Graphics 620`)
Verbose Output
For more detailed information, use the verbose flag:
```bash
lspci -v
```
This displays additional details including:
- Memory addresses
- IRQ assignments
- Driver information
- Device capabilities
Advanced lspci Options
Tree View Display
Display PCI devices in a hierarchical tree structure:
```bash
lspci -t
```
Example output:
```
-[0000:00]-+-00.0
+-02.0
+-14.0
+-16.0
+-1c.0-[01]----00.0
\-1c.4-[02]----00.0
```
For a more detailed tree with device names:
```bash
lspci -tv
```
Numerical IDs
Display vendor and device IDs in numerical format:
```bash
lspci -n
```
Example output:
```
00:00.0 0600: 8086:3e34 (rev 0c)
00:02.0 0300: 8086:3ea0 (rev 02)
00:14.0 0c03: 8086:9ded (rev 30)
```
Combining Numerical and Names
Show both numerical IDs and device names:
```bash
lspci -nn
```
Machine-Readable Output
For scripting purposes, use machine-readable format:
```bash
lspci -m
```
Example output:
```
"00:00.0" "Host bridge" "Intel Corporation" "8th Gen Core Processor Host Bridge/DRAM Registers" -r0c "Intel Corporation" "Device 3e34"
```
Kernel Drivers
Display kernel drivers handling each device:
```bash
lspci -k
```
Example output:
```
00:02.0 VGA compatible controller: Intel Corporation UHD Graphics 620 (rev 02)
Subsystem: Lenovo Device 225d
Kernel driver in use: i915
Kernel modules: i915
```
Practical Examples and Use Cases
Example 1: Identifying Graphics Hardware
To find graphics cards and their drivers:
```bash
lspci | grep -i vga
lspci | grep -i display
lspci | grep -i 3d
```
For detailed graphics information:
```bash
lspci -v | grep -A 10 -i vga
```
Example 2: Network Interface Discovery
List all network controllers:
```bash
lspci | grep -i network
lspci | grep -i ethernet
lspci | grep -i wireless
```
Get detailed network device information:
```bash
lspci -v | grep -A 15 -i network
```
Example 3: USB Controller Information
Find USB controllers and their capabilities:
```bash
lspci | grep -i usb
lspci -v | grep -A 10 -i usb
```
Example 4: Storage Controllers
Identify storage-related devices:
```bash
lspci | grep -i sata
lspci | grep -i ide
lspci | grep -i nvme
lspci | grep -i storage
```
Example 5: Audio Devices
Locate audio controllers:
```bash
lspci | grep -i audio
lspci | grep -i sound
lspci -v | grep -A 8 -i audio
```
Example 6: Specific Device Details
Get comprehensive information about a specific device:
```bash
lspci -v -s 00:02.0
```
Where `00:02.0` is the PCI address of the device.
Example 7: Vendor-Specific Devices
List devices from a specific manufacturer:
```bash
lspci | grep -i intel
lspci | grep -i nvidia
lspci | grep -i amd
```
Understanding lspci Output
Device Classes
PCI devices are categorized into classes:
| Class Code | Description |
|------------|-------------|
| 0x00 | Unclassified |
| 0x01 | Mass storage controller |
| 0x02 | Network controller |
| 0x03 | Display controller |
| 0x04 | Multimedia controller |
| 0x06 | Bridge |
| 0x0c | Serial bus controller |
Vendor IDs
Common vendor IDs include:
- 8086: Intel Corporation
- 10de: NVIDIA Corporation
- 1002: Advanced Micro Devices (AMD)
- 10ec: Realtek Semiconductor
Memory Regions
When using `-v`, you'll see memory regions:
```
Memory at f0000000 (64-bit, non-prefetchable) [size=16M]
Memory at e0000000 (64-bit, prefetchable) [size=256M]
I/O ports at e000 [size=64]
```
This information shows:
- Memory addresses: Physical memory locations
- Prefetchable: Whether memory can be cached
- I/O ports: Input/output port addresses
Troubleshooting Common Issues
Issue 1: lspci Command Not Found
Problem: `bash: lspci: command not found`
Solution:
```bash
Ubuntu/Debian
sudo apt install pciutils
CentOS/RHEL
sudo yum install pciutils
Verify installation
which lspci
```
Issue 2: Permission Denied Errors
Problem: Cannot access certain PCI configuration details
Solution:
```bash
Run with sudo for full access
sudo lspci -v
Or check current user permissions
ls -la /proc/bus/pci/
```
Issue 3: Incomplete Device Information
Problem: Device shows as "Unknown" or lacks details
Solutions:
1. Update PCI ID database:
```bash
sudo update-pciids
```
2. Check for newer pciutils version:
```bash
lspci --version
Update if necessary
```
3. Use alternative identification:
```bash
lspci -nn | grep "Unknown"
Search online using vendor:device ID
```
Issue 4: Missing Kernel Drivers
Problem: Device listed but no driver loaded
Investigation steps:
```bash
Check if driver is loaded
lspci -k | grep -A 3 "Device Name"
Look for available drivers
find /lib/modules/$(uname -r) -name "driver_name"
Check dmesg for driver messages
dmesg | grep -i "device_name"
```
Issue 5: Device Not Appearing
Problem: Expected device doesn't show in lspci output
Troubleshooting:
1. Check physical connection
2. Verify BIOS/UEFI settings
3. Rescan PCI bus:
```bash
echo 1 | sudo tee /sys/bus/pci/rescan
```
4. Check system logs:
```bash
dmesg | grep -i pci
journalctl | grep -i pci
```
Issue 6: Outdated Device Database
Problem: Newer devices show generic names
Solution:
```bash
Update PCI ID database
sudo update-pciids
Verify update
lspci --version
ls -la /usr/share/misc/pci.ids
```
Best Practices and Tips
1. Regular System Inventory
Create regular hardware inventories:
```bash
#!/bin/bash
hardware_inventory.sh
echo "=== PCI Device Inventory - $(date) ===" > pci_inventory.txt
lspci -v >> pci_inventory.txt
lspci -t >> pci_inventory.txt
```
2. Driver Verification Script
Monitor driver status for critical devices:
```bash
#!/bin/bash
check_drivers.sh
echo "Checking critical device drivers..."
lspci -k | grep -A 3 "VGA\|Ethernet\|Wireless" | grep -E "Kernel driver|Kernel modules"
```
3. Filtering and Formatting
Use advanced filtering for specific information:
```bash
Get only network devices with drivers
lspci -k | grep -A 3 -i network
Format output for reports
lspci | awk '{print $1 "\t" $2 "\t" substr($0, index($0,$3))}'
```
4. Combining with Other Tools
Integrate lspci with other system tools:
```bash
Combine with lsusb for complete hardware view
echo "=== PCI Devices ===" && lspci
echo "=== USB Devices ===" && lsusb
Check device temperatures (if available)
lspci | grep -i vga && sensors
```
5. Scripting and Automation
Create automated hardware monitoring:
```bash
#!/bin/bash
monitor_hardware.sh
LOGFILE="/var/log/hardware_changes.log"
Current hardware state
lspci -n > /tmp/current_pci.txt
Compare with previous state
if [ -f /tmp/previous_pci.txt ]; then
if ! diff -q /tmp/previous_pci.txt /tmp/current_pci.txt > /dev/null; then
echo "$(date): Hardware change detected" >> $LOGFILE
diff /tmp/previous_pci.txt /tmp/current_pci.txt >> $LOGFILE
fi
fi
Save current state for next comparison
cp /tmp/current_pci.txt /tmp/previous_pci.txt
```
6. Performance Considerations
For large systems or frequent queries:
```bash
Cache lspci output for multiple queries
lspci -v > /tmp/lspci_cache.txt
Use grep on cached output instead of running lspci repeatedly
grep -i network /tmp/lspci_cache.txt
```
7. Security Considerations
Be aware of information disclosure:
```bash
Sanitize output for sharing (remove serial numbers, etc.)
lspci | sed 's/Serial Number: [0-9a-f-]*/Serial Number: [REDACTED]/g'
```
Alternative Methods
Using /proc/bus/pci
Direct access to PCI information:
```bash
ls -la /proc/bus/pci/
cat /proc/bus/pci/devices
```
Using sysfs
Modern Linux systems provide PCI information via sysfs:
```bash
ls /sys/bus/pci/devices/
find /sys/bus/pci/devices/ -name "vendor" -exec cat {} \;
```
Using dmidecode
For additional hardware information:
```bash
sudo dmidecode -t slot
sudo dmidecode -t system
```
Using hwinfo
Comprehensive hardware detection:
```bash
Install hwinfo
sudo apt install hwinfo # Ubuntu/Debian
sudo yum install hwinfo # CentOS/RHEL
Use hwinfo
hwinfo --pci
hwinfo --short
```
GUI Alternatives
For desktop environments:
- lshw-gtk: Graphical hardware lister
- hardinfo: System information tool
- HardInfo: Comprehensive hardware analyzer
```bash
sudo apt install lshw-gtk hardinfo
```
Advanced Use Cases
Hardware Compatibility Checking
Before installing new hardware:
```bash
Check current PCI slots and usage
lspci -tv
Identify available slots
sudo lshw -class bridge
```
Driver Development and Debugging
For developers working with PCI drivers:
```bash
Get detailed device configuration
lspci -xxx -s 00:02.0
Monitor PCI configuration changes
watch -n 1 'lspci -xxx -s 00:02.0'
```
Virtualization Environments
In virtual machines:
```bash
Check for virtualized devices
lspci | grep -i virtual
lspci | grep -i vmware
lspci | grep -i qemu
```
Performance Tuning
Identify performance-critical devices:
```bash
Find high-speed devices
lspci -vv | grep -E "LnkSta.*Speed"
Check PCIe lane configuration
lspci -vv | grep -A 5 -B 5 "LnkCap\|LnkSta"
```
Conclusion
The `lspci` command is an indispensable tool for Linux system administration, hardware troubleshooting, and system inventory management. Through this comprehensive guide, you've learned:
- Basic Usage: How to list and identify PCI devices using various lspci options
- Advanced Techniques: Tree views, numerical IDs, and detailed device information
- Practical Applications: Real-world examples for common hardware identification tasks
- Troubleshooting: Solutions for common issues and problems
- Best Practices: Professional tips for effective hardware management
- Alternative Methods: Additional tools and approaches for hardware discovery
Key Takeaways
1. Start Simple: Begin with basic `lspci` commands and gradually use more advanced options
2. Combine Options: Use multiple flags together for comprehensive information
3. Regular Monitoring: Implement regular hardware inventory and monitoring practices
4. Documentation: Keep records of hardware configurations for troubleshooting
5. Stay Updated: Regularly update PCI ID databases for accurate device identification
Next Steps
To further enhance your hardware management skills:
1. Explore Related Commands: Learn `lsusb`, `lsblk`, `lscpu`, and `lshw`
2. Study Driver Management: Understand kernel module loading and driver troubleshooting
3. Practice Scripting: Create automated hardware monitoring and reporting scripts
4. Understand Hardware: Deepen knowledge of PCI architecture and computer hardware
5. Join Communities: Participate in Linux forums and communities for ongoing learning
With this knowledge, you're well-equipped to effectively use `lspci` for hardware discovery, troubleshooting, and system administration tasks in any Linux environment.