Posts Tagged ‘gstreamer’

e-con Systems Launches e-CAM130_CUTX1 Ultra HD Camera for Nvidia Jetson TX1 Development Board

January 20th, 2017 No comments

e-con Systems, an embedded camera solution company, has just announced the launch of e-CAM130_CUTX1 MIPI camera board for NVIDIA Jetson Tegra X1 development kit. The 13MP camera is based on On Semiconductor AR1820 CMOS image sensor, connects to TX1 board via its 4-lane MIPI CSI-2 connector, and supporting up to 3840 x 2160 @ 30fps/ 13MP@ 20 fps video streaming in uncompressed YUV format.

Jetson TX1 Board fitted with e-CAM130_CUTX1 camera module

e-CAM130_CUTX1 4K camera board features & specifications:

  • Sensor – 1/2.3″ Optical form factor AR1820HS sensor with on-board high performance ISP.
  • Focus Type – Fixed focus
  • Resolution: – 13MP on e-CAM130_CUTX1 (The sensor is capable of 18MP)
  • Pixel size – 1.25μm pixel with Aptina / ON Semiconductor A-PixHS with BSI technology and advanced pixel architecture
  • Sensor Active Area – 4912(H) x 3684(V)
  • Responsivity – 0.62 V/lux-sec (545nm); SNR: 36.3 dB; Dynamic Range: 65.8 dB
  • Output Format – Uncompressed YUV422 format and compressed MJPEG format. YUV422 resolutions:
    • VGA @ 60 fps
    • HD (720p) @ 72 fps
    • Full HD (1080p) @ 72 fps
    • 4K/Ultra HD @ 30 fps
    • 13MP @ 20 fps
  • Shutter type – Electronic Rolling Shutter
  • DFOV : 13M – 74°, 4K/1080p/720p – 69°, VGA – 72°
  • Interface – High-speed 4-lane MIPI CSI-2 interface
  • Operating Voltage – 5V +/- 5%, Current – 450mA
  • Dimensions – 75.03 mm x 40.18 mm x 25.6 mm (without lens)
  • Weight – 20 grams without lens, 26.5 grams with.

The board comes with an S-mount (M12) lens mount that enables customers to choose a lens of their choice.

The company provides a standard V4L2 driver for the camera board, which also supports Gstreamer 1.0 for video recording and networking streaming, and can be controlled with programs such GUVCViewer as demonstrated in Ubuntu 16.04 in the video below.

e-CAM130_CUTX1 4K camera module is available now for $249 via e-con Systems product page, where you’ll also find documentation (free email registration required) such as the datasheet, a getting started guide, various usage guide, and a developer’s guide.

AVC8000nano mini PCIe Frame Grabber Captures up to 8 D1 Videos

February 25th, 2016 1 comment

There are plenty of solutions to stream or capture multiple video streams from cameras, but example for security purpose, but usually the equipment is relatively large and heavy. Advanced Micro Peripherals AVC8000nano mini PCIe capture card miniaturizes all that thanks to its form factor, and its 8 u.FL connectors used to capture eight D1 videos at full frame rate.

AVC8000nano Connected to Gateworks Ventana SBC and 8 Cameras

AVC8000nano Connected to Gateworks Ventana SBC and 8 Analog Cameras

AVC8000nano features:

  • Video Inputs
    • 8x Live NTSC/PAL video inputs with 8x 10-bit ADC and anti-aliasing filters
    • 8x D1 size capture at full frame rate
    • Formats – NTSC-M, NTSC-Japan, NTSC (4.43), RS-170, PAL-B,G,N, PAL-D, PAL-H, PAL-I, PAL-M, PAL-CN, PAL-60 SECAM
    • Adjustments – Contrast, saturation, hue (or chroma phase), and brightness. Software adjustable Sharpness, Gamma and noise suppression
  • Video Capture FormatsRGB555, RGB565, YCbCr 4:2:2, YCbCr 4:1:1
  • Windows support with Drivers and DirectShow/DirectDraw
  • Linux with drivers and Video4Linux
  • Form factor – Full height mini PCI Express
  • Temperature Range – Commercial: 0°C to 60°C; Extended: –40°C to +85°C

AVC8000nano Block Diagram

The specifications also mentions hardware requirements: “x86 PC-Compatible with mini PCI Express socket”. But as you can see on the first picture, Gateworks managed to make the card work on their Ventana single board computers powered by Freescale/NXP i.MX6 and featuring one or more PCIe connectors so it’s also suitable for ARM platforms. The company also updated their Wiki to show how to use it on their boards with Linux (built with Yocto Project 1.8) using AVC8000nano drivers, Gstreamer, and optionally OpenCV if you want to stitch multiple inputs together.


Stitching with OpenCV

Such solutions can be used for vehicle-based Video Capture, real-time situational awareness, law enforcement, remote video surveillance, traffic monitoring and control, video acquisition & analytics, UAVs,  and more.

You may want to visit AVC8000nano product page for more details. Although it has been launched in 2013, I could not find price information for the capture card.

iMX6 TinyRex Module and Development Board Support HDMI Input in Linux (Video Demo)

December 2nd, 2015 2 comments

A couple of years ago, I wrote about iMX6 Rex open source hardware project combining a Freescale i.MX6 SoM and baseboard that aimed a teaching hardware design (schematics and PCB layout). I had not followed the project very closely since then, until I watched a video showcasing HDMI input capabilities in Linux using the new version of the module and baseboard called i.MX6 TinyRex.

Click to Enlarge

Click to Enlarge

i.MX6 Tiny Rex module specifications:

  • SoC – Freescale iMX6 processor up to 1.2GHz and 4 cores
  • System Memory – Up to 4GB DDR3-1066 (533MHz)
  • Storage – EEPROM
  • Connectivity – 10/100/1000 Mbps Ethernet PHY
  • I/Os via 3 board to board connectors:
    • Display / Video Output
      • 1x HDMI (up to QXGA 2048×1536)
      • 1x LVDS (up to WUXGA 1920×1200)
      • 1x 20-bit parallel LCD display (up to WXGA 1366×768) or 1x Video Input (CSI)
      • 1x MIPI DSI differential display output (up to XVGA 1024×768)
    • Video Input
      • 1x 20-bit parallel video input CSI (up to 8192×4096)
      • 1x MIPI differential camera input
    • Storage – 1x SATA; 1x NAND Flash or 1x MMC (8bit); 2x SD (2x 4bit or optional 4 & 8bit)
    • 1x PCIe
    • 2x USB
    • 5x UART, 3x I2C, 2x SPI, 1x CAN
    • Digital audio
    • 2x GPIO, 2x GPIO or PWM
    • System signals -Reset in/out, Boot mode, Power ok, User button
  • Misc – User LED, power LED, JTAG on testpoints
  • Dimensions – 38 x 38 x 4.8
  • Power –  2.7 to 5.5V DC, single +3.3V and +5V
iMX6 Tiny Ref Module Block Diagram (Click to Enlarge)

iMX6 Tiny Ref Module Block Diagram (Click to Enlarge)

The company provides Linux support via the Yocto Project. Bear in mind that contrary to OpenRex, TinyRex is not open source hardware. In order to complement the module, iMX6 TinyRex baseboard Lite has also been designed by Fedevel, and manufactured by Voipac.


Click to Enlarge

Baseboard specifications:

  • Storage – 1x SATA port, 1x micro SD card slot, up to 128Mbit on-board SPI Flash
  • Video
    • 1x HDMI Output with Audio
    • 1x micro HDMI input with audio (e.g. from GoPro camera) via ADV7610 HDMI receiver.
    • 1x MIPI-CSI camera input (compatible with Raspberry Pi)
  • Connectivity – 1x Gigabit Ethernet
  • USB –  1x USB (Optional: 2x USB ), 1x micro USB OTG port
  • Expansion
    • 1x PCIE mini card socket (PCIE & USB)
    • Headers with 4x UART, 1x SPI, 1x CAN (CMOS), 3x I2C, 2x PWM, 8x GPIO
  • Debugging – 1x UART debug console header (compatible with FTDI cable)
  • Misc – Reset & user buttons, power and user LEDs,
  • Power Supply – 3.2 to 5.5V DC via power barrel
  • Dimensions – 90 x 80 mm (with four holes for heatsink)
Click to Enlarge

Click to Enlarge

The schematics for the baseboard are available on request, and software documentation can be found on imx6rex website, including one part showing how to use HDMI input with the Yocto built image which using Video4Linux2 (V4L2), adv7610 driver, and Gstreamer. The demo below shows how to output the HDMI input to an HDMI monitor. It’s not very useful by itself, unless you do some processing or use as video stream as part of an application, but shows the system works, and could be modified for live video streaming for example.

I understand iMX6 TineRex module and baseboard should be available by the end of the year, or Q1 2016, with the module starting at 59 Euros for 1k orders. Further details can be found on iMX6 TinyRex SoM and Baseboard Lite product pages.

Embedded Linux Conference 2013 Schedule

January 24th, 2013 2 comments

ELC 2012

The Embedded Linux Conference (ELC 2013) will take place on February 20 – 22, 2013 at Park 55 Hotel in San Francisco, California.

ELC consists of 3 days of presentations, tutorials and sessions. There will be over 50 sessions during those 3 days. I’ll highlight a few sessions that I find particularly interesting, and that did not get presented at ELCE 2012 (AFAICR).

February 20

We are now two years into the new maintainer model for ARM platforms, and we have settled down into a workflow that maintainers have adjusted well to. Still, when new platforms arrive, or when maintainer ship changes hands, there’s sometimes a bit of ramp-up in getting used to how we organize our git tree and how we prefer to see code submitted to fit that model.

This presentation will give an overview of how we have chosen to organize and maintain the arm-soc tree, and advice to developers and maintainers on best practices to help organize your code in a way that makes life easier for everybody involved.Main audience for this presentation is developers working on upstream kernels for ARM platforms, including platform maintainers.

The Yocto Project was announced slightly more than 2 years ago at ELC-E Cambridge and in the OpenEmbedded e.V. General Assembly the day after the conference I proposed to embrace and adopt the Yocto Project as the core for OpenEmbedded.

In the past 2 years the ecosystem has seen tremendous growth, but not always in sane directions. This presentation will detail how the Yocto Project, the OpenEmbedded Project, the community and the companies involved evolved during that time.

The Angstrom Distribution and the Beagleboard will be used as examples since those were first OE classic targets to be publicly converted to the new world order.

This presentation will also try to clear up to confusion about what people actually mean when they say “this runs yocto” 🙂

LTSI is the Linux Foundation CE workgroup project that creates and maintains long-term stable kernel for industry use. Recently LTSI-3.4 was released, and it is committed to being kept maintained till the community applies bug-fix and security fix patches on LTS-3.4. The community LTS maintainer Greg Kroah Hartman stated it would last at least till May 2014. This would dramatically reduce your own effort to collect such important patches by you. Furthermore, Linux Foundation Yocto project that provides a recipe for custom Linux BSP creation will add support for LTSI kernel from this release. Given this significant improvement I want to help LTSI user to start work with it. In this session, I will introduce the specification of LTSI-3.4 (enhancement from the community kernel) and how to write a Yocto recipe to collect your own enhancement patches on top of the official LTSI-3.4 kernel.

The common clock framework, which was included in the 3.4 kernel in the beginning of 2012, is now mandatory to support all new ARM
SoCs. It is also part of the “one zImage to run them all” big plan of the ARM architecture in the Linux kernel.After an introduction on why we needed this framework and on the problems it solves, we will go through the implementation details of this framework. Then, with real examples, we will focus on how to use this framework to add clock support to a new ARM SoC. We will also show how the device tree is used in this process.The last part of the talk will review how device drivers use this framework, using examples taken from various parts of the kernel.

Multi-core processors are now the rule rather than the exception in high-end applications. But, as we try to port our legacy applications to multi-core platforms, what pitfalls lay in wait? This presentation will outline the conditions that lead to multi-core race conditions and outline the techniques for identifying and redesigning code to successfully function in a multi-core world.

GStreamer is the leading multimedia framework for various OS platforms, notably Linux systems. A variety of multimedia applications can be constructed with well-implemented plugins, which have versatile functions such as image scaling, cropping, color conversion, and video decoding. However, in the case of embedded systems, they should require further system integration to utilize specialized hardware acceleration engines in SoC for optimal performance.

This presentation shows the case study experience of integrating video plugins with a Renesas SoC platform. It will discuss how to access hardware inside a plugin, assigning buffer memory suited for hardware, and eliminating the ‘memcpy’ call.The audience will learn about essential technique for integrating GStreamer into embedded system. An understanding of the basics of video codecs and color formats is required.

February 21

This BoF is intended to bring together anybody that tests the Linux kernel to share best practices and brainstorm new ideas. Topics may range from .config testing, module/built-in drivers, test methods and tools for testing specific driver subsystems, VM/scheduler/interrupt stress testing, and beyond.

The discussion is targeted at Linux kernel developers, test engineers, and embedded Linux product teams/consultants with the common task of testing Linux kernel integrity. Attendees should have a firm grasp of building and deploying the kernel as well as kernel/userspace kernel APIs.

The LLVM project is an extensive compiler technology suite which is becoming commonplace in many industries. Technology built with LLVM is already shipped in millions of Linux devices as a part of Android/Renderscript. Increasingly it is becoming a big part of the development process for embedded projects, all the way up through to high performance computing clusters. This session will provide an update on the status of the LLVM Linux project; a project which is cooperating with both the Linux kernel and LLVM communities to build the Linux kernel with Clang/LLVM.This talk is for experienced developers who are interested in toolchain technology and Linux Kernel programming.

In 2003 I decided to replace twenty-two GNU packages in Linux From Scratch (everything except the compiler, kernel, and libc) with BusyBox, and then rebuild the result under itself. This didn’t remotely work, so I started testing and improving BusyBox until it did, putting in so much work on BusyBox its maintainer handed the project over to me.In 2006 I handed BusyBox off to a new maintainer and started over from scratch on a fresh implementation, Toybox. In 2011 Tim Bird (founder of CELF) convinced me to repurpose Toybox as a new BSD-Licensed Posix-2008 compliant command line for Android.

This panel explains what’s in the “standard” Linux command line: drawing commands from POSIX, LSB, Android Toolbox, Linux From Scratch, and more. How to determine what should be in the base system, and how to know what to exclude, and why the “standards” aren’t enough.

Closed-source binary drivers and libraries are endemic in embedded, with binary blobs essential on many modern boards to use the on-board 2D, 3D, or video acceleration. Recently there has been progress in open drivers from manufactures for various platforms including Intel, from 3D acceleration with OpenGL to hardware video decode/encode with VA API. This presentation will explain why open drivers are better than closed, discuss the options available, and describe what is available in the Yocto Project BSPs for you to use.The audience for this talk is expected to be developers and architects interested in the state of open graphics in Linux. Knowledge of this field will be assumed.

Performance is an important aspect when developing mobile applications as it affects both the interactive user experience and the device battery life. This presentation will introduce techniques and tools (e.g. profilers) useful for creating high-perfomance code starting at the high-level design stage (code organisation, data layout, etc.) and following through to implementation considerations. Specific instruction sets (e.g. NEON) will not be a primary focus, the goal rather being to enable efficient use of these without delving into details, thus giving the presentation a broader applicability.The target audience is developers of compute-intensive (native) applications or libraries who need to achieve the best possible performance. No special expertise beyond general familiarity with userspace Linux programming is assumed.

As costs have come down and the power of embedded platforms has increased, the hacker/maker community is playing an increasingly critical role in the creation of disruptive technologies. The “Next Big Thing” will likely start out as a hacker project using a commodity embedded hardware platform. Intel’s Atom-based offerings continue to grow while targeting new niches in embedded applications. This talk will outline exciting new developments with Atom processors in the embedded space, and how hackers can make best use of these advantages.This talk will be relevant to hackers, hobbyists, and people interested in developing embedded products based on Atom, and is open to all technical experience levels.

February 22

The ‘In Kernel Switcher’ (IKS) is a solution developed by Linaro and ARM to support ARM’€™s new big.LITTLE implementation. It is pairing together an A7 (LITTLE) and an A15 (big) processor into a logical entity that is then presented to the kernel as one CPU. From there the solution is seeking to achieve optimal performance and power consumption by switching between the big or the LITTLE core based on system usage.This session will present the IKS solution. After giving an overview of the big.LITTLE processor we will present the solution itself, how frequencies are masqueraded to the cpufreq core, the steps involved in doing a “€œswitch”€ between cores and some of the optimisation made to the interactive governor.

The session will conclude by presenting the results that we obtained as well as a brief overview of Linaro’s upstreaming plan.

Always Innovating has announced a new product, the MeCam, a self video nano copter to point-and-shoot yourself. The MeCam launches from the palm of a hand and hovers instantly. This talk will review the lessons learned during the design of this product:

  1. hardware “- CPU: the choice and the different trade-offs involved with this selection.
  2. hardware -€“ sensors: the complete list of the 14 sensors, their advantages and drawbacks.
  3. software -€“ core: the architecture of the Linux based system and the key challenges.
  4. software -€“ stabilization algorithm: the experience during the tuning of the different algorithms participating to the self hovering.

This talk targets developer with good expertise in both hardware and software. No deep knowledge in a specific field is mandatory but serious understanding of ARM and the Linux kernel is a plus.

Since Completely Fair Scheduler (CFS), which is default scheduler of Linux mainline kernel, has been introduced in kernel 2.6.23, due to its remarkable performance, we’ve paid little attention to improving the scheduler. In this presentation, we will show the CFS limitations, unsatisfactory fairness among cores and long response time to user interactive tasks by some experimental result. And then we will explain you an example scenario to solve this vulnerable point in multicore environment.

Sometimes you may encounter segmentation fault at malloc or free. It looks a bug of malloc library, but at most case it is not. Some other part destroys heap management area. It is very hard to tell which program actually destroys the heap if the process is very large and uses so many libraries and threads.
In this session I will show you some tips to trouble shoot heap problem.

  1. tips of malloc library in glibc
  2. how to hook and replace malloc
  3. use mspace in dlmalloc to separete memory spaceExpected audience is developers who writes code in C/C++ language and want to solve problems related heap memory.

Summary of the proposal:

This talk describes the presenter’s experience with using the Yocto Project, along with various open source layers, to build a digital signage solution from scratch. The presenter covers how various components are used from the oe-core, meta-web-kiosk, meta-security, meta-virtualization, and meta-nuc layers to get a working solution for digital signage. The talk provides a live demo of the solution, along with access to the source code & build environment.

Targeted Audience:

This talk is targeted to the open source development community. The audience can expect to get more knowledge about how they can build their own digital signage solution with the help of the Yocto Project and various open source layers.

olibc is derived from bionic libc used in Android, which was initially derived from NetBSD libc. olibc is expected to merge the enhancements done by several SoC vendors and partners, such as Qualcomm, TI, Linaro, etc., which is known to be the major difference from glibc, uclibc, and other traditional C library implementations. Typically, the code size of olibc runtime should be about 300 KB. For ARM target, olibc would benefit from ARMv7 specific features like NEON, Thumb-2, VFPv3/VFPv4, and latest compiler optimization techniques. Also, olibc is released under BSD License.

Those are just my choices among over 50 sessions. You can check the full schedule to find out which sessions suit you best.

You can register for ELC 2013 online.

There are two type of fees:

  • Professional Fee (If your company is paying for you to attend this event): 550 USD
  • Hobbyist Fee: 100 USD (up from $70 last year, who said there’s no inflation?)

Prior to ELC 2013, you can also attend the Android Builders Summit on February 18 & 19 for $200 extra, and/or Yocto Project Developer Day on February 19 at no additional cost.

Video4Linux: Current Status and Future Work – ELCE 2012

January 17th, 2013 No comments

Hans Verkuil, R&D software engineer at Cisco Systems Norway, talks about Video4Linux status, progress, and plans at the embedded Linux Conference in Barcelona, Spain, on November 7, 2012.


Video4Linux is a fast-changing subsystem where a lot of work is done to support the complex video hardware of embedded systems. This presentation will give an overview of the developments in the past year and the work that is planned for the near future.

Hans covers SoC video devices support, core, control, and videobuf2 frameworks, HDTV timings & events API, video connector support, media controllers, codec & flash support, and more…

You can also download the slides for this presentation. For further details about development, subscribe to linux-media mailing lists or chat on #v4l IRC channel on freenode.

$159 CuBox Pro: Open Source Development Platform Based on Marvell ARMADA SoC

January 4th, 2013 3 comments

Back in 2011, SolidRun unveiled the CuBox, a miniature open source development platform based on Marvell Armada 510 SoC (88AP510) and aimed at applications such as multimedia, set-top-box, network attached storage (NAS), thin client, digital signage, automation… SolidRun has now announced an upgraded version called CuBox Pro based on the same platform but with 2 GB RAM, and a redesigned casing.

SolidRun CuBox ProHere are the specifications of this development platform:

  • Marvell Armada 510 SoC – 800 MHz dual issue ARM PJ4 processor, VFPv3, wmmx SIMD and 512KB L2 cache.
  • 2GByte DDR3 at 800MHz
  • 1080p Video Decode Engine
  • OpenGL ES 2.0 graphic engine
  • HDMI 1080p Output (with CEC function)
  • Gigabit Ethernet, SPDIF (optical audio), eSata 3Gbps, 2xUSB 2.0, micro-SD, micro-USB (console)
  • Standard Infra-red receiver for 38KHz based IR controllers.
  • No JTAG required. Unbrickable for Developers (i.e. you can’t brick the device to the point you have to physically remove the flash, burn it and solder it again to repair it)
  • Linux based distributions like Ubuntu, Debian and others
  • Android
  • Chrome with flash 10.1
  • Gstreamer with GPU acceleration
  • XBMC Media Center
The CuBox Pro sells for $159 with a universal power supply (5V/2A DC Output, 2.1mm/5.5mm standard connector) and a 4GB microSD with Ubuntu pre-installed. If the original CuBox was sold at a relatively competitive price ($135) in 2011, $159 for this type of system in 2013 is not what I would call a bargain, although it could be an option if eSata and Gbe is a must for your application, as those are not available on most boards. If you just need 2GB RAM, go get yourself an ODROID-U2 ($89) instead. Nevertheless, if you are still interested by this system, you may pre-order the board on Solid-Run Cubox Pro page, and you should receive it later this month.

Collabora and Fluendo Release GStreamer SDK for Android

December 3rd, 2012 No comments

Collabora and Fluendo have recently announced the availability of GStreamer’s Software Development Kit for Android, which allows developers to create multimedia playback applications for Android smartphones and tablets using Gstreamer and the Android NDK..

The GStreamer SDK for Android targets Android 2.3.1 Gingerbread or higher (API Level 9 or greater). However, due to some of the restrictions of previous versions of Android, some features such as hardware acceleration are only available on Android 4.1 Jelly Bean (API Level 16 up).

Normally, you’d need the GStreamer SDK which can be installed on Linux (Ubuntu, Fedora and Debian), Windows (XP/Vista/7/8) and Mac OS X (10.6 to 10.8). But for developing Android applications using Gstreamer, you don’t. What you do need first is a typical Android development environment with the latest Android SDK, the latest Android NDK, and optionally, but recommended, the Eclipse IDE with Android ADT and NDK plugins. Once everything is setup correctly, and you have made sure you can build NDK apps, you can download and install GStreamer SDK for Android (ARM only).

I’ve tried the instructions in Eclipse 4.2.1 with Android NDK 8b and Android Tools SDK 21 following the the instructions to install GStreamer for Android development. In Eclipse IDE, make sure the Android SDK and NDK paths are correctly setup (Window->Preferences->Android->NDK), and set  GSTREAMER_SDK_ROOT_ANDROID to the folder where you unzipped the SDK, by going to Window->Preferences->C/C++->Build->Build Variables and defining GSTREAMER_SDK_ROOT_ANDROID.

There are 5 tutorials provided in the GStreamer SDK for Android:

  • Tutorial 1: Link against GStreamer
  • Tutorial 2: A running pipeline
  • Tutorial 3: Video
  • Tutorial 4: A basic media player
  • Tutorial 5: A Complete media player

Eventually, it will be possible to add GStreamer code to Java apps, but language bindings for the GStreamer API are not complete yet. The tutorial are written in both C and Java code with Java used for the User Interface, and C for the GStreamer code, with both parts interacting through JNI.

To import a tutorial into the Eclipse workspace, click on File->New->Project… ->Android->Android Project from Existing Code, and select the folder android-tutorial-1 in GSTREAMER_SDK_ROOT_ANDROID/share/gst-sdk/tutorials.

At this stage, Eclipse might complain about missing files, but this is normal, and we need to add native development support by right-clicking on the project tutorial1 and selecting Android tools->Add Native Support… The NDK plugin should ask for a library name, just keep the default ( and accept. Click on Project->Build Project in the top menu. Once the build is complete, run the project: Run->Run, and after a little while, the demo should appear in the emulator or your Android device.

You should be able to reproduce the same steps with tutorial 2 to 5. Details are available on GStreamer’s Android tutorials page.

Freescale i.MX6 Resources: Development Boards, Documentation, Source Code and Tools

November 18th, 2012 27 comments

Reader “Mark” recently left a comment saying the NDA on Freescale i.MX6 resources was lifted and documentation and source code were now available for the platform. So it’s time for me to look into it, and provide an overview of Freescale i.MX6 features, list available development platforms, and have a closer look at the documentation, source code and tools for the platform.

Freescale i.MX6 Processors

In 2011, Freescale initially announced 3 processors in the i.MX6 series for consumer, industrial and automotive markets, but added 2 lite SoC in 2012, and there are now 5 members in the family:

  • Freescale i.MX6SoloLite – Single Cortex A9 processor up to 1 GHz with 256KB L2 Cache, 32-bit DDR3 and LPDDR2 memory support, and 2D graphics accelerator (Vivante GC355 + GC320)
  • Freescale i.MX6Solo – Single Cortex A9 core up to 1 GHz with 512KB L2 Cache, 32-bit DDR3 and LPDDR2 memory support, and 2D & 3D graphics accelerator (Vivante GC880 + GC320)
  • Freescale i.MX6DualLite – Dual Cortex A9 up to 1 GHz with 512KB L2 Cache, 32-bit DDR3 and LPDDR2 memory support, and 2D & 3D graphics accelerator (Vivante GC880 + GC320)
  • Freescale i.MX6Dual – Dual Cortex A9 up to 1.2 GHz with 1MB L2 Cache, 64-bit DDR3 and LPDDR2 memory support, SATA-II, and 2D & 3D graphics accelerator (Vivante GC2000 + GC355 + GC320)
  • Freescale i.MX6Quad – Quad Cortex A9 up to 1.2 GHz with 1MB L2 Cache, 64-bit DDR3 and LPDDR2 memory support, SATA-II, and 2D & 3D graphics accelerator (Vivante GC2000 + GC355 + GC320)
i.MX6 Lite Series

Freescale i.MX6 Series

Everything I’ve written above is actually nothing new as this was mentioned in the press releases and Freescale i.MX6 page for a while. What might be new is the internal structure of the processors.

Freescale i.MX6 Dual/Quad Block Diagram (Click to Enlarge)

If you want to get more overview about Freescale i.MX6 SoC features, I invite you to visit the 2 links at the beginning of this section. If you want to look into details continue reading and we’ll get to the documentation soon.

Freescale i.MX6 Development Boards

In this blog, I mainly cover low cost development boards and gadgets, and we have already several boards which are available now or soon will be:

Low Cost Quad-core Cortex A9 Board

Freescale iMX6q Sabre Lite Development Board

Another low cost alternative would be to use the upcoming Hiapad Hi-802 mini PC ($89) based on Freescale i.MX6Quad and providing easy access to debug ports. Obviously this option offers less flexibility and features than the first 2 boards.

Freescale also provides some full-featured (and somewhat expensive) development platforms for different applications:

  • i.MX 6SoloLite Evaluation Kit ($399 to $499) – Evaluation kit based on i.MX6SoloLite to develop e-Reader products. $399 is for the board only, and $499 includes an E-Ink Panel with the board.
  • SABRE Board and Platform for Smart Devices ($399 and $999) – The SABRE board (MCIMX6Q-SDB) is powered by i.MX6Quad with 1GB RAM, 8GB eMMC, 2xLVDS, HDMI and LCD video outputs,, 2x SD card sockets, Gb Ethernet, SATA connector and more. The SABRE Platform is based on the SABRE board and comes with a 10.1″ LVDS display with integrated P-cap sensing.
  • SABRE for Automotive Infotainment ($799) – There are actually 2 platforms: one using i.MX6Quad(1GHz) and the other i.MX6DualLite (800 MHz). Both plaforms come with 2GB  DDR3 RAM, 32 MB NOR flash, a NAND flash socket, LVDS & HDMI interfaces, Ethernet, SD card socket, and more. The Quad version also comes with a SATA port.


All development platforms should be be able to support Android, Linux and Windows Embedded operating systems.

Freescale i.MX6 Documentation

BIG FAT WARNING! If you’ve been working on Chinese (and/or Taiwanese) SoCs for too long, you may be in for a shock (and may end up missing reverse-engineering the datasheet from the source code) as Freescale has released lots of document publicly (I won’t be able to list them all here) and the documentation appears to very thorough. For example, Freescale i.MX6 Reference Manual is 5739 pages long!

You can find all documents on Freescale i.MX6 Documentation page, and the most interesting (to me) are:

I’ve flicked through the technical documentation and it seems really good. I’ve discovered that i.MX6Quad can boot from SPI, I2C and EIM (External Interface Module) interfaces, NAND flash, SD/MMC, SATA or USB depending on the board configuration, which looks pretty darn interesting, especially for USB and SATA boot.

I’ve also looked at Linux and Android documentation (obviously), but I’m a bit puzzled as it asks you to use Ubuntu 9.04 (Jaunty) for the build environment (LTIB), and provide links to a git repo where the kernel has not been updated for 8 months and u-boot for 4 months… But as you’ll see below we won’t need to use those as you’ll discover below. Most of the software documentation on Freescale refers to the SABRE for Smart Devices and Automotive Infotainment, so if you are using one of the low cost board may be better off checking out the vendor software documentation.

[Update: There are lots of how-tos for i.MX6 processors on imx community page]

Elements14 has documentation for the SABRE Lite Board (which it sells for $179) including a user manual describing the hardware and showing how to get started with the software (TimeLink Linux BSP), and schematics. Boundary Devices has excellent instructions on their blog, and if you have a Freescale i.MX6 device to develop on, I recommend you subscribe to their blog.

Freescale released schematics and PCB layout files for the SABRE SD and AI platforms (Cf. Printed Circuit Boards and Schematics-Schematics section on i.MX6 page). If you are more interested in SABRE Lite hardware, Boundary Devices released the following files:

Freescale i.MX6 Linux and Android BSP & Source Code

Freescale i.MX6 Source Code

Beside linking to an outdated git repository, Freescale also provides download link to Linux Kernel 3.0.35, Android 4.0.4 and Multimedia Codecs source code:

Building the Linux Kernel and U-Boot for Freescale i.MX6 SABRE Lite board

Let’s try to build u-boot and the kernel for Freescale .iMX6 uing ltib in Ubuntu 12.04 64-bit.

After downloading L3.0.35_12.09.01_ER_SOURCE, extract it, and install the LTIB package as a normal user (not as root), in a location such as /home/user/:

Install some dependencies (this may vary depending upon your current installation and OS):

Since I’m using a 64-bit build machine, I also had to install the following:

After spending some time trying to figure out problems, I realized Ubuntu 12.04 is not currently supported in LTIB and you need a patch, which you can apply as follows in ltib directory:

curl -L | bash

Finally, you may need to edit the sudoers file (sudo visudo) to allow the current user to run rpm as root without password, and add the following line:

Start to build LTIB and cross your fingers:

At this point, it will install the host support packages (it will take a while) and eventually a menu will popup.

Set the platform to “Freescale iMX reference boards” (as if you had a choice), exit and save the changes. At the next menu, select platform type as “imx6q” and package profile. Exit and save the new configuration. Please note that only the profiles of Min profile, FSL gnome release packages, and mfg firmware profile pass build tests. I chose the default “Min” profile.

You can use the ./ltib -m selectype command to change the profile after the first selection.

To build U-Boot for i.MX6 SABRE Lite board, select “Choose your board for U-Boot” as “mx6q_sabrelibre”. This option is only for U-Boot, as the current default kernel configuration builds a single image that works for all i.MX6 boards except i.MX 6SoloLite boards. Close the configuration screen and save the changes. You can now build the kernel and U-Boot by running the following command:

The build failed to build busybox. To fix it, I had to edit rootfs/usr/lib/ and change one line to:

Same thing for rootfs/usr/lib/

Then type ./ltib again. When this procedure is completed, the kernel image and the U-Boot images are located at: rootfs/boot/:

Freescale i.MX6 Android, Linux, Ubuntu… Binary Images/Files

There are also some binary demo files for Android and Linux and closed source files (e.g. codecs):

Beside the Ubuntu root file system, Arch Linux for ARM is also said to be working on Nitrogen6X board.

There are also demo images specific to SABRE Smart Devices and Automotive Infotainment platforms. For a complete list of available files, visit Freescale i.MX6 Software & Tools page.

Boundary devices posted a binary LTIB image for i.MX6 Sabre Lite and Nitrogen6X boards as well as a short getting started guide. It might be worth having a look, although this has been done in August. Linaro has instructions to run Ubuntu 11.10 (Oneric) on the board, but it dates a bit and images have disappeared.

Finally, you could also use Timesys LinuxLink Linux BSP for SABRE Lite and Nitrogen6X boards. LinuxLink is a web based system that allows you to build custom Linux distributions for your board. I gave an overview of this web-based build system in a previous post “Timesys Unveils LinuxLink BSP/SDK for MityARM-3359 SoM (TI AM335x)“.

Freescale i.MX6 Development Tools

Again, you can check Freescale i.MX6 Software & Tools page for a list of software and hardware tools, but there appears to be 3 main software tools:

  • LTIB – This is the default build system for Freescale i.MX series processors, and it widely referred to in the documentation.
  • MfgTool – Tool for downloading OS images to the i.MX6. It can be downloaded separately, but is also part of IMX6_R13.4_ANDROID_SOURCE_CODE.
  • IMX_CST_TOOL – Freescale Code Signing Tool for the High Assurance Boot library. Provides software code signing support designed for use with i.MX processors that integrate the HAB library in the internal boot ROM.

If you develop on hardware based on Freescale i.MX6, you’ll have to use the first 2 tools. To be honest, I’m not exactly sure what the third tool does, but it seems required for security purpose at boot time. You need to be approved manually by Freescale before being able to download IMX_CST_TOOL.[Update: I’ve been approved to download the tool after 12 days, and what it does is to lock your hardware to only run software signed with a specific key. This means you would not be able to hack your i.MX6 device if HAB Library/ CST are in use]. This is probably not really needed if you just want to tinker with your board, but if you’re going to make a commercial product, you may need it.

Elements14 also point to Timesys LinuxLink (mentioned above) and ARM DS 5, and even if those are interesting, they may not be necessary. It all depends on your preferences and needs.

For low level debugging and board bring-up, you may want to use hardware probes such as ARIUM HS-1000S JTAG Emulator/Debugger or iSystem iC3000 ActiveEmulator debug and test tool.

If you need support for the platform for one of the low cost boards, you could check the imx community, comment in Boundary Devices blog (if you use their images) or participate in Elements14 community.