Linux CAN bus on the Cyclone5

How to configure and build Linux to use the built-in CAN on the Cyclone5 Development Kit

Overview

The Altera Cyclone5 SoCFPGA has a CAN bus peripheral that is useful for automotive and industrial applications.

This page discusses the configuration of the CAN bus in the Linux Kernel. The kernel version discussed here is the 4.1.33ltsi found at https://github.com/altera-opensource

Resources

Additional information on the CAN protocol can be found at http://www.bosch-semiconductors.de/en/automotive_electronics/ip_modules/can_ip_modules/in_vehicle_communication.html

Get the Altera Linux repo

Grab the entire Altera Linux git repository from GitHub

$ git clone https://github.com/altera-opensource/linux-socfpga.git

Checkout the most recent 4.1.33ltsi branch

$ git checkout -b linux-socfpga-can-4.1.33ltsi   origin/socfpga-4.1.33-ltsi
$ cd linux-socfpga-can-4.1.33ltsi

Now that the Linux source files are in the linux-socfpga-can-4.1.33ltsi directory, we can poke around.

Check the Device Tree to ensure CAN is enabled

Open the following files.

• arch/arm/boot/dts/socfpga.dtsi
• arch/arm/boot/dts/socfpga_cyclone5_socdk.dts

The CAN peripherals are defined in socfpga.dtsi as

   can0: can@ffc00000 {
      compatible = "bosch,d_can";
      reg = <0xffc00000 0x1000>;
      interrupts = <0 131 4>, <0 132 4>, <0 133 4>, <0 134 4>;
      clocks = <&can0_clk>;
      status = "disabled";
   };

   can1: can@ffc01000 {
      compatible = "bosch,d_can";
      reg = <0xffc01000 0x1000>;
      interrupts = <0 135 4>, <0 136 4>, <0 137 4>, <0 138 4>;
      clocks = <&can1_clk>;
      status = "disabled";
   };

Note how they are disabled here. However, the "outer" device tree in socfpga_cyclone5_socdk.dts "enables" CAN0

   &can0 {
   status = "okay";
   };

So no changes are required.

Enabling CAN in the Linux Kernel & Building the Linux Kernel

Before the Linux kernel is compiled/built, we need to setup the configuration.

1. Load the default Cyclone5 configuration

$ make ARCH=arm CROSS_COMPILE=arm-altera-eabi socfpga_defconfig

1. Then run menuconfig to enable CAN. In the case of the Altera repo, it should already be enabled but this should be confirmed.

$ make ARCH=arm CROSS_COMPILE=arm-altera-eabi menuconfig

and set the following

-> Networking Support
    -> <*> CAN Bus Subsystem Support
         -> <*> Raw CAN Protocol
         -> <*> Broadcast Manager CAN Protocol
         -> <*> CAN Gateway/Router
            CAN Device Drivers
            -> <*> Platform CAN drivers with Netlink support
            -> [*] CAN bit-timing calculation
            -> <*> Bosch C_CAN/D_CAN Devices
                -> <*> Generic Platform Bus based C_CAN/D_CAN Driver
            -> [*] CAN devices debugging messages

1. Then build the Linux kernel and the device tree with

$ make -j12 ARCH=arm CROSS_COMPILE=arm-altera-eabi zImage
$ make -j12 ARCH=arm CROSS_COMPILE=arm-altera-eabi dtbs

(assuming that the gcc directory for arm-altera-eabi is in your path)

1. Copy the resulting zImage and device tree blob into the SD card

$ cp arch/arm/boot/zImage /media/<your FAT directory on SD card>
$ cp arch/arm/boot/dts/socfpga_cyclone5_socdk.dtb  /media/<your FAT directory on SD card>

Building the CAN utilities

These instructions are for cross-compiling the CAN utilities on an Intel platform. Get the can-utils repo

$ mkdir -p  ~/tools/can; cd ~/tools/can
$ git clone https://github.com/linux-can/can-utils
$ cd can-utils
$ export CROSS_COMPILE=arm-altera-eabi-gcc 
$ ./autogen.sh
$ CC=${CROSS_COMPILE}gcc ./configure --host=arm-linux-gnueabihf build i8386
$ make clean all

then make sure it compiled as a ARM elf. To verify this,

$ file cansend
cansend: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-armhf.so.3, for GNU/Linux 2.6.32, BuildID[sha1]=16f8e4f6ae73a0caaf23c13c576f6f4c95dd690d, not stripped

Using the CAN Utilities

Installing the CAN Utilities

Copy the following CAN utilities into the /bin or /usr/bin directory of the root file system.

• can-calc-bit-timing
• candump
• cangen
• canlogserver
• cansend
• cansniffer

Using the CAN Utilities

The CAN device should be available now but we need to start it.

# ip link set can0 up type can bitrate 50000

Note that you can add "loopback=on" if wanted for testing. The affects of the above are

• Create a can device named can
• Start it (up)
• Set the bitrate to 50KHz

If you get an error like this

ip: either "dev" is duplicate, or "type" is garbage

It usually means that iproute2 is not installed. iproute2 can usually be installed with the Angstrom filesystem using:

# opkg install iproute2

Check the result of

# which ip

If it points to /bin/ip, you're probably using busybox. If you see /sbin/ip then you're probably using iproute2

Listening to CAN traffic

It is usually desirable to listen to any CAN traffic using candump

# candump -x can0 &

which will run in the background and print any CAN traffic.

Sending CAN traffic

To send a string (of up to 8 bytes) to another device

# cansend can0 123#11.22.33.44