Stream-on succeeds, the subdev binds, and still every capture times out — until the driver starts handing back buffers the log marks (error, ts-monotonic, ts-src-eof) with a timestamp of 0.000000. That pair of symptoms on a muxed multi-camera kit has a short cause list, and nearly every entry on it is one root: the channel the capture engine listens to is not the channel your sensor is on. This page decodes the dqbuf line field by field, sorts the -121 probe errors you can ignore from the one you cannot, and gives the bring-up order that keeps the mux channel and the stream locked together. Every command runs on a stock V4L2 stack with the i2c-tools utilities installed.
What does a DQBUF error flag with a zero timestamp mean?
A buffer dequeued with the error flag and ts 0.000000 means the capture engine never received a valid frame from the sensor: no frame start reached the capture hardware, so the driver hands the buffer back marked in error with nothing to timestamp.
Read the reported line one field at a time:
cap dqbuf: 0 seq: 0 bytesused: 32554752 ts: 0.000000 (error, ts-monotonic, ts-src-eof)
-
seq: 0— the first buffer since stream-on. No frame has completed, so the counter never advanced. -
bytesused: 32554752— the buffer's full length, not a count of valid pixels. The capture path reserves the whole frame size whether or not a frame arrived. -
(error, ts-monotonic, ts-src-eof)— the error flag is set; the other two names say where a timestamp would have come from, the monotonic clock sampled at end of frame. No frame end occurred, so ts stays 0.000000.
The bytesused number is worth factorising, because it confirms the format the driver negotiated:
4656 × 3496 = 16277376 pixels, and 16277376 × 2 = 32554752 bytes: a 16 MP sensor's native frame carried at two bytes per pixel, one of the 16-bit formats. Your application must request and allocate exactly this size; if your own allocation arithmetic lands on a different number, that mismatch is a second fault waiting behind the first.
Read the error flag as "no frame reached the capture engine", not "corrupt pixels". Genuinely corrupt lanes leave a different mark in the log, and the ranked causes further down show the difference.
What does an i2c read probe error -121 tell you?
Error -121 is EREMOTEIO, the I2C controller's no-acknowledge code: the driver addressed the sensor on that child bus and no device answered. One such line per unfitted camera channel is normal; on a channel you fitted a camera to, it is the fault.
Three lines from one boot tell the whole story:
imx519 9-001a: tegracam sensor driver:imx519_v2.0.6 — the sensor driver, version 2.0.6, loaded for the device on child bus 9 at 7-bit address 0x1a.
tegra-camrtc-capture-vi: subdev imx519 9-001a bound — the capture engine attached that subdev, so driver and sensor are paired on bus 9.
imx519 10-001a: error during i2c read probe (-121) — the same address on child bus 10 drew no acknowledge, so nothing attached there.
The number before the dash is the child bus, one fan of the kit's I2C multiplexer; the suffix after it is the sensor's 7-bit address in hex, 001a = 0x1a. EREMOTEIO has four ordinary causes, in order of likelihood: no camera fitted on that channel, a camera fitted but not powered, a ribbon cable not fully seated, or a camera on a different channel than the device tree scans there.
One -121 per unfitted channel is expected noise. The -121 that matters sits on a channel where a camera is definitely fitted. The deeper walk-through of probe failures is MIPI camera probe failed error -121: read the dmesg trail, and camera I2C communication failure: diagnose sensor probe errors covers the address-level checks.
Which mux channel must be selected before stream-on?
The channel that counts is the one whose sensor probed on a child bus: this log names bus 9 at address 0x1a. Hold the mux on that channel from just before stream-on to capture stop; 9548-type muxes take a one-hot byte, 0x01 through 0x08 for channels 0 to 3.
The probe lines hand you the answer. The sensor that bound lives on child bus 9, so the multiplexer must feed bus 9 from the moment stream-on starts until capture stops. The sensor's register writes at stream-on travel through the multiplexer, and the MIPI lanes carrying the frames hang off the same channel; point the port anywhere else and the capture engine clocks nothing.
A 9548-type multiplexer selects its channel with a single one-hot byte written to its own 7-bit address:
- channel 0 = 0x01
- channel 1 = 0x02
- channel 2 = 0x04
- channel 3 = 0x08
The write is one command on the multiplexer's parent bus, at the address this kit reports as 0x24: i2cset -y <parent-bus> 0x24 0x01 selects channel 0. If the kernel's own multiplexer driver manages the switching, let it — a manual write on the parent bus races the driver. Manual selection belongs to set-ups where the multiplexer sits unmanaged and userspace owns it.
How do you prove a channel is live before streaming?
Prove the channel with i2cdetect on each child bus, then a three-frame capture: i2cdetect -y 9 must list 1a while -y 10 stays empty on this rig, and the first working dqbuf lines show a rising sequence number and a real timestamp instead of the error pair.
Run the check in this order:
- Detect on every child bus:
i2cdetect -y 9andi2cdetect -y 10. A bus listing1a— orUU, once the driver owns the address — holds a live sensor; an empty row is an unfitted or unpowered channel. - Write the matching one-hot byte to the multiplexer, then re-run i2cdetect on the chosen child bus and confirm the address still answers after the switch.
- Capture three frames:
v4l2-ctl --device=/dev/video0 --stream-mmap --stream-count=3 --verbose. The same command pattern captures raw Bayer frames from six V4L2 cameras in this six-camera capture walk-through. - Read the dqbuf lines. Healthy output steps the sequence 0, 1, 2 and advances the timestamp in fractions of a second; the error pair means the channel and the stream still disagree.
If i2cdetect answers but frames still time out, the fault has moved from I2C to the MIPI side; separating I2C failures from MIPI failures splits the two by test. Once frames flow but timestamps freeze or jump, the clock source is the next suspect — fixing frozen or jumping image timestamps takes that case.
The four signatures and their first moves:
| Log line | What it tells you | First move |
|---|---|---|
subdev ... 9-001a bound |
the driver attached where the device tree says a sensor sits | none — binding is not streaming |
error during i2c read probe (-121) |
no device answered at that address | i2cdetect that child bus; check fit and power |
dqbuf ... ts: 0.000000 (error, ...) |
no valid frame reached the capture engine | confirm the mux channel at stream-on |
rising seq, advancing ts
|
frames are arriving | none — capture works |
More capture-side diagnostics sit on the systems topic page.
Why does a bound sensor still return error frames?
Bound means only that the driver attached to the I2C address the device tree described; it is not proof that the capture port is watching that sensor's lanes. With the mux on any other channel at stream-on, the capture engine clocks silence and every buffer comes back error-flagged and zero-timestamped.
Rank the causes by how often each turns up on a muxed kit:
- The multiplexer sits on the wrong channel at stream-on. One sensor bound, on bus 9 here, while the mux was last written to channel 2 and the capture engine watched an empty channel. This is the most common cause and the quickest to fix.
- Something switched the channel after stream-on. A second capture process, a probe script or a manual i2cset on the parent bus flipped the mux mid-run. The first frames can even be good; from the switch onwards, every buffer returns with the error pair.
- The camera you meant to use never probed. Its channel logged -121, another channel's camera bound instead, and the stream went to whichever sensor the device tree found — cause 1 in a different coat.
-
Corrupt MIPI lanes. Broken lane pairs leave a different signature: the capture module logs
uncorr_errorcorr_err: discarding framelines and drops individual frames while good frames still get through between them. Every buffer error-flagged with ts 0.000000 is silence, not corruption.
Causes 1 and 2 share one rule, the same one the still-capture guide applies to photo triggers: switch the mux channel before you capture. If your symptom is instead a capture that stalls after a few good frames with real data in the queue, that is buffer starvation, not channel selection — the buffer starvation maths covers that chain.
How do you lock the mux channel to the stream?
Lock them together with a fixed bring-up order: probe first, note the bound bus, select its channel, re-detect the address, then stream, and let one process own the mux parent bus until capture stops.
Run bring-up the same way every time:
- Power the kit and cameras; read the boot log. Expect one -121 per empty channel and one bound line per fitted camera.
- Write down the child bus and address in the bound line:
9-001ameans bus 9, address 0x1a. - Select that channel at the multiplexer with the one-hot byte before any capture starts.
- Re-run
i2cdetect -y 9and confirm1astill answers. - Stream and check the first two dqbuf lines for a rising sequence and advancing timestamps.
- To move to another camera: stop capture, write the next channel byte, re-detect, then stream again.
- Let one process own the multiplexer's parent bus for the whole run — no parallel I2C scripts during capture.
Steps 3 and 5 form the atomic pair: channel select and stream-on belong to the same line of your start-up script, never split across a manual command in another terminal.
A rig that follows this order turns the whole fault class into a thirty-second check at power-on.
When is a shared CSI mux the wrong tool?
If the rig needs every camera streaming at once, or bring-up keeps eating days, give each camera its own link: industrial GigE cameras run one cable each to a switch, trigger off a shared strobe where the model exposes one, and have no mux in the signal path.
A muxed MIPI port streams one camera at a time over one set of lanes and puts every switching decision in software. That is the right shape for a sequential cell — look, capture, step, look again — and the wrong shape when the views must be simultaneous, the cable runs grow past a metre, or the bring-up fight repeats at every firmware update.
GigE cuts the sharing out entirely: each camera takes its own 1 Gbps link to a switch, frames never contend for one CSI port, and a shared trigger line aligns the views on models that expose one. Mount each camera on a repeatable camera stand so the geometry holds between runs.
For a bench rig of two to four views, a 2.5 MP color GigE camera with a global shutter per view keeps every stream independent — one cable, one link, no shared port.
- Sensor format
- 1/1.7"
- Lens mount
- C-mount
- Interface
- GigE
- Resolution
- Up to 3 MP
Where a view needs more pixels, the 6 MP mono GigE model keeps the same one-camera-one-link layout at a higher resolution.
- Sensor format
- 1/1.8"
- Lens mount
- C-mount
- Interface
- GigE
- Resolution
- 6-10 MP
The decision in one line: fix the bring-up order above when a muxed kit fits the job; move to one link per camera when it does not. Browse the area scan cameras range, filter by interface and resolution in the camera finder, or step through configuring a camera for the rig. If the log still fights you after the order above, send the boot trail and the dqbuf lines through the contact page and we will read them with you.
Questions
Is one -121 probe line per empty camera channel harmless?
Yes. The driver probes every bus and address the device tree lists, and a channel with no camera fitted draws no acknowledge, so the boot log records one -121 per empty channel. Count the fitted cameras: when every fitted channel probed and bound, the remaining -121 lines are expected, and only a -121 on a fitted channel is a fault.
How much memory does a capture queue reserve even when frames fail?
Each buffer is sized by the frame, not by its contents: 32554752 bytes per buffer here, so a four-buffer queue reserves 4 × 32554752 = 130219008 bytes, about 130 MB, valid frames or not. Eight buffers double that to roughly 260 MB, which matters on small modules where the allocation itself can be the limiting step.
What does a healthy dqbuf line look like once the channel is right?
The error flag disappears, the sequence number steps up by one per frame and the timestamp advances by roughly the frame period, for example seq 0 at ts 0.500 and seq 1 at ts 0.533 — a 33 ms frame period, about 30 fps. Rising sequence plus advancing timestamps is the signature that the mux channel and the stream finally agree.
Can I switch the mux channel while a capture is running?
No. Mid-stream the sensor loses its register path and the capture engine loses its lanes, so every buffer after the switch returns flagged error with a zero timestamp. Stop the capture first, write the next one-hot channel byte, confirm the address answers with i2cdetect, and only then start the next stream.
Does the zero-timestamp error signature also appear without a multiplexer?
Yes. Any capture that reaches the engine with no valid frame produces it: a single camera with an unseated ribbon, a sensor without power, or a lane mapping the device tree gets wrong. The multiplexer is just the easiest way to point the port at a channel that has nothing on it.

