1 2 3 Previous Next

ARM and Keil Tools

99 posts

R for Real-time

We are very excited to have partnered with Renesas Electronics to introduce support for the recently announced Renesas RZ/T1 product series in ARM DS-5 Development Studio. The new device family comprises ten ARM Powered® products aimed at industrial applications that require both high performance and real-time predictability. Based on an ARM® Cortex®-R4 processor operating at up to 600 MHz, the product line also includes configurations that feature a Cortex-M3 core to enable highly integrated asymmetrical multi-processing (AMP) applications. Visit Renesas website (English/Japanese) if you want to learn more about the RZ/T1 series.


Renesas RZ/T1 in DS-5

ARM DS-5 is a complete software development tools solution for RZ/T1 users. It includes efficient C/C++ code generation for both ARM cores and full support for synchronous and asynchronous AMP debug.


Some benefits of DS-5 for RZ/T1:

  • ARM Compiler 5: industry reference C/C++ compiler for Cortex-R4 and Cortex-M3 processors, compatible with the widest range of RTOS, middleware and third-party tools
  • Simultaneous debug connections to both ARM processors
  • Collection, decode, synchronization and visualization of trace data from ARM CoreSight™ ETM (Embedded Trace Macrocell) and ITM (Instrumentation Trace Macrocell) units for faster bug finding
  • TÜV SÜD certified compiler and compiler qualification documentation for functional safety certification
  • Built-in OS awareness for leading commercial real time operating systems (RTOS)


Target connections for your every need

Depending on the stage you are in the software development project and your budget, you may select different technologies to connect DS-5 to your RZ/T1 target. See below summary of the target connection options, for you to pick the right one for your needs.


Target connection typeBest forTrace capture
DSTREAMBoard bring-up, high-performance debug and ETM trace-based analysis

off-chip (4 GB DSTREAM)

on-chip (4 KB ETB)

ULINKproFast software debug with on chip trace  (Note: ULINKpro trace is not supported in DS-5)on-chip (4 KB ETB)
ULINKpro DFast software debug with on-chip traceon-chip (4 KB ETB)
ULINK2Basic software debugon-chip (4 KB ETB)
CMSIS-DAPSilicon evaluation on development boards (USB connection to board, no debug hardware required)on-chip (4 KB ETB)




RZ/T1 platform configuration file is available for DS-5 version 5.20 users upon request. If you require access to it now, get in touch.

Hi, It would be really useful for the team here at ARM, if you could have a few moments to complete a short survey of your experiance with Juno ARM's Development Platform for ARMv8. I can feed this back into the requirements for future plaftoms and also try to address any issues you incountered either with the software or hardware. Click here to complete survey




ARM releases updates to DS-5 on an approximate quarterly cadence, and as I write this, we have just released v5.20 of the tool. With each release we increment the debugger and compiler(s) version to the latest version available. This can cause difficulty for the compiler use case, as typically the version of a compiler used for a given project becomes fixed at some point in time, and moving from this version becomes costly from a validation and/or qualification point of view. ARM has always made the ARM Compiler package available as a separate installation for those users that do not wish to use the default version. However, until now, it has been precisely that... a separate installation, detached from the rest of your DS-5. As you've likely guessed from the title of this article, this is a situation that we have improved within DS-5 v5.20.


You will first need to download the appropriate compiler package, and install. I recommend installing to the DS-5 sw directory where the default tools are, though you can use any location. You then need to make DS-5 aware of this installation. To do this, launch the Eclipse GUI, and navigate through the Window menu to Preferences. Therein, drill down the left hand side to select DS-5, and then Toolchains:




Click Add... and navigate to the bin (or bin64) directory of the compiler you wish to add:




Click on Next and the tools will verify the location:




Click on Finish, and you will be asked to restart the GUI. The newly added compiler version will now be available to use in your projects:




For those that build from makefiles or equivalent, these changes are reflected in the DS-5 Command Prompt. Now, when you launch this, you will first see the following:



We have created an add_toolchain script that behaves in a similar manner to the above. Use the path to the bin directory and it should work just as above.


We provide two scripts (select_toolchain and select_default_toolchain) to allow the user to set the appropriate compiler version that they wish to use. As the names suggest, using select_default_toolchain is a do-once operation to set the default compiler version used each time the user launches the command prompt. If necessary, you can then override the compiler version used for a particular compilation session using select_toolchain. The use of either of these options is simple. Call the appropriate script, and you will see a list of available compiler versions. Select the version you wish to use, and the environment will instantly be set to point to that version.



Join us for a live webinar on Monday 10th November 10:00 am PST (1:00 pm EST, 6:00 pm GMT) to learn about the new features of CMSIS v4. This will be hosted by Christopher Seidl, Keil MDK Technical Marketing Manager.


The Cortex-M Microcontroller Software Interface Standard (CMSIS) is a vendor-independent standard for hardware manufacturers and tool vendors. It provides common software layers and interfaces for all microcontrollers based on ARM Cortex-M processors.


In this webinar you’ll learn about the recently released CMSIS 4, which includes several major improvements that will affect embedded developers in the near future. It adds a standardized driver interface for Middleware and user applications (CMSIS-Driver) and Software Packs for device and board information as well as the delivery of software components.


Take away from this webinar a deeper understanding of CMSIS 4 and how it can be used to speed-up the software development process. All parts of CMSIS will be covered and code examples will be used to demonstrate ease-of-use.


Register for your place »



For the last TechCon, my colleage Bob Boys has created a comprehensive application note that tells you how to create a middleware applications using CMSIS-Drivers and our middleware that comes with Keil MDK-ARM Professional. You'll learn how to start a project from scratch, adding features as you go. The application note explains how to setup, debug and run a CMSIS-compliant application using CMSIS-RTOS RTX, USB and graphic display capabilities. It uses the STMicroelectronics STM32F429IDISCOVERY kit, but works similarly with all ARM Cortex-M based microcontrollers and development boards that have CMSIS-Drivers available (for example the MDK5 - KeilMCB1800 based on NXP LPC1857).


Check out the application note on the Keil website: Application Note 268: Creating a CMSIS Middleware Application

Happy Friday!! This week is over and that is a beautiful thing. I am going to celebrate finishing my operating systems midterm by answering a rtx question today.

This week is from the Connected Community:

"Hi Experts,


There is code pieces on Full context and reduced context in the RTX code.


What this is actually intended for ?"


Full context Vs Reduced Context  techguyz



There are 2 types of task switch in RTX library for ARM7 and ARM9: reduced context switch and full context switch.

Reduced context switch does not store all registers to the stack on task switch. The advantage of this move is to make the system more efficient in that the switch is faster and requires less space on the stack. Some functions that utilize this type are os_tsk_pass, os_dly_wait, os_sem_wait, etc.

Then there is the full context switch that stores all registers to the stack. This task switch is slower and needs more space on the stack, ideal for swithces with timeouts (i.e. round robin). Some of the functions that utilize the full context are os_dly_wait and isr_evt_set.

Since the rate of the context switch can make or break a real-time operating system's ability to process efficiently, RTX takes advantage of the reduced context to save time wherever possible and full context in functions where the register contents are too critical to omit.

It's also worth noting that this is not relevant for Cortex-M processors, which use the CMSIS-RTOS compliant version of RTX. 



MCB2300 Influence of TCPnet on RTX scheduler

TestPCF8563.rar RTX_Config.c

For some time msr and mrs works on CP15 registers, so instead of using the cryptic


mrc p15,0,r0,c0,c0,5    ; hint: r0 = MPIDR


it can be as simple as


mrs r0,MPIDR

Unfortunatley, it just works for 32 bit registers. For 64 bit registers there is still just mcrr and mrrc

So here is a macro that solves this:

So here is a macro that solves this:


    m__op64 $op,$reg0,$reg1,$coproc,$opcode,$crn
        $op $coproc,$opcode,$reg0,$reg1,$crn

    m_op64 $sReg,$op,$reg0,$reg1
        IF ("$sReg" = "PAR")
            m__op64 $op,$reg0,$reg1, p15,0,c7
        ElIF ("$sReg" = "TTBR0")
            m__op64 $op,$reg0,$reg1, p15,0,c2
    ; .....
    ; ..... add more regs here
    ; .....
            INFO 42,"$sReg"
            ASSERT {FALSE}

    ; "m_msrr" works like "msr", but puts two core regs into one
    ; 64 bit reg
    m_msrr $sReg,$reg0,$reg1
        m_op64 $sReg,mcrr,$reg0,$reg1

    ; "m_mrrs" works like "mrs", but puts one 64 bit into two
    ; core regs
    m_mrrs $reg0,$reg1,$sReg
        m_op64 $sReg,mrrc,$reg0,$reg1


So now you can write things like


  m_mrrs r0,r1,PAR
  m_msrr TTBR0,r0,r1


And one day, when armasm implements msrr and mrrs all it take is removing the "m_" there.....


Join us for a live webinar on Wednesday 22nd October 1:00 pm EDT (10:00 am PDT) to learn how ARM tools can be used more widely for safety-related development, now that the ARM Compiler toolchain is fully certified by TÜV SÜD, a recognized safety industry expert. This will be hosted by Daniel Owens, ARM Compiler Product Manager, and Johannes Bauer, Keil MDK Product Manager.


The webinar will feature the TÜV certified ARM Compiler and Qualification Kit, support for coding standards and code coverage in Keil MDK. This enables anyone deploying ARM products into a variety of safety-related sectors (for e.g. automotive, industrial control, railway, aerospace and medical), to reduce risk and gain confidence that the system is functioning according to design.


The TÜV certified compiler and compiler Qualification Kit are now part of both Keil MDK-ARM Professional Edition and DS-5 Development Studio Ultimate Edition.



Register for your place »

We've been showcasing the latest and greatest tools for ARM software development over the last couple of days at TechCon 2014 in Santa Clara. It's been a busy week, with plenty of announcements from our friends at ARM Mali Graphics and mbed along with lots of questions and feedback from engineers already using our tools.


Here's my summary of what we've been demonstrating or announcing this week in the world of tools:


DS-5 Development Studio

We've been using DS-5 Development Studio Ultimate Edition coupled with DSTREAM for JTAG debug and trace of the Cortex-A53x4 and Cortex-A57x2 based Juno Development Platform. DS-5 handles connections to individual cores, clusters or the whole system, depending on what you want to target. Upcoming changes to the registers view allow you to easily see the split between AArch64 and AArch32 registers, whilst the disassembly and trace views handle ARMv8 instructions just as they had previously handled earlier instruction sets. Many of our visitors asked about the debugging experience of ARMv8, so it was great to be able to show the jump from AArch64 to AArch32 when launching 32-bit apps such as Angry Birds on our 64-bit Android OS.


DS-5 has now been around for over 4 years, so we spend a lot of time at events like this catching up with customers who have been successfully developing ARM software using our tools. It's been great to hear feedback from DS-5 users and a lot of fun showing off the features that our engineering teams have worked hard to develop since the previous TechCon. If you're a DS-5 user, I encourage you to sign up to our monthly developer newsletter, which shows you how to use each new feature to solve every day programming problems.


Streamline and OpenCL for NEON

Streamline has always been a popular tool with engineers at exhibitions across the world and TechCon has been no different. With counters to support ARMv8 profiling, as well as a slick live capture mode, Streamline is now a firm favorite for system optimization with software development studios.


One of the announcements this week was around OpenCL support between GPU and CPUs with NEON, using Streamline to demonstrate the dependencies. This is a great extension of the OpenCL mode that we released earlier this year and should help to make compute processing a whole lot easier for developers. Read more here: Heterogeneous Multiprocessing Gets a Boost with the New OpenCL for NEON Driver


Keil MDK-ARM v5

Reinhard Keil was here this week to show off new features in MDK, including the software packs concept, demonstrating how easy it is to carry out microcontroller software development when you have access to the extensive range of middleware that is included in the packs. Along with Bob Boys, Reinhard delivered a training session to explain the concept of CMSIS-Drivers in order to create a USB application faster using the CMSIS software framework. 


V Certified Compiler

Another exciting announcement this week is that we are including a certified version of ARM Compiler 5, with long term support in MDK Professional and DS-5 Ultimate Edition. This makes software development for safety critical applications easier in both tools, especially for IEC 61508 and ISO 26262. We also include the ARM Compiler Qualification Kit to assist you in making your compliance case. This struck a chord with a lot of developers who were working on automotive software projects who dropped by the booth, so we hope it will be useful to many of you.


Fast Models and Fixed Virtual Platforms

Rob Kaye was on hand to deliver a great set of demos showing the integration between ARM Fast Models and DS-5. With model trace and Streamline for models in development, he gave visitors a glimpse into the future of models and was kept busy both days by the number of engineers already using models for ARM software development.


Of course, there have been new features and announcements from all of the software tools providers in our ARM ecosystem. My colleague Andy Frame (@andyframe_ARM) took on the role of roving reporter this week to cover their exciting news. Check out his blog here: Day 1 of TechCon 2014 with Simon Segars, Atmel MCUs, Freescale Kinetis, STMicroelectronics STM32 F7, HP Moonshot, Dell s…


What did you think?

Were you at TechCon? Did you come and visit any of the ARM software tools teams? Let us know what you thought in the comments below... and see you all next year!

Freescale will be hosting their Design with Freescale event in São Paulo on October 8th, and I will be there to support the technology sessions and the Technology Lab, demonstrating ARM's software tool solutions that support all of Freescale's ARM based Portfolio.


As you likely know if you are reading this, ARM is ubiquitous in the industry from sensors to servers. Freescale similarly offer ARM based products, from Kinetis MCUs, through the Vybrid and i.MX series of Application processors, to advanced Layerscape Networking solutions.


ARM tools support these devices with Keil MDK toolchain and DS-5 Development Studio as appropriate. Furthermore there are a variety of Freescale platforms supporting the mbed Development Platform.


Also at the event, my colleague Drew Barbier will talk about the ARM Accredited Engineer (AAE) program. This is a run-through of the subject matter covered by the ARM Accredited MCU Engineer accreditation, focusing on software aspects of the ARMv-6M and ARMv7-M Microcontroller architectures as implemented in the Cortex-M processor family. Drew will offer a look into the subject matter needed for the exam, in order to benefit from the industry-recognized qualification.


I look forward to meeting you there!

Visit us at the ARM Techcon in USA or at the Conference for ARM-Systems in Germany to learn about the new innovations for Cortex-M microcontrollers and the related CMSIS software standard.


Santa Clara, USA, October 1 - 3, 2014

The ARM TechCon 2014 in Santa Clara is a great event to get the latest information about the Cortex-M processors and the numerous microcontroller families that are based on that processor technology.


Visit the ARM booth for an in-dept demonstration of the Keil MDK Microcontroller Development Kit Version 5 that incorporates the Run-Time Environment (RTE). With RTE you compose sophisticated software frameworks for your embedded application from pre-built CMSIS and middleware software components.


Don't miss on October 2, the session Create an USB Application Using CMSIS-Drivers. In this TechCon conference session you will learn the benefits of CMSIS-Driver for creating microcontroller applications. During a 50 minute training session, Bob Boys and Reinhard Keil explain the concept of the CMSIS-Drivers. An example USB application shows how CMSIS-Drivers help to create embedded applications for supported Cortex-M microcontrollers faster by using the industry standard CMSIS software framework. The first 30 attendees registered to that TechCon workshop will get a complementary evaluation board and a full 60-day license for MDK-Professional which allows you to replicate the projects.


Munich, Germany, October 8 - 9, 2014

The Konferenz für ARM-Systementwicklung" in Munich is just one week after the ARM TechCon. This event is a great opportunity to get the latest update from ARM specialists and other ARM partners. Dr. Krisztian Flautner, Vice President Research & Development ARM, presents on 9. October 2014 his keynote on the topic Internet of Things and explains how this applies to industrial and automotive applications.


Other ARM speakers at this event cover the following topics:

  • Cortex-M – The best fitting architecture for my application: Dr. Ian Johnson
  • CMSIS – faster Software Development using software components such as DSP Library: Christopher Seidl
  • Benchmarking of Microcontrollers: Joseph Yiu
  • ARM big.LITTLE Technology: Why? What? How?: Kinjal Dave
  • Real-time hypervisors for safer control systems: Chris Turner
  • Building High End, Low Power Wearable SoCs using Application Processors: Kinjal Dave

Last month I covered the details of using ARM Compiler 6 to compile bare metal software included in Carbon Performance Analysis Kits (CPAKs) for ARMv8 processors such as the Cortex-A53. This time I will outline the flow used to connect ARM DS-5 version 5.19 to debug software. DS-5 is a full set of tools for end-to-end software development for ARM processors and includes the ability to connect to cycle accurate models running in SoC Designer and debug software.


Overview of DS-5 to SoC Designer Connection


Setting up SoC Designer for use with DS-5 involves the following steps:

  1. Use a DS-5 supplied program called cdbimporter to create a DS-5 configuration database.
  2. Add the configuration database to the list of systems to which DS-5 can connect.
  3. Create a DS-5 Debug Configuration which specifies the system to connect to and the software to debug.
  4. Connect to a SoC Designer simulation using the Debug Configuration to perform software debugging tasks.


This article presents a summary of the flow. The last two steps are common to debugging with eclipse, but the first two steps may be new to eclipse users. There is an application note in the SoC Designer release which provides additional information about cdbimporter. SoC Designer users can look at the file $MAXSIM_HOME/doc/DS5_App_Note.pdf


Generating a DS-5 Configuration Database


The database is created with a DS-5 utility called cdbimporter, which provides a number of useful features to help automate the process such as:

  • Query the host machine for running CADI servers
  • Identify the simulation of interest
  • Identify the cores included in the simulation
  • Generate the configuration database


I will use a Cortex-A53 Baremetal CPAK with SoC Designer 7.14.6 for reference.


a53x1 resized 600

To set up the DS-5 configuration database start the simulation as specified in the CPAK README file and load the software. Do not start running the simulation.


Run the simulation:


$ sdsim -b A53-cpak.conf -b $MAXSIM_PROTOCOLS/etc/Protocols.conf Systems/A53v8-MP1-CCI400.mxp


Then load the sorts_v8.axf file from the Applications/ directory and go to the shell prompt to run cdbimporter.


Setup the DS-5 shell environment using the path to your DS-5 installation:


$ /o/tools/linux/ARM/DS5_5.19/64bit/bin/suite_exec_ac6 bash


Now cdbimporter should be in the PATH and ready to run.


The output from cdbimporter is a directory containing the DS-5 configuration database which will be used in the next step.

Add the Configuration Database to DS-5


The next step is to make DS-5 aware of the new configuration database. Start by launching eclipse and set the workspace directory.


Import the database generated by cdbimporter as follows:
Open the Preferences page from the menu: Windows -> Preferences.
From the Preferences popup, select DS-5-> Configuration Database -> Add. The Add configuration database location dialog opens:


Capture1 resized 600


Use the Browse button to navigate to the directory which contains the configuration database created in the first step.


Use the Name field to name this database for later identification in the Preferences (it can also be left blank).
Click OK to close the Add configuration database location dialog.
Click OK again to close the Preference window. You will see a dialog box indicating it is adding the new database.


The configuration database is now included in the DS-5 list of target systems.


Create a DS-5 Debug Configuration


The next step is to create a DS-5 Debug Configuration that creates the connection to the system to be debugged.


Start the DS-5 debug perspective as follows:


From the top menu, select Windows -> open perspective -> DS5 Debug.


From the top menu, select Run > Debug Configurations… (or right-click from the upper left “Debug Control” view and select debug configurations -> DS-5 Debugger).


From the “Debug Configurations” pop up, right-click on DS5-Debugger and select New.


On the Connection tab, close default groups, then scroll down and select the imported system; e.g., Carbon > A53-MP1-CCI400.mxp > Bare Metal Debug > Debug Cortex-A53_0


Capture2 resized 600

On the Files tab select the .axf file of the application, in this case sorts_v8.axf.


Load symbols from file assumes you already loaded the application to debug from SoC Designer. To load the application from DS-5 instead, enter the name in the Application on host to download box and the application will be written to memory when the debugger connects.


Capture3 resized 600


On the Debugger tab, in the Run Control panel, select "Connect only."


Capture4 resized 600

Connect DS-5 to a SoC Designer Simulation and Debug Software


The final step is to launch the Debugger Configuration and connect to the SoC Designer simulation. You can do this immediately using the Debug button on the lower right of the Debug Configurations dialog.


You can also use the Debug Control tab by right-clicking on the connection and selecting “Connect to Target” from the context menu (shown below).


Capture5 resized 600


After the debugger is connected the status is shown as “connected”:


Capture6 resized 600

After connection, DS-5 can be used to debug the software running on the SoC Designer simulation.

Simulation on Another Machine or Port


If multiple simulations are starting and stopping there is a chance the port number the simulator is using is different than it was when the configuration database was created. The first simulation is normally port 7000, then the next is 7001. The numbers will recycle as simulations start and stop. It’s not necessary to start from scratch and create a new configuration database. There is an environment variable that is the easiest way to adjust to a new port number:


For bash I use:


$ export CADI_TARGET_MACHINE=localhost:7001


This environment variable can also be used to connect to a simulator on another machine by using the name or IP address of the machine which has the running simulation.



This summary covered the steps to connect DS-5 to SoC Designer. DS-5 is the best debugger to handle bare metal software for the AARCH64 state compiled with ARM Compiler 6 and DWARF4 debug information. Make sure to review the application note provided with each SoC Designer release for the latest information.


Jason Andrews

The concept of "exceptions" to most experienced programmers in languages ​​like Java, in my case, is a sign of failure or error during code execution.


However, in assembly language programming for the ARM, this concept indicates an internal requisition, be a reset, a System Tick or a call from the supervisor, but there are also architectures that throw exceptions in case of problems such as division by zero.


In ARM, external signals that interfere in the implementation process are called interruptions, but all are exceptions, most commonly used for internal signals.

Such signals are called events.


The blocks of codes dealing more events are called Exceptions Handlers when dealing with exceptions (internal) or Interruptions Handlers when dealing with interrupts (external).


Now expanding a bit with my studies, I realized that there is a possibility that the exception "Hard Fault" occurs, so get more knowledge about the moments that it can occur update this post.

A couple of months ago I posted this blog discussing how to get started with the Fixed Virtual Platform supplied with DS-5 Ultimate Edition. I'm writing this blog as a follow up, as ARM has just released their first ARMv8 Development Platform, Juno. Furthermore, in DS-5 version 5.19 (and later) there is a ready made debug configuration for the Juno Platform. You can download the latest version of DS-5 here. For more on Juno, see other blogs from my colleagues here and here. Linux and Android ports to this board are available via Linaro.I used the 14.06 Linaro LAMP file system in the examples below, which was the latest available at the time of writing.


One of the best things about using DS-5 is that the look and feel is very consistent, regardless of the type of target you are using. The only notable difference between using DS-5 with the Juno (or any other) platform vs the Fast Model, is in the Debug Configuration Pane.

Let's start with configuring a JTAG based debug connection using DSTREAM. Connect the DSTREAM hardware to the JTAG port at the rear of the Juno platform. Note that if TPIU ("off-chip") trace is needed, you will need to remove the top of the casing to access the trace connectors.


Launch the Eclipse GUI, and select Run Debug Configurations to launch the pane. On the left hand side, select DS-5 Debugger, and click on the New Configuration Button. Give the configuration a meaningful name. You will see a long list of known targets, in what we call the configuration database. Typing "Juno" in the filter window will jump straight to the required configuration database entry, which you can expand like this:



You will notice a wide variety of options here. You will see options to connect to the individual CPUs present in the platform. You also have options to connect to the distinct Cortex-A53 and Cortex-A57 CPU clusters (in an SMP configuration). Finally you have an option to connect to all six application processors in a big.LITTLE configuration. You will need to understand how the platform boots to know which is available and when. Assuming you are using the platform exactly as supplied by ARM, the initial bootloader and UEFI run on Cortex-A53_0 (as labelled above). The Cortex-A57 cluster is held in reset, during this process, and so any attempt to connect to any of the Cortex-A57 processors, including the big.LITTLE configuration, will result in a debugger error. You should select either the Cortex-A53_0 or the Cortex-A53x4 SMP connections. If you are connecting to a fully booted system, you should be able to select any of the options. Note if running Linux, and debug symbols of your kernel are available, you may wish to use the connections listed under "Linux Kernel and/or Device Driver Debug" for enhanced debugger features.


Click the DTSL Options "Edit" button to show the range of different trace configurations available to you. You can enable trace for any or all CPUs that you wish to connect to.




Click the Browse button to locate your DSTREAM unit. Finally, use the File and Debugger tabs to configure your debug session as necessary. Click Apply to save your setup and then OK, to commence the debug session.


Example 1: Debugging the Cortex-M3



Example 2: Debugging the Cortex-A53 cluster (UEFI running on target)



Example 3: Debugging the entire big.LITTLE cluster (Linux running on target)



For Linux Application Debug, the steps are identical to those in my previous blog. I did however spot a problem with the Linux Application Debug option within the Juno configuration database entry, which refers to a AArch32 gdbserver (code on Juno is highly likely to be running in AArch64).




If you attempt to use this configuration (with AArch64 code) you get an unrecoverable error of the form:



! Failed to read state of device gdbserver

! The address "<address>" is invalid


The solution to this is to use the Linux Application Debug Application Debug Connections via AArch64 gdbserver configuration:


DS-5 Ultimate Edition has full Streamline support for Cortex-A53 and Cortex-A57, Mali-T624, and other system hardware present on Juno. Initial support is provided within the Linaro images, and I expect this to be extended over time.




Both DS-5 Ultimate Edition v5.19 and the Juno ARM Development Platform are available to order now. Please contact your ARM Representative for more information.

Having started at ARM about a week ago, I have been very excited to work on Juno, ARM's first 64-bit Development Platform.

Juno is aimed at accelerating the development of 64-bit software for the mobile and enterprise markets. Based on the ARMv8-A big.LITTLE™ architecture, Juno offers software developers an open, vendor neutral, reference platform for 64-bit software development. Interestingly, Linaro has also released an Android Open Source Project (AOSP) port for the 64-bit ARMv8-A architecture. The entire software stack for the platform is now available through Linaro. The software bundle includes ARM Trusted Firmware, Linux file systems and a Linux kernel (3.10) that can support both OpenEmbedded Linux and Android (AOSP) file systems.

Juno is aligned with the ARM® Server Base Architecture (SBSA), which means that developers can use the system for early access of porting and performance-tuning OS kernel or driver code to the 64-bit architecture, based on the ARM® Cortex®-A57 and ARM Cortex-A53 processors. This means Juno creates a common foundation for the software developers in the ARMv8 ecosystem and allows early access to the silicon. For the hardware vendors, Juno provides the entire ARMv8 IP portfolio working together in a big.LITTLE™ implementation, delivering high performance and low power consumption.


The timing of the platform release is important, as Google recently announced the details of the their "Android L", which would include a new Virtual Machine "ART" to support both 32 and 64-bit ARM architectures. The platform definitely aims to accelerate the time to market for future 64-bit ARM designs.

Hardware Overview


Juno Design.jpg


The Juno SoC was built by ARM with an aim to keep the implementation functionally correct so that it can be representative of a potential mobile platform. Therefore, like many development platforms, Juno isn't meant to deliver highest standards of performance or efficiency. It is meant

to enable software developers to port their applications to 64-bit ARMv8-A. Juno includes ARM's own Mali™-T624 graphics processor, the mobile-focused CCI-400, dual DDR3 memory controllers, and an ARM® Cortex® M3 System Control Processor that handles SoC-level power management and system control. Juno also offers SoC hardware expansion for customers wishing to implement their own custom RTL designs. This is enabled through the LogicTile design and Thin Links technology, which can be used to prototype custom CPU, GPU and peripheral designs. Lets have a quick look at Juno hardware specs:



ARM® Cortex®-A57 MP2 cluster

    Speed: 1.1GHz (Overdrive)

    Caches: L1 48KB I, 32KB D, L2 2MB


ARM® Cortex®-A53 MP4 cluster

    Speed: 850MHz (Overdrive)

    Caches: L1 32KB, L2 1MB

GPUsARM® Mali™-T624 MALI T624

   Speed: 600MHz

   Caches: L2 128KB


  8GB 1600MHz DDR,

  64MB user NOR FLASH,


SoCARM® CoreSight ETM/CTI per core,

VFS and power gating,

4 energy meters,

DMC-400 dual channel DDR3L interface,

Internal CCI-400, 128-bit, 533MHz

Rest of SoC

Internal NIC-400, 64-bit, 400MHz

DMAC : PL330, 128-bit

Static Memory Bus Interface : PL354

HDCLD dual video controllers: 1080p

Expansion support

AXI expansion to FPGA daughterboard

USB 2.0 with 4 port hub

Debug & Trace

ARM® JTAG : 20-way DIL box header

ARM® 32/16 bit parallel trace


Software Overview

ARM has been working closely with Linaro to provide a stable software stack that includes low-level firmware for runtime services and high-level file systems such as OpenEmbedded Linux and Android (AOSP).

Linaro ARMv8 ports are based on Linux kernel 3.10 (Linaro Stable Kernel), and compiled with GCC 4.9 and can run both Juno and ARMv8 fast models. The entire software stack for Juno is available through the Linaro website.


linaro website.png


Let's drill-down into the different software components:



MCC Microcontroller Firmware

The MCC firmware takes care of early setup before the SCP or application processors are powered on. The MCC is also responsible for managing firmware upgrades.

Systems Control Processor (SCP) Firmware

The SCP firmware loads the runtime that provides low level power management and system control for the Juno platform.
ARM Trusted FirmwareThe ARM Trusted Firmware provides an open source framework enabling easy integration of secure OS and run-time services to ARMv8-A platforms. The project has been hosted as an open-source project on GitHub
Unified Extensible Firmware Interface (UEFI)The Juno UEFI implementation provides Linux loader support for the Juno platform. It is based on the open source EFI Development Kit 2 (EDK2) implementation from the Tianocore sourceforge project.
A 64-bit Linux Kernel with big.LITTLE™ and Mali supportThe Linux Kernel can support both Android and OpenEmbedded file systems. It is being managed by Linaro and can be downloaded from the Linaro website as a part of the entire software stack.
Linux-based file systemsThis includes Android Open Source Project (AOSP) and OpenEmbedded Linux. Linaro has been responsible for porting AOSP to 64-bit ARM and will be maintaining this project. It can be downloaded from the Linaro website along with other software deliverables.

Clearly, Juno offers software developers and system architects a robust product stack including cutting-edge hardware and software, which would serve as a firm baseline for testing future 64-bit ARM-based designs. It has received a lot of attention in the press. A simple Google News search on "Juno ARM 64-bit" would yield a number of blogs and news articles on the Juno platform, including details about the software stack provided by Linaro. Some of the top links are listed below.


ARM Unveils Juno Platform for 64-Bit Development

ARM arms devs for 64-bit push with 'Juno' board • The Register

ARM releases Juno dev platform for 64-bit computing - Software - News - HEXUS.net




For support and queries around the Juno platform, contact:  juno-support@arm.com

Getting Started

In order to get started with the Juno board, a detailed getting-started guide can be found here.


If you want to learn how you could get Android installed on Juno, watch the following TUTORIAL: Installing Android on Juno ARM Development Platform


Additional Links

Juno ARM Development Platform Technical Reference manual

Juno ARM Development Platform datasheet

Juno ARM Development Platform Technical Overview

Filter Blog

By date:
By tag: