The BeagleBone's I/O pins: inside the software stack that makes them work

The BeagleBone is a inexpensive, credit-card sized computer with many I/O pins.
These pins can be easily controlled from software, but it can be very mysterious what is really happening.
To control a general purpose input/output (GPIO) pin, you simply write a character to a special file and the pin turns on or off. But how do these files control the hardware pins?
In this article, I dig into the device drivers and hardware and explain exactly what happens behind the scenes.
(Variousweb pages describe the GPIO pins, but if you just want a practical guide of how to use the GPIO pins,
I recommend the detailed and informative book Exploring BeagleBone.)

This article focuses on the BeagleBone Black, the popular new member of the BeagleBoard family.
If you're familiar with the Arduino, the BeagleBone is much more complex;
while the Arduino is a microcontroller, the BeagleBone is a full computer running Linux.
If you need more than an Arduino can easily provide (more processing, Ethernet, WiFi), the BeagleBone may be a good choice.

The BeagleBone uses the Sitara AM3358 processor chip running at 1 GHz - this is the thumbnail-sized chip in the center of the board above.
This chip is surprisingly complicated; it appears they threw every feature someone might want into the chip.
The diagram below shows what is inside the chip:
it includes a 32-bit ARM processor, 64KB of memory,
a real-time clock, USB, Ethernet, an LCD controller, a 3D graphics engine, digital audio, SD card support, various networks, I/O pins, an analog-digital converter, security hardware, a touch screen controller, and much more.[1]
To support real-time applications, the Sitara chip also includes two separate 32-bit microcontrollers (on the chip itself - processors within processors!).

The main document that describes the Sitara chip is the
Technical Reference Manual, which I will call the TRM for short. This is a 5041 page document describing all the feature of the Sitara architecture and how to control them.
But for specifics on the AM3358 chip used in the BeagleBone, you also need to check the
253 page datasheet.
I've gone through these documents, so you won't need to, but I reference the relevant sections in case you want more details.

Using a GPIO pin

The chip's pins can be accessed through two BeagleBone connectors, called P8 and P9.
To motivate the discussion, I'll use an LED connected to GPIO 49, which is on pin 23 of header P9 (i.e. P9_23).
(How do you know this pin is GPIO 49? I explain that below.)
Note that the Sitara chip's outputs can provide much less current than the Arduino, so be careful not to overload the chip; I used a 1K resistor.

To output a signal to this GPIO pin, simply write some strings to some files:

The first line causes a directory for gpio49 to be created. The next line sets the pin mode as output. The third line turns the pin on; writing 0 will turn the pin off.

This may seem like a strange way to control the GPIO pins, using special file system entries.
It's also strange that strings ("49", "out", and "1") are used to control the pin.
However, the file-based approach fits with the Unix model, is straightforward to use from any language, avoids complex APIs, and hides the complexity of the chip.

The file-system approach is very slow, capable of toggling a GPIO pin at about 160 kHz,
which is rather awful performance for a 1 GHz processor.[2]
In addition, these oscillations may be interrupted for several milliseconds if the CPU is being used for other tasks, as you can see from the image below.
This is because
file system operations have a huge amount of overhead and context switches before anything gets done.
In addition, Linux is not a real-time operating system. While the processor is doing something else, the CPU won't be toggling the pins.

An I/O pin can be toggled to form an oscillator. Unfortunately, oscillations can stop for several milliseconds if the processor is doing something else.

The moral here is that controlling a pin from Linux is fine if you can handle delays of a few milliseconds.
If you want to produce an oscillation, don't manually toggle the pin, use a PWM (pulse width modulator) output instead.
If you need more complex real-time outputs, use one of the microcontrollers (called a PRU) inside the processor chip.

What's happening internally with GPIOs?

Next, I'll jump to the low level, explaining what happens inside the chip to control the GPIO pins.
A GPIO pin is turned on or off when a chip register at a particular address is updated.
To access memory directly, you can use
devmem2, a simple program that allows a memory register to be read or written.
Using the devmem2 program, we can turn the GPIO pin first on and then off by writing a value to the appropriate register (assuming the pin has been initialized). The first number is the address, and the second number is value written to the address.

devmem2 0x4804C194 w 0x00020000
devmem2 0x4804C190 w 0x00020000

What are all these mystery numbers?
GPIO 49 is also known as GPIO1_17, the 17th pin in the GPIO1 bank (as will be explained later).
The value written to the register, 0x00020000, is a 1 bit shifted left 17 positions (1<<17) to control pin 17.
The address 4804C194 is the address of the register used to turn on a GPIO pin. Specifically it is SETDATAOUT register for the 32 GPIO1 pins.
By writing a bit to this register, the corresponding pin is turned on.
Similarly, the address 4804C190 is the address of the CLEARDATAOUT register, which turns a pin off.

How do you determine these register addresses?
It's all defined in the TRM document if you know where to look.
The address 4804C000 is the starting address of GPIO1's registers (see Table 2-3 in the TRM).
The offset 194h is the offset of the GPIO_SETDATAOUT register, and 190h is the GPIO_CLEARDATAOUT register (see TRM 25.4.1).
Combining these, we get the address 4804C194 for GPIO1's SETDATAOUT and 4804C190
for CLEARDATAOUT.
Writing a 1 bit to the SETDATAOUT register will set that GPIO, while leaving others unchanged. Likewise, writing a 1 bit to the CLEARDATOUT register will clear that GPIO.
(Note that this design allows the selected register to be modified without risk of modifying other GPIO values.)

Putting this all together, writing the correct bit pattern to
the address 0x4804C194 or 0x4804C190 turns the GPIO pin on or off. Even if you use the filesystem API to control the pin, these registers are what end up controlling the pin.

How does devmem2 work? It uses Linux's /dev/mem, which is a device file that is an image of physical memory. devmem2 maps the relevant 4K page of /dev/mem into the process's address space and then reads or writes the address corresponding to the desired physical address.

By using mmap and toggling the register directly from a C++ program, the GPIO can be toggled at about 2.8 MHz, much faster than the device driver approach.[3]
If you think this approach will solve your problems, think again.
As before, there are jitter and multi-millisecond dropouts if there is any other load on the system.

The names of pins

Confusingly, each pin has multiple names and numbers.
For instance, pin 23 on header 9 is GPIO1_17, which is GPIO 49, which is pin entry 17 (unrelated to GPIO1_17) which is pin V14 on the chip itself. Meanwhile, the pin has 7 other functions including GMPC_A1, which is the name used for the pin in the documentation.
This section explains the different names and where they come form.
(If you just want to know the pin names, see the diagrams P8 header
and P9 header from Exploring Beaglebone.)

The first complication is that each pin has eight different functions
since the processor has many more internal functions than physical pins.[4]
(The Sitara chip has about 639 I/O signals, but only 124 output pins available for these signals.)
The solution is that each physical pin has eight different internal functions mapped to it. For each pin, you select a mode 0 through 7, which selects which of the eight possible functions you want.

Figuring out "from scratch" which functions are on each BeagleBone header pin is tricky and involves multiple documents.
To start, you need to determine what functions are on each physical pin (actually ball) of the chip.
Table 4-1 in the chip datasheet shows which signals are associated with each physical pin (see the "ZCZ ball number").
(Or see section 4.3 for the reverse mapping, from the signal to the pin.)
Then look at the BeagleBone schematic to see the connection from each pin on the chip (page 3) to an external connector (page 11).

For instance, consider the GPIO pin used earlier.
With the ZCZ chip package, chip ball V14 is called GPMC_A1 (in mode 0 this pin is used for the General Purpose Memory Controller).
The Beaglebone documentation names the pin with the the more useful mode 7 name "GPIO1_17", indicating GPIO 17 in GPIO bank 1.
(Each GPIO bank (0-3) has 32 pins. Bank 0 is numbered 0-31, bank 1 is 32-63, and so forth. So pin 17 in bank 1 is GPIO number 32+17=49.)
The schematic shows this chip ball is connected to header P9 pin 23, earning it the name P9_23. This name is relevant when connecting wires to the board. It is also the name used in BeagleScript (discussed later).

Another pin identifier is the sequential pin number based on the the pin control registers.
(This number is indicated under the column $PINS in the header diagrams.)
Table 9-10 in the TRM lists all the pins in order along with their control address offsets. Inconveniently, the pin names are the mode 0 names (e.g. conf_gpmc_a1), not the more relevant names (e.g. gpio1_17).
From this table, we can determine that the offset of con_gpmc_a1 is 844h.
Counting the entries (or computing (844h-800h)/4) shows that this is pin 17 in the register list.
(It's entirely coincidental that this number 17 matches GPIO1_17).
This number is necessary when using the pin multiplexer (described later).

How writing to a file toggles a GPIO

When you write a string to /sys/class/gpio/gpio49/value, how does that end up modifying the GPIO?
Now that some background has been presented, this can be explained.
At the hardware level, toggling a GPIO pin simply involves setting a bit in a control register, as explained earlier.
But it takes thousands of instructions in many layers to get from writing to the file to updating the register and updating the GPIO pin.

The write goes through the standard Linux file system code (user library, system call code, virtual file system layer) and ends up in the sysfs virtual file system. Sysfs is an in-memory file system that exposes kernel objects through virtual files. Sysfs will dispatch the write to the gpio device driver, which processes the request and updates the appropriate GPIO control register.

In more detail,
the /sys/class/gpio filesystem entries are provided by the gpio device driver
(documentation for sysfs and
gpio).
The main gpio driver code is gpiolib.c.
There are separate drivers for many different types of GPIO chips;
the Sitara chip (and the related OMAP family) uses
gpio-omap.c.
The Linux code is in C, but you can think of gpiolib.c as the superclass, with subclasses for each different chip.
C function pointers are used to access the different "methods".

The gpiolib.c code informs sysfs of the various files
to control GPIO pin attributes (/active_low, /direction/, /edge, /value), causing them to
appear in the file system for each GPIO pin.
Writes to the /value file are linked to the function gpio_value_store, which parses the string value, does error checking and calls gpio_set_value_cansleep, which calls chip->set().
This function pointer is where handling switches from the generic gpiolib.c code to the device-specific gpio-omap.c code. It calls gpio_set, which calls _set_gpio_dataout_reg, which determines the register and bit to set.
This calls raw_writel, which is inline ARM assembler code to do a STR (store) instruction. This is the point at which the GPIO control register actually gets updated, changing the GPIO pin value.[5]
The key point is that a lot of code runs to get from the file system operation to the actual register modification.

How does the code know the addresses of the registers to update?
The file gpio-omah.h contains constants for the GPIO register offsets. Note that these are the same values we used earlier when manually updating the registers.

But how does the code know that the registers start at 0x4804C000?
And how does the system know this is the right device driver to use?
These things are specified, not in the code, but in a complex set of configuration files known as Device Trees, explained next.

Device Trees

How does the Linux kernel know what features are on the BeagleBone? How does it know what each pin does? How does it know what device drivers to use and where the registers are located?
The BeagleBone uses a Linux feature called the Device Tree, where the hardware configuration is defined in a device tree file.

Linux used to define the hardware configuration in the kernel.
But each new ARM chip variant required inconvenient kernel changes, which led to
Linus Torvald's epic rant on the situation.
The solution was to move this configuration out of kernel code and into files known as the Device Tree, which specifies the hardware associated with the device.
This switch, in the 3.8 kernel, is described here.

As if device trees weren't complex enough,
the next problem was that BeagleBone users wanted to change pin configuration dynamically.
The solution to this was device tree overlays, which allow device tree files to modify other device tree files.
With a device tree overlay, the base hardware configuration can be modified by configuration in the overlay file.
Then the Capemgr was implemented to dynamically load device tree fragments, to manage the installation of BeagleBoard daughter cards (known as capes).

The "compatible" line is very important as it causes the correct device driver to be loaded.
While processing a device tree file, the kernel checks all the device drivers to find one with a matching "compatible" line. In this case, the winning device driver is
gpio-omap.c, which we looked at earlier.

The other lines of interest specify the register base address 44e07000. This is how the kernel knows where to find the necessary registers for the chip.
Thus, the Device Tree is the "glue" that lets the device drivers in the kernel know the specific details of the registers on the processor chip.

BoneScript

One easy way to control the BeagleBone pins is by using JavaScript along with
BoneScript, a Node.js library.
The BoneScript API is based on the Arduino model.
For instance, the following code will turn on the GPIO on pin 23 of header P9.

Using BoneScript is very slow: you can toggle a pin at about 370 Hz, with a lot of jitter and the occasional multi-millisecond gap.
But for programs that don't require high speed, BoneScript provides a convenient programming model, especially for applications with web interaction.

For the most part, the BoneScript library works by reading and writing the file system pseudo-devices described earlier.
You might expect BoneScript to have some simple code to convert the method calls to the appropriate file system operations, but BoneScript is surprisingly complex.
The first problem is BoneScript supports different kernel versions with different cape managers and pin multiplexers, so it implements everything four different ways
(source).

A bit surprise is that BoneScript generates and installs new device tree files as a program is running.
In particular, for the common 3.8.13 kernel,
BoneScript creates a new device tree overlay (e.g.
/lib/firmware/bspm_P9_23_2f-00A0.dts) on the fly from a template, runs it through the dtc compiler and installs the device tree overlay through the cape manager by writing to /sys/devices/bone_capemgr.N/slots
(source).
That's right, when you do a pinMode() operation in the code, BoneScript runs a compiler!

Conclusion

The BeagleBone's GPIO pins can be easily controlled through the file system, but a lot goes on behind the scenes, making it very mysterious what is actually happening. Examining the documentation and the device drivers reveals how these file system writes affect the pins by writing to various control registers.[6]
Hopefully after reading this article, the internal operation of the Beaglebone will be less mysterious.

Notes and references

[1]
Many of the modules of the Sitara chip have cryptic names. A brief explanation of some of them, along with where they are described in the TRM:

PRU-ICSS (Programmable Real-Time Unit / Industrial Communication Subsystem, chapter 4): this is the two real-time microcontrollers included in the chip. They contain their own modules.

Industrial Ethernet is an extension of Ethernet protocols for industrial environments that require real-time, predictable communication. The Industrial Ethernet module provides timers and I/O lines that can be used to implement these protocols.

SGX (chapter 5) is a 2D/3D graphics accelerator.

GPMC is the general-purpose memory controller.
OCMC is the on-chip memory controller, providing access to 64K of on-chip RAM.
EMIF is the external memory interface. It is used on the BeagleBone to access the DDR memory.
ELM (error location module) is used with flash memory to detect errors.
Memory is discussed in chapter 7 of the TRM.

L1, L2, L3, L4: The processor has L1 instruction and data caches, and a larger L2 cache. The L3 interconnect provides high-speed communication between many of the modules of the processor using a "NoC" (Network on Chip) infrastructure.
The slower L4 interconnect is used for communication with low-bandwidth modules on the chip.
(See chapter 10 of the TRM.)

TS_ADC (touchscreen, analog/digital converter, chapter 12) is a general-purpose analog to digital converter subsystem that includes support for resistive touchscreens. This module is used on the BeagleBone for the analog inputs.

LCD controller (chapter 13) provides support for LCD screens (up to 2K by 2K pixels). This module provides many signals to the TDA19988 HDMI chip that generates the BeagleBone's HDMI output.

EMAC (Ethernet Media Access Controller, chapter 14) is the Ethernet subsystem.
RMII (reduced media independent interface) is the Ethernet interface used by the BeagleBone.
MDIO (management data I/O) provides control signals for the Ethernet interface.
GMII and RGMII are similar for gigabit Ethernet (unused on the BeagleBone).

The PWMSS (Pulse-width modulation subsystem, chapter 15) contains three modules. The eHRPWM (enhanced high resolution pulse width modulator) generates PWM signals, digital pulse trains with selectable duty cycle. These are useful for LED brightness or motor speed, for instance. These are sometimes called analog outputs, although technically they are not.
This subsystem also includes the eCAP (enhanced capture) module which measures the time of incoming pulses.
eQEP (Enhanced quadrature encoder pulse) module is a surprisingly complex module to process opitcal shaft encoder inputs (e.g. an optical encoder disk in a mouse) to determine its rotation.

[2]
The following C++ code uses the file system to switch GPIO 49 on and off. Remove the usleeps for maximum speed.
Note: this code omits pin initialization; you must manually do "echo 49 > /sys/class/gpio/export" and
"echo out > /sys/class/gpio/gpio49/direction".

[3]
Here's a program based on devmem2 to toggle the GPIO pin by accessing the register directly.
The usleeps are delays to make the flashing visible; remove them for maximum speed.
For simplicity, this program does not set the pin directions; you must do that manually.

I'm surprised your code in [2] works. There definitely was a time when you had to write the first byte of the file to get the kernel to accept the new value. Many people used lseek(, 0, SEEK_SET) or reopened the file and I was proud to have thought of pwrite(,,, 0) to do both in one syscall.

Anonymous: I verified that the code in [2] works as written (on the 3.8.13-bone79 kernel). Requiring lseek sounds like a bug in the driver, so it probably got fixed at some point. Nigel: Thanks, I fixed the text. I guess you're the first person to read the whole footnote :-)

A very practical article, thank you. I wish there was a similar article for the 4.4 kernel and universal capes, as they appear to change the working arrangement quite significantly. Especially if the pre-made device trees and universal capes don't fit your needs, and you need to roll your own :)

Many thanks for your post!I tried the code in [2] and it worked fine.Problems came up when I tried to go a little further, trying to read from a push button connected (properly!) on the same IO (set as direction:in).I manage to catch the button's state by "cat /sys/class/gpio/gpio49/value" (I get 0 if not pushed and 1 if pushed).Then I tried to use read() and I couldn't manage to catch the value with this code://---------------------------- int fd = open("/sys/class/gpio/gpio49/value",O_RDONLY); printf("fd:%d\n",fd); int* pbtn; int btn; int tmp;// while(1) { tmp=read(fd,(void*)pbtn,1); btn=*pbtn; printf("%d\n",tmp); printf("%x\n",btn); if (btn==1) { printf("Button pressed!\n"); } }//----------------------------

All I have is:fd:4-14f0b00f0

Any idea? (at least I hope I didn't do any stupid thing in C...)Thanks again!