Skip to content

About

Reverse-engineering notes for the discontinued RED DSMC2 camera platform: media (cheap SSD magazines) fully documented, plus platform, models, and what's possible. Repair and preservation.

Resources

Contributing

Stars

21 stars

Watchers

4 watching

Forks

Latest commit

 

History

123 Commits

Folders and files

Repository files navigation

RED DSMC2 — Owner's Reverse-Engineering Notes

This repository holds independent reverse-engineering of the RED DSMC2 camera platform. It is for owners who want to keep discontinued bodies and their end-of-life media running. The reference body is a SCARLET-W 5K on firmware 7.4.1.

This repository documents what the platform is, what is possible with it, and how to do it. It publishes the keys, the methods, the access steps, and working tools, so that owners can maintain hardware RED no longer sells.

Status (2026-11). A custom DSMC2 firmware — production and dev images — has booted and run on a camera. The method is proven on hardware, not just mapped. What remains is the release: the hardening and recovery tooling that make a flash safe and reversible for owners who are not the author. Please do not patch or flash your own camera from this material yet — a verified build is not the same as a finished one, and an early-boot change applied wrongly can stop a body booting. The safe build and a clear procedure will be announced here when ready. See docs/custom-fw/builds.md.

Roadmap & status

  • Done — the platform is fully reverse-engineered: firmware packaging + decryption, the bootloader, the whole application, the capability system, media authentication, calibration, and the code-injection method. All documented here.
  • In progress — a custom firmware in two flavours: a production image (safe, repair-positive fixes only) and a dev image (engineering tools). See docs/custom-fw/builds.md and docs/whats-possible.md.
  • Not yet — do not self-patch from this material. A custom image has booted on a body, so the method is verified; the safe, recoverable build and its procedure are still being finished.
  • Follow it — a Discord tracks this work and the build's release; for an invite or any question, email radosek@pm.me (see Community & contact).

Context. This is independent research on hardware the author owns. The goal is repair and preservation. The focus is the MINI-MAG media, which RED has discontinued and no longer makes parts for — so there is no RED media product or service that this work competes with.

RED stopped selling DSMC2 camera bodies in December 2022 (Discontinued Sales: DSMC2 and RANGER). RED still offers technical support and service for the bodies, "parts availability permitting", and DSMC2 is not on RED's no-longer-repairable list (which names RED ONE, MYSTERIUM-X and DRAGON). After the Nikon acquisition, Nikon stated it planned no changes to RED's lineup and that warranty, repair and product support would continue.

The RED MINI-MAG 1TB, 512GB and 240GB media, by contrast, is on that discontinued-products page, marked "repair parts no longer available" — which is why this repository documents the cheap-SSD media path in full.

There is more — the private contributor hub (dsmc2-sdk)

This public repo is the owner-facing slice. The full reverse-engineering — the subsystem findings, the reference maps, the buildable SDK, and the RE tooling — lives in a separate private repository, dsmc2-sdk, the contributor hub. Private here is a timing gate, not secrecy: owner-ready, safe material is routed out to this public repo as it matures. For access, email radosek@pm.me.

The platform is reverse-engineered end to end. What is already done and documented in dsmc2-sdk (summary — this public repo carries the owner-facing subset):

Boot & firmware

  • Full boot flow map, boot-failure diagnostics, SYSTEM_ERROR 34 gate trace + repair tree, complete Startup Error 0x01–0x07 latch map (incl. the exact 0x02 /env-signature cause).
  • Bootloader analysis: loader M2 RE, bootloader-from-package, size/partition layout.
  • Firmware package format + the signature scheme, decryption (both embedded decrypt keys), the own-key signing path (env_sign / own-key; no RED package signing key exists or is needed), /env signature algorithm.

Application & subsystems

  • Whole DSMC2 app decompiled, labeled, characterized: HW_CAP map + hidden debug variables, RTTI class map, app-subsystem map (see Ghidra block for function counts).
  • Calibration subsystem: file integrity, serial provenance, media RC4, command surface. Plus CDB2 SQL schema, side module, Wi-Fi (Redpine), SATA/CDB upgrade, RCP protocol, RED protocol speed, DSP C64x.
  • Sensor readout width / 6K, ISP 6K tiling chain.

Peripherals (the whole stack, not just the ARM app)

  • ISP + IOB Xtensa cores named & characterized, ISP encode pipeline, LSB FPGA named & characterized, RSB/SB, 1-Wire signature + sensor-ID, shared-code map, Xtensa calling conv.

Reference maps

  • OMAP memory map, I2C device map, UCD register map, power-rail map, FileX/NetX/ThreadX ABI, RTOS lib internals, ThreadX source validation, 59C golden baseline.

Buildable SDK & tooling

  • Linker-symbol sets (app + RTOS + loader + commands), clean reworked C of key subsystems (hw_cap, media-auth, record/codec, media/clip, playback, serial-2), engineering shell commands as injectable C, patch framework (patch_741, named patch sets incl. own-key), feature-menu applier (redml) with safe-zone analysis.
  • Private host CLIs: dsmc-fw (build/patch/sign/flash, fail-closed brick-gate), dsmc-re (RE/architecture-query), redtools-rs, camtool-rs, rftp-rs; bench flasher + boot-log puller (live-proven).
  • RE tooling: LLM-assisted naming workflow, BSim/FID scripts.

Ghidra reverse-engineering (the built state behind the symbols)

  • The app is fully analyzed and labeled: SYMBOL_MAP.txt — 3530 firmware function addresses recovered by name; the function DB (redfw.sqlite, below) carries 4315 named functions. (The labeled Ghidra projects themselves live in the private RED working tree — bulky to mirror and not needed to build the SDK; dsmc2-sdk ships the DB, the exports, and the rebuild recipe.)
  • Function DB: redfw.sqlite (+ diffable JSON export) — functions, call graph, string xrefs, OMAP MMIO touch-points — queryable via redq / dsmc-re q (who-calls, xrefs, stats). A loader DB (bl741) too.
  • Exported tables: RTTI/vtable map, globals report, handler/dispatch tables, struct-candidate mining (struct_offsets, boot_env_structs.h), source-tree/layout reconstruction from log strings.
  • Ghidra scripts + full rebuild recipe: DecFn, RefsToRange, WhoCalls, LabelFromLogStrings (auto-naming from __FILE__/__FUNCTION__ log descriptors), module split, struct/table/RTTI scanners, OMAP register labeling, the Xtensa cspec patch, serial-redaction.

Also covered

  • DSMC1 (EPIC/DRAGON) findings, bug-hunt rounds (UI boot, SSD write), LCD panel swap, disk support extension.

Quickstart — the tools

The debug and firmware tools are Rust. You need the Rust toolchain (rustup.rs). Build and run each tool from its own directory.

dsmcdbg — debug a live camera. It reads the camera over the serial shell, captures every board signal, and compares the result to a known-good baseline.

cd tools/dsmcdbg
cargo run -- selftest --port /dev/cu.usbmodemXXXX   # full health check vs the golden baseline
cargo run -- log decode <logfile>                   # decode an exported .enc log

dsmc-fw-core — read firmware. It decrypts packages, reads and builds .preset files, lists NAND recovery dumps, and unpacks RED ONE firmware. It does not sign or flash.

cd tools/dsmc-fw-core
cargo run -- unpack --list <combo.bin>              # list the models in a package
cargo run -- unpack --extract 0x16 --out DIR <combo.bin>
cargo run -- preset read <file.preset>

The private build / patch / sign / flash tool (dsmc-fw) and the reverse-engineering tool (dsmc-re) are in the dsmc2-sdk repository. Clone it next to this one (the two repositories must be siblings).

Contents

Area What it covers
docs/platform.md What the DSMC2 is: processor, OS, coprocessors, buses
docs/models.md The DSMC2 model family and how models differ
docs/dsmc1/ DSMC1, both branches: MX/Dragon (same platform as DSMC2) and RED ONE (PowerPC/VxWorks)
docs/whats-possible.md What the research enables (outcomes)
docs/features/subsystems.md Per-subsystem map: software lever vs hardware limit
docs/custom-fw/builds.md Custom firmware: status, what is coming, and the safety model
docs/custom-fw/code-injection.md The method behind the custom firmware (status page, not a how-to)
docs/features/reliability.md Reliability findings (SATA write-retry, log spam)
docs/firmware/firmware.md Package formats (v2/v3) and how the encryption works
docs/firmware/keys.md The keys: where they live, how they were recovered, what each opens
docs/access/serial-shell.md Enabling and using the DSMC2 debug shell
docs/firmware/log-decode.md Decoding the camera's obfuscated log
docs/access/shell-commands.md Debug-shell command reference
docs/access/shell-debug-playbook.md Which shell commands work, and how to read results
docs/features/feature-unlock.md Features, capabilities, and model identity
docs/features/calibration.md Regenerate, back up, or transplant sensor calibration
docs/firmware/extraction.md Pulling the filesystem and firmware image off the camera
docs/hardware-fw/peripheral-firmware.md Coprocessor and accessory firmware images
docs/hardware-fw/accessory-bus.md The accessory bus: module enumeration, identity, why nothing is crypto-locked
docs/features/anamorphic.md Anamorphic de-squeeze ratios, measured per sensor
docs/features/ipp2.md In-camera IPP2 on a Dragon-5K body: one capability bit, not a sensor lock
docs/research-notes.md Difficulties, insights, and the research story
media/ MINI-MAG and compatible SSDs

Tools and hardware

The debug + firmware tooling is Rust, built over a shared library (dsmc-core). The flagship is dsmcdbg — it talks to a live camera, captures a full board signal set, and diffs it against a golden healthy baseline. dsmc-fw-core is the firmware read/decrypt/preset/recovery CLI (it replaced the old unpack_combo.py / red_preset.py / nand_list.py). The private build/patch/flash and reverse-engineering CLIs live in dsmc2-sdk.

Area What it is
tools/dsmcdbg/ Flagship debug CLI (Rust): live-camera verify/selftest, capture, and diff vs the golden baseline
tools/dsmc-fw-core/ Firmware CLI + lib (Rust): decrypt/unpack packages, read/build .preset, list NAND recovery dumps
tools/dsmc-core/ Shared Rust lib: serial shell driver, reply parsers, I2C/UCD maps, baseline model
tools/fw-crypto/ The embedded RSA decrypt keys (used by dsmc-fw-core unpack)
tools/red-log-decoder/ The log XOR pad + cipher proof (decoder is dsmcdbg log)
tools/redone-su/ RED ONE redone.su format (unpacker is dsmc-fw-core redone)
tools/rom-recovery/ DSMC2 block-0 recovery over the UART3 boot ROM (bare-metal image + rig)
hardware/serial-bridge/ USB↔CTRL RS232 bridge: RP2040 firmware + wiring
hardware/display-repair/ Touch LCD panels, digitizers, connectors, thread inserts
hardware/expander-repair/ Expander pogo-pin spring fix

The media folder

Document What it covers
media/README.md Overview and the short version
media/authentication.md The three checks (model string, signature, geometry) and the signature algorithm
media/media-table.md Every approved model string and its OEM
media/compatible-ssds.md What to buy in 2026, and why a buyable drive needs the camera patch for full rate
media/mag-firmware.md The MINI-MAG controller .rmf firmware format
media/hardware.md The connector/adapter board

Scope

Everything needed to keep a DSMC2 and its media running is here: the firmware decryption keys and unpacker, the preset key and tooling, the serial-shell access path, the log decoder, and the serial-bridge hardware. The one thing not present is a package signing key — the camera holds none, so nobody has it — but signing is not required for any of the above, because the bootloader does not verify the installed image. See docs/firmware/keys.md.

The one thing still in progress is the custom firmware build itself — the research is complete and a custom image has booted on a camera, but the shippable, recoverable image an owner can flash safely is not done yet. Do not self-patch from these notes in the meantime; wait for the announced build.

Community & contact

There is a Discord for owners following this work and the upcoming custom firmware. For an invite, or any question about the project, reach out: radosek@pm.me.


DSMC2 Virtual Brain (Emulator)

This repository includes DSMC2 Virtual Brain, a full-system hardware and RTOS emulator for RED DSMC2 cameras.

The emulator runs user-supplied ARM Cortex-A8 firmware (dsmc_program.mem), models OMAP3630/DM3725 peripherals (INTC, GPTimers, PRCM, UARTs, I2C, sDMA, McSPI, GPMC NAND) and coprocessors (Xtensa IOB0/IOB1, Xtensa ISP, TI C64x+ DSP), and provides a browser-based Web Studio with an interactive 1024x576 touchscreen and RED Command Protocol (RCP) control.

See emulator/README.md for setup instructions, architecture documentation, and CLI commands.

About

Reverse-engineering notes for the discontinued RED DSMC2 camera platform: media (cheap SSD magazines) fully documented, plus platform, models, and what's possible. Repair and preservation.

Resources

Contributing

Stars

21 stars

Watchers

4 watching

Forks

Releases

Packages

Contributors

Languages