A camera module looks right on the sensor page: low light, small footprint, the connector your board already has. Then the install script fails, the package aborts, and the vendor's source tree turns out to belong to a different single-board computer. Nothing is wrong with the hardware — the module simply has no software for your platform, and no amount of troubleshooting adds one. This guide explains what a MIPI CSI-2 camera module needs besides a sensor, how to read a driver package's support list, and how to decide before you order whether a module will run on your board. The worked example checks a L4T 36.4.4 Jetson Orin NX against a package that names 36.2.0; the same exact-match rule applies on any embedded platform.
What a MIPI CSI-2 module needs besides the sensor
A MIPI module is a sensor plus three pieces of platform software, and all three come from the platform side:
- Sensor control. The driver sets registers, clocks and power rails over I2C, in the order the module's designer wired them.
- The CSI-2 link. The platform's video-input receiver deserializes the lanes and writes frames into memory.
- The ISP. A raw Bayer frame is not an image until the platform's ISP debayers, white-balances and denoises it.
A device-tree overlay tells the OS how all of it is wired: which lanes the sensor drives, which I2C bus it sits on, which receiver port it feeds. The receiver and the ISP are the platform vendor's silicon, so their programming interfaces exist only in that vendor's kernel source. The sensor-to-host capture pipeline, stage by stage walks the whole chain.
The link itself is sized, not assumed:
Keep the result under the per-lane ceiling your platform documents, with 20-30% headroom for blanking and control packets. If the arithmetic demands a lane count or a sensor mode the module cannot supply, no driver will repair it — the electrical and protocol layers behind the connector decide as much as the software does.
Why the same sensor name is not the same camera
One sensor designation appears in dozens of module designs: different oscillator frequencies, different regulator-enable lines, different I2C address maps, sometimes a motorized IR-cut filter on its own GPIO. A camera driver binds to the module — it must drive every one of those parts. Sensor-level support alone brings nothing up.
The differences are invisible from the outside: two modules can share a connector, a sensor and even a form factor while needing different enable sequences, which is why module model numbers, not sensor names, key every support list. Platform vendors publish what they built and tested — some Jetson releases ship built-in drivers for the two most common camera sensors (IMX219 and IMX477), which is why modules built around those two come up with no vendor package at all (the built-in support, and its limits). The same logic runs one level up: match the host to the module before admiring the sensor (board level camera sensor compatibility: match the host before you buy).
What a driver package must name before you buy
A support statement is a list, not a claim. Before you order, the module vendor's package page should name four things:
- Platform and compute module — for example Jetson Orin NX, on a named carrier board, or stated as module-only support.
-
The exact OS release string the package was built for — on Jetson, the L4T number your board prints with
cat /etc/nv_tegra_release. - Module model and sensor, spelled out — the driver drives the module profile, not the sensor in the abstract.
- Package contents — kernel modules and a device-tree overlay for your platform, plus a change log with dates.
That ordering is deliberate: compatibility is decided at the module-and-platform level before sensor features matter. If your platform, your release string or your module model is missing from the list, the module has no supported install path as bought. That sentence is the whole purchase test.
Worked example: L4T 36.4.4 against a package that lists 36.2.0
Inputs. Your board is a Jetson Orin NX printing L4T 36.4.4 from cat /etc/nv_tegra_release — the exact check the purchase behind this article started with. The candidate is a published out-of-tree Jetson camera-driver project whose release notes name exactly one L4T release, 36.2.0, exactly one compute module and one carrier board, and add one new sensor model (IMX900) with that release — a typical support footprint for out-of-tree camera work.
Rule in words. Compare release strings component by component, then the hardware names. An out-of-tree driver runs as published only where every component matches: same platform, same compute module, same carrier board unless the package states module-only support, same release string. Out-of-tree kernel modules are compiled against one kernel source; a different release means a different source tree, a different module ABI and different device-tree bindings.
Arithmetic.
- major: 36 = 36 — match
- minor: 4 ≠ 2 — mismatch, two minor numbers apart (36.2 to 36.3 to 36.4)
- patch: 4 ≠ 0 — mismatch
Two of the three numeric components differ, so the strings do not match.
Result and decision. Your release is not in the package's list. The threshold is an exact match: not a shared major number, not closeness. A 36.2.0 package on a 36.4.4 board has no documented install path — the modules may refuse to load, and forcing them drives an overlay generated for bindings your kernel does not have. Ask the vendor whether a 36.4.4 package exists, or buy a module whose list contains your string. In the case behind this article the gap was wider than numbers: the package targeted a different single-board family entirely, so no release of it would ever have matched.
What happens when you install a module without platform support
The failure chain is consistent, and recognizing it saves an evening:
- The vendor's installer script stops with a non-zero exit from a system command — in this case a subprocess call to
lsblkthat returned exit status 1, because the script expects a partition layout your board does not have. - Installing the package directly fails the same way: its post-install configuration step (
config-by-hardware.pyin that package) cannot map your hardware to a supported profile and aborts. - The vendor's driver source repository contains only the other platform's camera stack — no build files for yours.
- Building against generic kernel headers dead-ends, because the video-input receiver, the ISP framework and the camera device-tree bindings live only in the platform vendor's kernel source, not in the generic ARM tree.
Four routes, one cause: the platform is absent from the module's software. No flag, no forced install and no re-ordering of steps changes that.
A module that is on the list can still misbehave, and that is a different, debuggable class of problem — a supported CSI receiver can deliver no frames to the video-input engine for reasons from lane mapping to power sequencing (why an Orin Nano CSI receiver can deliver no frames to the video-input engine). Even on supported stacks, driver and multimedia API versions must align with your release.
When the usual answers are wrong
The connector fits, so it works. The flat-cable connector and its lane count are the electrical layer only. Read the connector pinout before matching a camera to a board — the pinout says nothing about the receiver or driver behind it.
The sensor is supported, so a driver exists. Sensor support is necessary, not sufficient; the driver must also drive the module's clocks, rails, enable lines and any motorized extras.
The next OS release will add it. Support arrives only when the module vendor publishes a package built for that release string. Until then an update is as likely to break a working camera as to fix a missing one — pin the release or rebuild the driver deliberately.
When to choose USB3 or GigE instead of MIPI
If the package list fails your board — or you run mixed platforms and cannot maintain a capture stack per board — choose an interface the host already speaks. A USB3 board-level camera enumerates through the standard USB stack, so the release string stops mattering. A GigE board camera crosses distances USB cannot: the Ethernet standard allows 100 m against a few metres for a passive USB3 cable, and the cabling matches the rest of the plant.
Read the trade-offs between the two interfaces before you re-plumb a design (CSI versus USB camera connections on embedded controllers). One nuance: USB3 Vision cameras stream through the vendor's SDK rather than the kernel's UVC stack — how to pick the acquisition path.
These span both interfaces and both shutter types:
- Sensor format
- 1/1.8"
- Lens mount
- C-mount
- Sensor format
- 1/1.8"
- Interface
- USB3
- Sensor format
- 1/2.9"
- Lens mount
- M12
The LS-BCM-0003 delivers 3.1 MP at 120 fps over USB3, with an IMX252 sensor in 1/1.8" format behind a C-mount and a global shutter — the part where frame rate decides. The MV-CB060-10UM-B is a bare board built on a 6 MP IMX178 mono sensor in 1/1.8" format with a rolling shutter, made to be housed in your own machine. Where the run gets long, the MV-CB016-10GM-M-W carries a 1.6 MP IMX296 mono sensor in 1/2.9" format with a global shutter and an M12 lens mount over GigE.
Pre-order checks
The module passes or fails at order time. Run the check in this order:
- Read the release string off the board —
cat /etc/nv_tegra_releaseon Jetson — and copy it exactly. - Open the driver package page for the exact module model, not the sensor.
- Match four values: platform, compute module, carrier board, release string. All four, or nothing.
- Confirm the package contains kernel modules and a device-tree overlay for your platform, and shows a change log with dates — a package never updated since its first release will not survive your next OS update.
- If your release string is missing, treat the module as incompatible and shortlist a USB3 or GigE part instead.
- If it passes, record the package version beside the release string; you will need both at the next update.
If the check fails, the supported path is a camera that speaks an interface your platform already has. The cameras finder filters by interface, resolution and shutter type, and the camera configurator builds the rest of the chain around your choice. For a second opinion on a specific module-and-board pair, contact us; the platform-side questions that follow the purchase are collected on the cameras topic page.
Questions
Can I port a camera driver written for one platform to another myself?
Only by writing a new driver, not by adjusting the old one. A port means building against the target platform's kernel source, replacing the other platform's receiver and ISP plumbing, and rewriting the device-tree overlay to its bindings. That is vendor-level engineering measured in weeks, it ends outside both vendors' support, and every OS update reopens the work. A module whose package already names your platform and release string is the better buy.
Will a module listed for an older OS release still work after I update?
Expect failure until the vendor publishes a package for the new string. Out-of-tree kernel modules are compiled against one kernel source; a release update changes the kernel, the device-tree bindings and the receiver plumbing together. Pin your working release if the camera is already in production, and re-run the exact-string match against every new package the module vendor publishes before you update anything.
Why does the vendor's install script fail with an lsblk error on my board?
The script's hardware-detection step calls system tools such as lsblk and parses the output for the disk layout it expects. On a board outside the support list, that layout does not exist, the command exits with status 1, and the installer stops. Working around the error installs software built for the wrong platform; the correct step is to check the package's support list first.
Does a USB3 camera remove the platform compatibility problem?
Almost. A USB3 board camera presents an interface the host OS already speaks, so no device-tree overlay or ISP plumbing is needed and the platform release stops mattering. What remains is the acquisition path: USB3 Vision cameras stream through the vendor's SDK, so check that the SDK supports your CPU architecture, while UVC-class devices use the kernel's built-in stack.
Are drivers interchangeable between modules built around the same sensor?
No. The driver drives the module profile: oscillator frequency, power-rail enable lines, I2C address map and any motorized filter control. Two modules around one sensor can differ in all of those, so one module's driver will not bring up the other. Treat every module model as its own compatibility case, even from the same vendor, unless the vendor states a shared profile.


