cExplr / ARMDebianUbuntu.md
You might want to read this to get an introduction to armel vs armhf.
If the below is too much, you can try Ubuntu-ARMv7-Qemu but note it contains non-free blobs.
Running ARM programs under linux (without starting QEMU VM!)
First, cross-compile user programs with GCC-ARM toolchain. Then install qemu-arm-static so that you can run ARM executables directly on linux
If there’s no qemu-arm-static in the package list, install qemu-user-static instead
# armel packages also exist sudo apt-get install gcc-arm-linux-gnueabihf libc6-dev-armhf-cross qemu-arm-static Then compile your programs in amd64 directly:
cat > hello.c int main(void) < return printf("Hello ARM!\n"); >EOF arm-linux-gnueabihf-gcc -static -ohello hello.c file hello hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), statically linked, ./hello Hello ARM! If you want a dynamically-linked executable, you’ve to pass the linker path too:
arm-linux-gnueabihf-gcc -ohello hello.c qemu-arm -L /usr/arm-linux-gnueabihf/ ./hello # or qemu-arm-static if you install qemu-user-static If you want to run an ARM64 binary:
sudo apt-get install libc6-dev-arm64-cross gcc-aarch64-linux-gnu qemu-aarch64 -L /usr/aarch64-linux-gnu/ [path-to-binary] # or qemu-aarch64-static if you install qemu-user-static For running the C++ program:
sudo apt-get install g++-arm-linux-gnueabihf libstdc++-4.8-dev-armhf-cross sudo apt-get install g++-aarch64-linux-gnu libstdc++-4.8-dev-arm64-cross Notice that the version number of the libcstdc++ might change
Create a hard disk for your virtual machine with required capacity.
qemu-img create -f raw armdisk.img 8G You can then install Debian using an ISO CD or directly from vmlinuz
First, you should decide what CPU and machine type you want to emulate.
You can get a list of all supported CPUs (to be passed with -cpu option, see later below):
You can get a list of all supported machines (to be passed with -M option, see later below):
qemu-system-arm -machine help In this example, I chose the cortex-a9 CPU and vexpress-a9 machine. This is an ARMv7 CPU which Debian calls as armhf (ARM hard float). You must download vmlinuz and initrd files for, say Wheezy armhf netboot. Cortex-A8, A9, A15 are all ARMv7 CPUs.
You can emulate ARMv6 which Debian calls as armel by downloading the corresponding files for Wheezy armel netboot. Note that you need armel for ARMv5, v6. Raspberry Pi uses ARMv6. In this case, the cpu is arm1176 and machine is versatilepb .
Create a virtual machine with 1024 MB RAM and a Cortex-A9 CPU. Note that we must -sd instead of -sda because vexpress kernel doesn’t support PCI SCSI hard disks. You’ll install Debian on on MMC/SD card, that’s all it means.
qemu-system-arm -m 1024M -sd armdisk.img \ -M vexpress-a9 -cpu cortex-a9 \ -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.gz \ -append "root=/dev/ram" -no-reboot Specifying -cpu is optional. It defaults to -cpu=any . However, -M is mandatory.
This will start a new QEMU window and the Debian installer will kick-in. Just proceed with the installation (takes maybe 3 hours or so). Make sure you install «ssh-server» in tasksel screen.
NOTE: For creating ARMv6, just pass versatilepb :
qemu-system-arm -m 1024M -M versatilepb \ -kernel vmlinuz-3.2.0-4-versatile -initrd initrd.gz \ -append "root=/dev/ram" -hda armdisk.img -no-reboot Download netboot ISO for armhf or armel as needed.
WAIT! Apparently, these Debian CD images are not bootable! But Ubuntu’s ARM CD image works [2].
First boot from newly installed system
You need to copy vmlinuz from the installed disk image and pass it again to qemu-system-img [Qemu wiki] (http://en.wikibooks.org/wiki/QEMU/Images#Mounting_an_image_on_the_host»).
sudo modprobe nbd max_part=16 sudo qemu-nbd -c /dev/nbd0 armel.img mkdir ~/qemu-mounted sudo mount /dev/nbd0p1 ~/qemu-mounted mkdir after-copy cp ~/qemu-mounted/boot/* after-copy/ sudo umount ~/qemu-mounted sudo qemu-nbd -d /dev/nbd0 sudo killall qemu-nbd Then pass the copied kernel and initrd to qemu-system-img. Also note that we are now booting from /dev/sda1 because that is where Linux was installed
qemu-system-arm -M versatilepb -m 1024M \ -kernel after-copy/vmlinuz-3.2.0-4-versatile \ -initrd after-copy/initrd.img-3.2.0-4-versatile \ -hda armel.img -append "root=/dev/sda1" And there you go, play with ARM to your heart’s extent!
Extract & copy the boot files exactly as before (but for armhf.img) and pass while invoking:
qemu-system-arm -m 1024M -M vexpress-a9 \ -kernel armhf-extracted/vmlinuz-3.2.0-4-vexpress \ -initrd armhf-extracted/initrd.img-3.2.0-4-vexpress \ -append "root=/dev/mmcblk0p1" -sd armhf.img Once again, note the device ( mmcblk0p1 ) and partition ( armhf.img ) reflect SD-card usage.
Connecting to the SSH server
Login to the guest OS and create a private/public key pair: ssh-keygen -t rsa .
On the host, just redirect some random port from the host to guest’s port 22 (or whichever port the SSH server is running on, see /etc/ssh/sshd_config)
qemu-system-arm . -redir tcp:5555::22 & Then you can connect to SSH just like ssh -p 5555 localhost .
Chroot Voodoo your ARM VM (architectural chroot with QEMU)
After the install of your ARM, you will probably see that it is really slow. To speed up your arm, you can chroot it natively and let qemu-user-static interpret the ARM instruction. [5]
sudo apt-get install qemu-user-static kpartx We mount the image using loopback
sudo kpartx -a -v armdisk.img sudo mkdir /mnt/arm-vm sudo mount /dev/mapper/loop0p2 /mnt/arm-vm sudo cp /usr/bin/qemu-arm-static /mnt/arm-vm/usr/bin sudo mount -o bind /proc /mnt/arm-vm/proc sudo mount -o bind /dev /mnt/temp/dev sudo mount -o bind /sys /mnt/temp/sys We register qemu-arm-static as ARM interpreter to the kernel linux. [6]
#This can only be run as root (sudo don't work) sudo su echo ':arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-arm-static:' > /proc/sys/fs/binfmt_misc/register exit $ uname -a Linux cis-linux-arm 2.6.32 #19-Ubuntu SMP Wed Oct 9 16:20:46 UTC 2013 armv7l GNU/Linux N.B: After test, qemu 1.1 (Debian wheezy) had some strange behaviour but the 1.5 (Ubuntu saucy) was working perfectly !
When you finished your work you should unmount everything to avert bad behaviour. Do not forget to not start your VM with Qemu before unmount everything !
sudo umount /mnt/arm-vm/proc sudo umount /mnt/arm-vm/dev sudo umount /mnt/arm-vm/sys sudo umount /mnt/arm-vm sudo kpartx -d -v armdisk.img How to start ARM programming in linux?
I was using PIC micro controller for my projects. Now I would like to move to ARM based Controllers. I would like to start ARM using Linux (using C). But I have no idea how to start using Linux. Which compiler is best, what all things I need to study like a lot of confusions. Can you guys help me on that? My projects usually includes UART, IIC, LCD and such things. I am not using any RTOS. Can you guys help me? Sorry for my bad English
5 Answers 5
Once you put a heavyweight OS like Linux on a device, the level of abstraction from the hardware it provides makes it largely irrelevant what the chip is. If you want to learn something about ARM specifically, using Linux is a way of avoiding exactly that!
Morover the jump from PIC to ARM + Linux is huge. Linux does not get out of bed for less that 4Mb or RAM and considerably more non-volatile storage — and that is a bare minimum. ARM chips cover a broad spectrum, with low-end parts not even capable of supporting Linux. To make Linux worthwhile you need an ARM part with MMU support, which excludes a large range of ARM7 and Cortex-M parts.
There are plenty of smaller operating systems for ARM that will allow you to perform efficient (and hard real-time) scheduling and IPC with a very small footprint. They range form simple scheduling kernels such as FreeRTOS to more complete operating systems with standard device support and networking such as eCOS. Even if you use a simple scheduler, there are plenty of libraries available to support networking, filesystems, USB etc.
The answer to your question about compiler is almost certainly GCC — thet is the compiler Linux is built with. You will need a cross-compiler to build the kernel itself, but if you do have an ARM platform with sufficient resource, once you have Linux running on it, your target can host a compiler natively.
If you truly want to use Linux on ARM against all my advice, then the lowest cost, least effort approach to doing so is perhaps to use a Raspberry Pi. It is an ARM11 based board that runs Linux out of the box, is increasingly widely supported, and can be overclocked to 900MHz