Aros/Platforms/ARM support

Introduction
There have been a few attempts at porting AROS (Amiga OS like) to the ARM architecture. At the moment, AROS runs on top of Linux (as well as Android) as another task/application.


 * 2006 year tech (ARMv5) : VIA 8500/8505, VIA 8650, RK2808/2818, Telechip 7801 (no support)
 * 2008 year tech (ARMv6) : Imap X2xx, Telechip 8902, Nvidia Tegra, Raspberry Pi,
 * 2010 year tech (one ARMv7) : Freescale iMX5, Marvell, Qualcomm, Samsung Hummingbird, TI OMAP 3xxx, Allwinner A10,
 * 2011 year tech (two ARMv7) : Nvidia Tegra 2, Qualcomm, Samsung Origen, ST-Ericsson, TI OMAP 4xxx,
 * 2012 year tech (3/4 ARMv7) : Nvidia Tegra 3, Qualcomm, Freescale iMX6, Samsung Exynos,
 * 2013 year tech : Qualcomm, Samsung, Tegra 4,
 * 2014 year tech (64bit) : AMD ,

Although ARMv6 chips have been around since late 2007, it is only since 2008 that Linux like Ubuntu, Debian, Angstrom] and close cousin Android with JIT Dalvik VM bytecode or Java bytecode been placed on netbooks, smartbooks, phones and tablets to provide a choice to the closed commercial OS like WinCE,  Windows Mobile and BlackberryOS and in the past  SymbianOS (which is now open) and even the old Archimedes RISCOS.

Support Chips

An SOC is an integrated chip that includes a CPU, a GPU (graphics) and various task specific processors. The level of support is entirely based on the amount of information that is available. Support needs to include the core cpu itself (2D and 3D as well) and other extra motherboard chips like hdmi, lcd, touchscreen, dsp, sata, etc. which requires knowledge (datasheets) from the suppliers of those chips (audio and USB is the best that can be supported without it). To get some idea of the amount of information needed see the Rockbox site for slightly simpler examples.

ARMHF target needs either armv7a cpu, if you are going to use both 32-bit arm code and thumb2, or armv6 cpu (that one was default, after you deleted this line) with 32-bit ARM code only (then gcc cross compiler needs—disable-multilib option).

GPUs


 * nVidia's Custom GPU found in the Tegra 2 SOC - 71 million. This GPU's native support for Unreal Engine 3, OpenGL 2.0, and a dedicated processor for 1080p/HDMI output support.
 * PowerVR SGX535 GPU - 28 million (triangles per second). This is the GPU found in the iPhone 4, iPad and most of Intel's Integrated Graphics Cards found in laptops (GMA 500/600). The iPhone 3GS also uses this GPU but clocked at a mere 200mhz. At that speed, it only pushes 7 million.
 * PowerVR SGX540 GPU - 90 million. This is the GPU found in the upcoming OMAP4 SOC, Snapdragon Gen II/III SOC and the Hummingbird SOC. The GPU in the Hummingbird SOC maxes out at 28 million due to it being clocked at 200 mHz and due to limitations related to the memory bandwidth.
 * PowerVR SGX554MP GPU - Unknown performance. It's a multicore gpu and thus the performance would scale based on the number of cores used.
 * GC800 single core Vivante GPU used by Marvell
 * GC1000
 * GC2000/GC4000 Marvell's Vivante GPU found in the Tri-Core Armada 628 SOC - Marvell claims that this GPU pushes a whopping 200 million triangles per second. As always, the actual devices will likely limit the clockspeed in order to conserve battery life so the real world performance will be less.
 * ARM Mali 200 GPU pushes 16 million triangles per second.
 * ARM Mali 400 GPU - This is the GPU found in the ST Ericsson U8500 SOC and the Samsung Orion SOC. This is a MP GPU that can scale anywhere from 1-4 cores. The rumours regarding the theoretical performance of the four core design range anywhere from 130 million to a whopping 450 million triangles per second. However, the key limitation as always is the clockspeed. A four core design could deliver very impressive performance even at a low clockspeed.
 * Mali T604
 * Mali-T658 "The Mali-T658 delivers desktop-class performance, achieved by doubling the number of GPU cores, doubling the number of arithmetic pipelines within each core and improving the compiler and pipeline efficiency.

The ARM Mali-T658 GPU supports multiple Compute APIs, including Khronos® OpenCL 1.1 (Full Profile), Google Renderscript compute and Microsoft DirectCompute. It provides native hardware support for 64-bit scalar and vector, integer and floating-point data types - fundamental to accelerate complex and computationally intensive algorithms. Complete support for Khronos APIs is maintained across the Mali-T600 Series of GPUs.

The Job Manager within Mali-T600 Series GPUs offloads task management from the CPU to the GPU and enables seamless load balancing across active shader cores. Concurrent delivery of a common set of compatible drivers for all Midgard architecture-based Mali GPUs enables faster time-to-market and minimizes software upgrade costs for future implementations.

The Mali-T658 GPU takes advantage of ARM CoreLink Cache Coherent Interconnect (CCI-400) technology, enabling faster and more efficient sharing of data with other processors in the system.

Supported

 * ARMv6 - ARM1136J(F)-S 8-stage pipeline, VFPv3+SIMD, Thumb, Jazelle DBX, Enhanced DSP instructions, variable, MMU
 * ARMv7 - Cortex A8 single, 13-stage superscalar pipeline, VFPv3+NEON, Thumb-2, Jazelle RCT, variable (L1+L2), MMU+TrustZone

AROS ARM Linux hosted Phase 1 was completed November 2010 for Efika MX products and others.

Watch a video here and a blog of the work done can be found here and here.


 * See more about Android support here

The following specific chipsets and drivers are also available. Please let us know any mistakes or any information to be added, to this General Chat list AROS-Exec or here AROS World

Developing
Commercial


 * Keil
 * IAR
 * Raisonance
 * Rowley Crossworks
 * Code Red
 * Norcroft C

IAR have a free code size limited version. Keil are owned by ARM, so should provide good tools. Code Red have excellent debug facilities (none intrusive trace, etc.) and the lowest price. Rowley and Code Red use CodeSourcery. Raisonance uses the arm-non-eabi CodeSourcery compiler too.


 * IDA PRO 4.x Freeware

Free


 * GNU Arm
 * Code Sourcery
 * GCC Arm
 * ARMuC
 * Arm Development
 * GNU Arm
 * Tiny CC

https://support.bluetechnix.at/wiki/Hardware_documentation_(SBC-i.MX51)

What the ideal developer board should have?


 * 2 serial ports (one can be null modem, second should have RTS/CTS/DTR lines)
 * working Ethernet not placed on USB bus (so it works when USB does not)
 * powered USB host port (more than one would be great)
 * USB device port
 * JTAG connector
 * one power input — +5V or +12V
 * SD/MMC slot — even if it is over slow SPI
 * GPIO pins
 * I²C bus
 * SPI bus
 * keypad with Up/Down/Left/Right + Enter at least
 * easily reachable reset button (pins to short are acceptable as micro switch can be put on them)
 * few LEDs controlled by system
 * all connectors put on one or two edges of board — top one + one of side ones are ok
 * mounting holes (so board can be mounted for presentation)
 * backup battery for RTC
 * U-Boot or similar
 * quite fresh kernel

What to avoid:


 * female serial port connectors
 * flat cables which connect “debug boards” with main board
 * RJ45 connectors for serial console — DB9 or properly done USB->RS232 adapter on-board are best
 * placing connectors on all edges (BeagleBoard)
 * non standard bootloaders (U-Boot is what I prefer)
 * Ethernet on USB
 * jumpers
 * non standard connectors

I am trying to not cover should developer board contain display with touchscreen or not as it depends on type of board. But if screen is present then more than QVGA (320×240) would be nice (WVGA 1200x768 anyone?). Some kind of video out connector can also be used but would be nice to have one of VGA/DVI/HDMI so normal PC monitor can be used — Composite video and S-Video require searching for some kind of TV.