You have plugged a USB camera into an embedded Linux board, lsusb lists it, and the application still reports there is no capture device. Nothing is wrong with the camera: the node /dev/video0 never appears because the board's kernel was built without the USB Video Class driver, uvcvideo. This is a kernel configuration task, not a driver download. UVC support lives in the Linux source tree, and once it is enabled the camera binds itself and any V4L2 application opens it.
The sections below confirm the driver is absent, enable CONFIG_USB_VIDEO_CLASS as a module or built-in, rebuild and install the result, and prove the stream. On a board whose source tree already builds, the whole job fits in under an hour. Desktop and full distribution kernels ship the driver already — the UVC-compliant USB cameras on embedded Linux guide covers that case — so trimmed vendor kernels are where this matters.
Why does lsusb show the camera but no /dev/video device appears?
lsusb talks to the device directly over USB, so it lists any camera that enumerates. A /dev/video node appears only after a driver has claimed the camera's video interfaces; with uvcvideo missing from the kernel, nothing ever creates the node.
Enumeration and binding are separate steps. The USB bus reports the vendor and product ID, dmesg prints a line like usb 1-1.2: new high-speed USB device number 4, and the device appears under /sys/bus/usb/devices/. Binding is where the build matters: the kernel offers each detected interface to the drivers it contains, and a UVC camera exposes a Video Control and a Video Streaming interface with class 0x0E that only uvcvideo claims. Run ls /dev/video* — an empty result next to a live lsusb entry is the signature of a driver-less kernel, not of a broken camera. If the interface class itself is the open question, Camera shows in lsusb but no video device: check the USB class walks that check.
How do you check whether uvcvideo support is in the running kernel?
Three commands answer it: modinfo uvcvideo prints the module's version and file path when it is installed, zcat /proc/config.gz | grep USB_VIDEO_CLASS shows how the running kernel was configured, and dmesg | grep -i uvc shows a live probe at plug-in.
Read the three outputs together. A modinfo error means no uvcvideo.ko sits in /lib/modules/$(uname -r)/ for this release. /proc/config.gz exists on kernels built with CONFIG_IKCONFIG_PROC; otherwise read /boot/config-$(uname -r) or the vendor defconfig the image came from. CONFIG_USB_VIDEO_CLASS=m and =y both count as support; the symbol absent entirely means the option was never turned on.
The built-in case hides from lsmod: if the camera streams while lsmod | grep uvcvideo prints nothing, the driver is compiled into the image, and Uvcvideo module not loaded: check for a built-in driver explains how to confirm it.
Which kernel options enable the UVC driver?
Four settings decide it: CONFIG_MEDIA_SUPPORT, CONFIG_MEDIA_CAMERA_SUPPORT and CONFIG_MEDIA_USB_SUPPORT prepare the media stack, and CONFIG_USB_VIDEO_CLASS adds the driver itself, set to m for a loadable uvcvideo module or y for one built into the kernel image.
In make menuconfig the path is Device Drivers → Multimedia support → Media USB Adapters → USB Video Class (UVC). To set the symbols directly from the tree root:
scripts/config --enable MEDIA_SUPPORT \
--enable MEDIA_CAMERA_SUPPORT \
--enable MEDIA_USB_SUPPORT \
--module USB_VIDEO_CLASS
make olddefconfig
grep USB_VIDEO_CLASS .config
Add CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y as well when the camera's snapshot button should reach applications as an input event. The driver also exposes quirks flags and module parameters in its kernel documentation, including the bandwidth cap used in the last section.
Should uvcvideo be a module or built into the kernel?
Choose m while you develop, because you can load, unload and replace uvcvideo.ko without touching the kernel image. Choose y for unattended units where the camera must work from the first second of boot without an init script loading modules.
A module (m) ships as uvcvideo.ko under /lib/modules/$(uname -r)/kernel/drivers/media/usb/uvc/, travels with the root filesystem and loads with one modprobe. Built-in (y) sits inside the kernel image, probes before userspace starts and works even with an empty module tree on the target. Both produce the same /dev/video0. For a fixed production image on an unattended line, y removes one startup dependency; on a development kernel you will toggle options often, so m keeps each iteration to a file copy instead of a reflash.
How do you rebuild and install a kernel with UVC enabled?
A prepared source tree needs four passes — enable the options, build, stage the modules, deploy image and modules — and one reboot with the camera attached proves the whole chain.
- Match the source to the running build.
uname -rprints the exact release — on vendor boards a string such as3.10.24-g6eb5d7e— and you need that board's BSP tag or the source package that shipped with the image, not the nearest upstream version. - Start from the board's own configuration: copy its defconfig out of
arch/arm/configs/orarch/arm64/configs/and runmake olddefconfig. - Enable the four symbols from the previous section, through menuconfig or the
scripts/configblock, and confirmCONFIG_USB_VIDEO_CLASS=m(or=y) in.config. - Build with
make -j$(nproc), addingARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-on a cross machine. - Stage the modules outside the tree:
make modules_install INSTALL_MOD_PATH=$HOME/staging. - Deploy: write the kernel image and device tree blob where the bootloader — U-Boot on most boards — expects them, and copy
staging/lib/modules/$(uname -r)/onto the target root filesystem. - On the board run
depmod -a, reboot, thenmodprobe uvcvideowith the camera plugged in.
For the same enablement on a long-term-support industrial kernel, a worked UVC camera fix on a Linux CIP kernel follows the configuration end to end.
Can you build just the uvcvideo module without a full kernel rebuild?
Yes — with the tree configured for the running release, make modules_prepare plus a directory build produces uvcvideo.ko in a few minutes, and that one file is all that changes on the target.
With ROOTFS set to the target's root directory:
make modules_prepare
make M=drivers/media/usb/uvc
cp drivers/media/usb/uvc/uvcvideo.ko \
$ROOTFS/lib/modules/$(uname -r)/kernel/drivers/media/usb/uvc/
depmod -a
modprobe uvcvideo
The requirement is exactness: the build tree must believe it is the running kernel, so the release string in include/generated/utsrelease.h has to match uname -r character for character. When it does not, the module still compiles but refuses to load, and the table below names the error you will see.
Why does modprobe still report module uvcvideo not found?
The message reports a missing file rather than a broken camera: after a successful build the usual culprit is /lib/modules/$(uname -r)/ without a uvcvideo.ko in it, because depmod never ran or the release string moved.
| What you see | What it means | The fix |
|---|---|---|
FATAL: Module uvcvideo not found |
no uvcvideo.ko for the running release |
depmod -a, then check /lib/modules/$(uname -r)/kernel/drivers/media/usb/uvc/
|
Invalid module format |
module built against a different kernel version | rebuild from the exact source of the running release |
Camera works, nothing in lsmod
|
driver compiled in with =y
|
nothing to fix; confirm with dmesg
|
Module loads, still no /dev/video*
|
camera is not USB video class | check the interface class, next section |
Vendor kernels in industrial gateways hit the same two failures; a kernel configuration fix for a UVC camera on an industrial gateway documents one such recovery in full.
What if the driver loads but the camera still will not stream?
If uvcvideo loads cleanly and the camera still will not stream, the device is probably not a UVC camera: many industrial USB3 cameras speak a vendor-specific protocol, which lsusb reports as interface class 0xFF instead of 0x0E (Video).
lsusb -v | grep -i bInterfaceClass settles it. Class 0x0e on a streaming interface means UVC, and the node should already exist. Class 0xff (Vendor Specific) means the camera needs its vendor's user-space library — USB camera in lsusb but not detected by the vision SDK on Linux covers that path.
Two related cases sit nearby. A camera that never appears in lsusb at all sits on a MIPI CSI-2 connector, where the kernel question is device tree and clocks rather than USB classes; MIPI sensor detected but streaming fails: power, clocks, device tree is the guide there. A UVC camera that opens but delivers black or green frames has a pixel-format problem, not a driver problem: USB camera black image on Linux: fix UVC format negotiation works through the formats. And GigE cameras never touch uvcvideo — their GigE Vision protocol is served by user-space GenICam software, which is what the area scan cameras with an RJ45 port use.
How many UVC cameras can one USB controller handle?
A USB 2.0 controller grants one isochronous camera stream at most 24.6 MB/s, so two 1080p MJPEG cameras share it comfortably while a single uncompressed 1080p camera does not fit; heavier streams belong on USB 3.
USB 3 lifts the wire to 5 Gbit/s, roughly 500 MB/s of payload, where even uncompressed 1080p60 fits several times over. uvcvideo reserves the negotiated bandwidth for the whole stream even when frames arrive smaller, so cameras sharing one controller benefit from the driver's bandwidth_cap parameter — settable on the kernel command line or through sysfs — which caps each reservation and lets more cameras run at reduced frame size or rate.
The decisions, then. A desktop or full distribution kernel needs nothing: plug in and the node appears. A trimmed vendor kernel gets CONFIG_USB_VIDEO_CLASS=m for development and =y in the production image, built from source matching the running release. A camera that answers with class 0xFF needs its vendor SDK, and the better fix at the next purchase is UVC hardware: compare the USB board-level cameras in the camera finder, assemble a set in the configurator, or reach us through the contact page to match a module to your board's kernel.
Questions
Does a UVC camera need a vendor SDK on Linux?
No. Once uvcvideo is in the kernel, the camera is a standard V4L2 device at /dev/video0, and anything that reads V4L2 opens it directly: OpenCV's VideoCapture, a GStreamer v4l2src element, or ffmpeg. Vendor libraries matter only for cameras that use a proprietary USB protocol instead of the USB Video Class.
Will every USB camera work with uvcvideo?
No. Webcams and most board-level camera modules are class devices, but a large share of industrial USB3 cameras use a vendor-specific protocol and need their vendor's library. Check the data sheet for the letters UVC, or test once on a desktop Linux: a UVC camera creates a /dev/video0 node there with no package installed.
What pixel formats does uvcvideo deliver?
Whatever the camera declares: usually compressed MJPEG plus one uncompressed format such as YUYV, and raw Bayer on some industrial modules. The driver passes the stream through without conversion, so the decoders in your application, not the kernel, decide what is usable; v4l2-ctl --list-formats-ext on the device node lists every supported frame size and rate.
What happens to the module after a kernel update?
Modules are tied to the exact kernel release through their version magic, so an update breaks the pair unless the new image carries UVC built in or packaged. Rebuild uvcvideo against the new release's sources, reinstall with depmod, and confirm with modinfo uvcvideo followed by modprobe uvcvideo before the line starts.