Requirements for Rockbox DAP: (last updated 2025-07-11) * Physical/Case 1) Small, eg Sansa Clip+ or ClipZip (60 x 33 x 10mm, tiny 1" screen) 2) Medium, eg AGPTek Rocker (83 x 40 x 10mm, 1.8" screen) 3) Large, eg iPod Classic, (104 x 62 x 11mm, 2.5" screen) Demand exists for all three classes, though feature expectations go up with each size (and price point). * 9+ physical buttons: * Four directional keys (Up, Down, Left, Right) logically arranged * Subsituting a rotary encoder (eg wheel or knob) for a pair of directional controls is okay, if done well * Play/Pause/Select (ideally in the center of the direction keys) * Power * Home / Back * Vol Up & Vol Down * Menu (if possible) * Physical lock switch strongly preferred but not strictly needed * Ideally use dedicated GPIOs for each key to allow for simultaneous keypresses. * Matrix-based input can be used as an alternative * ADC-based key input (each key with a different restistor/voltage is also okay (recommend tying line to GPIO to allow sampling ADC only on demand) but prevents registering multiple keypresses * Note power and lock must always be on dedicated GPIOs! * Note that the tiny Sansa Clip series manages to get 9 buttons in its tiny form factor, lacking only a lock switch. Physical case size is not an excuse to skimp on controls. * Hard reset circuit; either dedicated button or hold button [combo] for 10s. * Display * OLED preferred, but LCD is acceptable. E-ink may also be viable. * No touch/digitizer preferred (having one isn't a problem, but primary interaction must be via buttons) * Color screens should be at least 16-bit (eg RGB565) * Decent viewing angle * Physical size and resolution will depend on final form factor: * 128x64 min for small * 160x128 min for medium * 320x240 min for large (portrait or landscape orientation) * Backlight/brightness control (eg via native display or SoC PWM) * Must support display shutdown (via GPIO?) * "standard" parallel LCD bus preferred, I2C/SPI LCD acceptable if system DMA controller (or embedded 2D GPU) can auto-refresh display from a static framebuffer at 30Hz or better. * uSD card slot * SD2.0 (4-bit) support, ideally UHS-1 capable * USB-C port for charging and data * USB-PD nice (for rapid charging) but not necessary * USB 2.0 High Speed or faster * OTG support preferable, to support operating in host mode * Capable of reporting plug/power/charging state to system * Audio * Small / Medium form factor: * Builtin SoC codec (capable of at least 16bit/48KHz) * Medium / Large form factor: * External I2S/SAI-attached codec (capable of 24bit/192KHz) * I2C-based control path * Native DSD support will probably not get utilized * Reasonably decent audio path (eg isolated power supplies, don't cheap out on decoupling/filtering) -- especially on medium to large form factors. * Independent PLL for audio clocks (most SoCs do this) * For larger form factors, support both headphones and true line out audio paths. Dual jacks strongly preferred. * Jack(s) detect physical plug insertion (GP Input) * Any external analog output must be mutable (GPO controlled) * Audio DMA must be capable of double-buffered circular operation * Support for inline audio controls is nice-to-have * Debug * UART test points * JTAG/SWD/etc test points * SoC-supported USB-based recovery mode strongly desired * Built in recovery/programming mode * Battery * Capacity and dimensions depends on physical device size * Voltage/Charge level monitor (via ADC or PMIC) * Sized to operate player for at least 8-12 hours with screen off. * RTC * 32KHz XTAL * Alarm wakeup Nice to have: * Bluetooth * "Classic" BT audio must be present, but modern LE audio good to have * UART attached * I2S audio (bi-directional capable) * A2DP (v1.2+) and AVRCP (v1.3+) * AAC/AptX support desired * SW/Stack License *MUST* be compatible with GPLv2! (This is why we do not have any Bluetooth support currently) * FM Radio tuner * I2S audio, I2C for control * Uses headphone cord as antenna * DAB support * HD radio support a bonus (probably not realistic in our power budget) * Recording support * Built-in microphone or piggy backing on headphone jack * Line in * USB audio * FM Radio (if equipped) * Bluetooth (if equipped) Pointless (and/or power-hungry) gimmicks: * WiFi or Ethernet * Built-in speaker(s) * Tube amps or replacable/multiple DACs * Balanced or digital/optical inputs/outputs * On-device flash for audio/data storage (Just use an uSD card!) * 3D GPU of any sort (Rockbox is 2D only) * NPU or "AI" features of any sort Requirements for MCU-based player: (bare-metal, no operating system) * MCU * Any 32-bit CPU arch is okay, but must have full upstream F/OSS toolchain. * 400-500MHz clock speed ideal, 160MHz minimum viable for single core * FPU not needed, but DSP/SIMD can help if available * MMU/MPU not needed * Dynamic clock control * Priority-aware interrupt controller * Supports off-chip RAM * RAM: * 256KB (or more) of fast on-chip SRAM * 1MB on-chip RAM preferred if we don't have flash capable of XIP * 8MB non-banked external RAM minimum, 32MB ideal, over 64MB is wasted * Note that SPI-attached PSRAM is rarely acceptible (it's usually fairly slow and often banked, preventing true random access) * Flash: * 128KB on-chip for bootloader (64K with no USB) * 1MB on-chip needed for execute-in-place rockbox * Do *NOT* care about storing audio in on-board flash! * Other: * Some sort of recovery mode that enables updating flash over USB (ie without opening the case) * F/OSS flash (and/or recovery) tools that can run on a variety of operating systems The STM32H7 family seems ideal due to its large amount of on-chip RAM and flash, but the STM32F7 family is similar but slower/smaller. The STM32F4 family is probably the lowest-end for a viable device. Note that while this is our preferred route, we understand it probably does not make sense economically, due to relatively high BOM versus an integrated SoC with stacked or on-package DRAM. Requirements for a full CPU (and/or Linux-based) player: * CPU * Single-core, 500MHz-1GHz range (any 32- or 64-bit CPU architecture) * FPU not needed, but DSP/SIMD can help * Must support dynamic reclocking for power savings * >1GHz or Multicore CPU will be wasted * RAM: * 32MB absolute minimum, 64M-128MB ideal, over 256MB is wasted * On-package (or stacked) RAM strongly preferred due to lower BoM cost * Flash: * If SoC supports SD card boot, small serial I2C eeprom (<1 kbit) nice to have, to store serial number, Bluetooth address, etc. On-chip OTP will also suffice. * Otherwise, for bare-metal system, 2MB NAND flash minimum. Linux-based will need 32MB minimum. Over 64MB is wasted. * Will be read-only at runtime to prolong flash life * SoC: * Full source code to reference bootloader and Linux kernel is MUST-HAVE * Mainline/Upstream support strongly preferred but not strictly necessary * Must have upstreammed F/OSS toolchain * GPU/ISP/etc capabilities do not matter; Rockbox only uses basic 2D framebuffer. * For linux-based systems, display controller must be usable via the standard fbdev APIs, preferably with double-buffered bank switching to enable tear-free operation. * Audio controller driver connected to standard ASoC layer * DMA driver fully supports scatter-gather * Ideally, some sort of USB-based recovery/flash mode Note that battery life is more important than raw performance. That said, it is likely that the analog audio path will be the largest power consumer when the screen is off. We would prefer to port Rockbox to the bare metal hardware, using the Linux code only as a reference. However, the system should be powerful enough to provide a good user experience even when running rockbox on top of Linux. Fast bootup time is strongly desired. If we do build on top of a Linux system, we anticipate that we will create our own cut-down Linux distribution rather than relying on a vendor reference/example system. **** SoCs identified that look like good fits: * Allwinner F1C100s/F1C200s (aka F1C600 / F1C500) * ARM926EJ-S @ 500MHz, 32/64MB SiP RAM * Popular choice for retro handheld game emulators * Allwinner V3/V3s (aka Sochip S3/S3L) * Cortex-A7 @ 1.2GHz, 128/64MB SiP RAM * Popular choice for higher-end retro handheld game emulators * Allwinner V851SE/V851S * Cortex-A7 @ 900MHz (+ RISC-V @600MHz), 64MB SiP RAM * Ingenic X1000/X1000e * MIPS32r2 @1GHz, 32/64MB SiP RAM * This is _very_ popular with higher-end non-Android DAPs. All of the above have public documentation, upstream Linux, and GCC support. The F1C series in particular is _very_ cheap and is still plenty capable for our needs! Possible (more modern/powerful) Alternatives: * Ingenic X1600/X1600E/X1600N * dual MIPS32r2 @1.0GHz, 32/64/128MB SiP RAM * Ingenic X2000/X2000E/X2000H * dual MIPS32r5 @1.2GHz, 128/256/512MB SiP RAM Both of the Ingenic series are vast overkill for our needs but are likely easier to obtain than the X1000 series. Decent upstream Linux support but all shipping devices are based on ancient vendor kernels. * Allwinner D1s/F133 * C906 64-bit RISC-V @1GHz, 64MB SiP DRAM * Appears to be supported by mainline Linux * Completely new CPU architecture for Rockbox; more up-front work, especially for a bare-metal port * Only known docs on the CPU core are Machine-translated from Chinese * Allwinner T113-s2/s3/s4 * Pin-compatbile with D1s * C906 64-bit RISC-V @800MHz * 2x Cortex-A7 @ 1GHz (1.1GHz for the s3p/s4p variant) * "HIFI4 DSP 600M" (likely will not be used by rockbox) * 64/128/256MB of SiP DRAM * Vast overkill for our needs