This is an Intel® Edison GPIO Pin Multiplexing Guide

Introduction

The Intel® Edison platform contains external input/output pin connections which may be configured to be used in a variety of interfacing modes, such as GPIO, PWM, SPI, I2C, ADC, for compatibility with Arduino Uno shield hardware. This article describes the pin functions available, detailed GPIO pin mapping for pin control and I/O, and use of Linux command line tools to configure the external I/O pin functions correctly for the desired mode of operation.

1. To use the information in this guide, all you need is access to the Linux command line on an Intel® Edison Arduino baseboard. If you want to dig a bit deeper, then the schematics should be available at maker.intel.com in the Edison Community section.

GPIO allocation and shield pin control

The 20 Arduino-compatible shield I/O pins on the Edison board are numbered IO0-IO19 (see Figure 1 below). All pins support basic GPIO functionality. Some of the pins also support PWM, ADC, SPI or I2C functions. Selection of different pin functions on Edison is achieved through use of SoC pin control interfaces and GPIO output signals dedicated for multiplexing control. The following sections detail the mapping of each of the GPIO pins available on Edison platform to their respective functions, which can be broadly categorised as follows:

• External GPIO
  • Used for digital input/output signalling via the external shield pins
• Pin multiplexing control
  • Used for selecting different functions available on a given shield pin
• Pin buffer (level-shifter) direction control
  • Used to configure the buffer on a given shield pin for input or output
• Pin pull-up resistor control
  • Used to enable/disable a pull-up resistor on a given shield pin
• Miscellaneous

To use any of the supported functions on a shield pin, it is first necessary to configure the multiplexing, buffer direction, and pull-up resistor controls applicable to that pin.    

Figure 1. Intel® Edison Arduino board

Shield pin GPIO mapping

The following table describes the mapping of GPIO and PWM pin numbers (in Linux) to shield I/O pins. The following details are included:

• Shield Pin – Digital I/O pin number as per Arduino Uno pin numbering scheme
• Linux – The pin number assigned under Linux
• Muxed Functions – Other signals available on this shield pin

• Shield	GPIO	PWM	Muxed functions	Notes
  Pin	Linux Pin	Linux Pin
  IO0	130		UART1_RXD
  IO1	131		UART1_TXD
  IO2	128		UART1_CTS*
  IO3	12	0	PWM0	Depends on PWM Swizzler**
  IO4	129		UART1_RTS*
  IO5	13	1	PWM1	Depends on PWM Swizzler**
  IO6	182	2	PWM2	Depends on PWM Swizzler**
  IO7	48		-
  IO8	49		-
  IO9	183	3	PWM3	Depends on PWM Swizzler**
  IO10	41	Swiz	SPI_2_SS1
  			I2S_2_FS*
  			PWM4_OUT	Depends on PWM Swizzler**
  IO11	43	Swiz	SPI_2_TXD
  			I2S_2_TXD*
  			PWM5_OUT	Depends on PWM Swizzler**
  IO12	42		SPI_2_RXD
  			I2S_2_RXD*
  IO13	40		SPI_2_CLK
  			I2S_2_CLK*
  IO14	44		AIN0
  IO15	45		AIN1
  IO16	46		AIN2
  IO17	47		AIN3
  IO18	14		AIN4
  			I2C_6_SDA
  IO19	165		AIN5

• Table 1: Shield pin GPIO mapping

* Some additional functions are available on certain SoC pins, such as I2S and UART flow control, but are not currently planned to be supported by the Arduino library. However, it may be possible to utilise these from Linux.
** The SoC offers only 4 PWM pins. A jumper pin matrix labelled “PWM swizzler” on the base board allows these 4 pins to be connected to any subset of the 6 shield header pins normally used for PWM. From the factory, IO3, IO5, IO6 and IO9 will be connected to the 4 available SoC PWM pins as described above. This can be manually altered to connect IO10 or IO11.

Summary Pin Function Multiplexing Control

All GPIO pins on the Arduino header require some intenal GPIOs to be set up before the pin is usable. This is usually as simple as setting an output enable, pull-up enable and mode. However, some pins have extra functionality such as SPI, PWM, or I2C, so these pins need extra multiplexing (muxing) in order to be usable. The table below attempts to simplify this so that a programmer can easily see all the muxing pins affected for a given Arduino header pin. The colour codes in the table show related boxes. For example the blue boxes are meant to show the relationship between the Pin Mux pins and the Pin Modes. This table is a synopsis of the more detailed tables below, which contain extra information such as schematic pin numbers. For most needs, this synopsized table should suffice. 

Note: Before setting up any muxing, it is recommended to set pin 214 (TRI_STATE_ALL) LOW, make all your changes, then set pin 214 HIGH again. 

Example 1: Setting up IO0 for output. Pin 0 has no muxing requirements, so just needs output enable and pull-up enable set. 
Exampel 2: Setting IO10 to SPI, 263 needs to be set HIGH, which enables non-PWM functionality, contolled by 240. 240 needs to be set HIGH, and then setting the SoC Pin Mode to mode1 selects the SPI function.

There are several more detailed examples at the end of this article.

GPIO interrupt support

All GPIO inputs on the Edison platform are interrupt-capable, and all interrupt types are supported on all inputs. The following table lists the specific edge- and level-triggered interrupt types which are supported on each pin.

Table 2: GPIO Interrupt Support
* Level-triggered interrupts are not supported by the Arduino library, a limitation of the GPIO sysfs interface.

Detailed Pin Function Multiplexing Control

The following table lists the GPIO outputs dedicated to pin multiplexing control. Different functions may be selected for specific shield I/O pins by setting these GPIO outputs to 0/1 (low/high). Additionally, some of the SoC GPIO pins also feature internal mux options. These are listed as “SoC Pin Modes”. Currently, these are configured by setting the required pin mode for the corresponding SoC GPIO pin N, via /sys/kernel/debug/gpio_debug/gpioN/current_pinmux, to “mode[0/1/2/...]”

Table 3: Pin Function Multiplexing Control  
* These pins are pulled-up inputs at power-on. This effectively enables the Mux switches (i.e. Mux function 1 is selected).        

Pin direction and pull-up control

For most shield pins on the Edison board, there is a buffer/level-shifter which needs to be configured for input or output direction, and an external 47k pull-up/down resistor which may be optionally enabled. Both are driven by dedicated GPIO outputs, listed below. When configuring a shield pin as an output, it is advisable to configure the buffer for output BEFORE setting the SoC GPIO pin direction to output. To disconnect the external pull-up/down resistors, it is necessary to configure as high-impedance inputs the GPIOs which drive them. Note also that the GPIO signals from the PCAL9555A GPIO expanders have internal 100k pull-up resistors which are connected to the GPIO pins by default. These need to be disabled in many cases, by configuring those pins as high-impedance inputs.

Table 4: Pin direction and pull-up control  
* These pins are externally pulled-down inputs at power-on. This effectively selects input direction for level shifters.
** These pins are internally pulled-up inputs at power-on. This effectively enables pull-ups (as 100k + 47k in series).      

Miscellaneous GPIOs

The following GPIOs are used other platform functions and for Arduino shield compatibility.

Table 5: Miscellaneous GPIOs   * These pins are pulled-up inputs at power-on. In this state, they have the same effect as outputs set high.  

Shield pin configuration guide

1. Identify the Arduino shield pin number of the pin you wish to use, in the range IO0-IO19.
2. Identify the functions available for the given pin, and select the function you wish to use
   1. Typical functions are GPIO, PWM, UART, I2C, SPI, ADC.
   2. Only some functions are available on each pin.
3. Determine which GPIO signals, if any, need to be configured to select the correct pin muxing option for the selected function. Some pins only have a single function, or do not require mux control.
4. Determine which GPIO signals, if any, need to be configured to select the pin buffer direction for input or output, and determine the direction that is required.
5. Determine which GPIO signals, if any, need to be configured to select the pull-up resistor control, and whether the pull-up resistor should be enabled or disabled. Generally, for most pin functions, the pull-up resistors should typically be disabled. For GPIO input functions, the pull-up resistor may optionally be enabled or disabled according to the needs of the user.
6. Export the above GPIO numbers for access in the Linux user-space environment (i.e. from the command shell)
7. Configure the above GPIO numbers for output
8. Assert the TRI_STATE_ALL signal to disconnect the shield pins
9. Set the above GPIO numbers to assert their output logic levels as high or low.
10. Set the SoC GPIO pin mode for the required functionality
11. De-assert the TRI_STATE_ALL signal to reconnect the shield pins

Example 1: Configure IO5 as a GPIO input, with pull-up resistor disabled

1. The shield number is IO5. According to Table 1, the GPIO number is 13.
2. The function required is GPIO. According to Table 1, other functions available on this shield pin are: PWM
3. According to Table 3, GPIO 43 pin-mux must be set to mode0 to select GPIO According to Table 4, GPIO 253 must be set to 0 to disable the output direction for IO5.
4. According to Table 4, GPIO 221 must be set as a high-impedance input to disable the external pull-up resistor for IO5.
5. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

  So, the commands in Linux to achieve this are as follows:

# echo 13 > /sys/class/gpio/export
# echo 253 > /sys/class/gpio/export
# echo 221 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo low > /sys/class/gpio/gpio253/direction
# echo in > /sys/class/gpio/gpio221/direction
# echo mode0 > /sys/kernel/debug/gpio_debug/gpio13/current_pinmux
# echo in > /sys/class/gpio/gpio13/direction
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO5 as a GPIO input. For example:  

# cat /sys/class/gpio/gpio13/value  

Example 2: Configure IO11 as a GPIO input, with pull-up resistor disabled

1. The shield number is IO11. According to Table 1, the GPIO number is 43.
2. The function required is GPIO. According to Table 1, other functions available on this shield pin are: PWM, SPI, I2S
3. According to Table 3, GPIO 262 must be set to 1 to select GPIO/SPI, GPIO 241 must be set to 0 to select GPIO, and GPIO 43 pin-mux must be set to ‘mode0’ to select GPIO
4. According to Table 4, GPIO 259 must be set to 0 to disable the output direction for IO11.
5. According to Table 4, GPIO 227 must be set as a high-impedance input to disable the external pull-up resistor for IO5.
6. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

  So, the commands in Linux to achieve this are as follows:

# echo 43 > /sys/class/gpio/export
# echo 262 > /sys/class/gpio/export
# echo 241 > /sys/class/gpio/export
# echo 259 > /sys/class/gpio/export
# echo 227 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo high > /sys/class/gpio/gpio262/direction
# echo low > /sys/class/gpio/gpio241/direction
# echo mode0 > /sys/kernel/debug/gpio_debug/gpio43/current_pinmux
# echo low > /sys/class/gpio/gpio259/direction
# echo in > /sys/class/gpio/gpio227/direction
# echo in > /sys/class/gpio/gpio43/direction
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO11 as a GPIO input. For example:  

# cat /sys/class/gpio/gpio43/value    

Example 2: Configure IO7 as a GPIO input, with pull-up resistor enabled

1. The shield number is IO7. According to Table 1, the GPIO number is 48.
2. The function required is GPIO. According to Table 1, there are no other functions available on this pin
3. For IO7, there are no applicable mux options listed in Table 3.
4. According to Table 4, GPIO 255 must be set to 0 to disable the output direction for IO7.
5. According to Table 4, GPIO 223 must be set to output high to enable the external pull-up resistor for IO7.
6. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

# echo 48 > /sys/class/gpio/export
# echo 255 > /sys/class/gpio/export
# echo 223 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo low > /sys/class/gpio/gpio255/direction
# echo high > /sys/class/gpio/gpio223/direction
# echo in > /sys/class/gpio/gpio48/direction
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO7 as a GPIO input. For example:  

# cat /sys/class/gpio/gpio48/value    

Example 3: Configure IO6 as a PWM output

1. The shield number is IO6. According to Table 1, the GPIO number is 182.
2. The function required is PWM. According to Table 1, other functions available on this pin are: GPIO
3. According to Table 3, GPIO 182 pin-mux must be set to ‘mode1’ to select PWM
4. According to Table 4, GPIO 254 must be set to 1 to enable the output direction for IO6.
5. According to Table 4, GPIO 222 must be set as a high-impedance input to disable the pull-up resistor for IO6.
6. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

# echo 254 > /sys/class/gpio/export
# echo 222 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo high > /sys/class/gpio/gpio254/direction
# echo in > /sys/class/gpio/gpio222/direction
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio182/current_pinmux
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO6 as a PWM ouput. For example:

# echo 2 > /sys/class/pwm/pwmchip0/export
# echo 2000000 > /sys/class/pwm/pwmchip0/pwm2/duty_cycle
# echo 1 > /sys/class/pwm/pwmchip0/pwm2/enable  

Example 3: Configure IO14 as an ADC input

Note on ADC usage: The ADC sits on the SPI bus, and as such the SPI pins need to be set to a valid configuration (after cold boot) before the ADC can be used. Just Pins 10-13 as input (even just setting pin 13 will do), and the ADC will then function fine on 14-19. 

1. The shield number is IO14. According to Table 1, the GPIO number is 44.
2. The function required is ADC. According to Table 1, other functions available on this pin are: GPIO
3. According to Table 3, GPIO 200 must be set to 1 to select ADC.
4. According to Table 4, GPIO 232 must be set to 0 to disable the output direction for IO14.
5. Any GPIO lines which are directly connected to IO14 should be configured as high-impedance inputs to prevent possible current leakage. According to Table 4, GPIO 208 is used to enable a pull-up resistor for IO14.
6. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

  So, the commands in Linux to achieve this are as follows:

# echo 200 > /sys/class/gpio/export
# echo 232 > /sys/class/gpio/export
# echo 208 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo high > /sys/class/gpio/gpio200/direction
# echo low > /sys/class/gpio/gpio232/direction
# echo in > /sys/class/gpio/gpio208/direction
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO14 as an ADC input. For example:

# cat /sys/bus/iio/devices/iio:device1/in_voltage0_raw  

Example 4: Configure IO18/IO19 for I2C connectivity

1. The shield number is IO18 and IO19. Corresponding GPIO numbers are 28 and 27, respectively.
2. The function required is I2C. According to Table 1, other functions available on these pins are: GPIO, ADC
3. According to Table 3, GPIO 204 must be set to 0 to select GPIO/I2C, and GPIO 28 pin-mux must be set to ‘mode1’ to select I2C for IO18
4. According to Table 3, GPIO 205 must be set to 0 to select GPIO/I2C, and GPIO 27 pin-mux must be set to ‘mode1’ to select I2C for IO19
5. GPIO 14 and GPIO 165 are also connected to the I2C signals, and should be configured as high-impedance inputs when I2C is in use on these pins, to prevent them driving a signal on the I2C bus.
6. According to Table 4, GPIO 236 must be set to 0 to disable the output direction for GPIO 14, and GPIO 237 must be set to 0 to disable the output direction for GPIO 165.
7. According to Table 4, GPIO 212 and 213 must be set as high-impedance inputs to disable the pull-up resistors for IO18 and IO19, respectively.
8. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

  So, the commands in Linux to achieve this are as follows:

# echo 28 > /sys/class/gpio/export
# echo 27 > /sys/class/gpio/export
# echo 204 > /sys/class/gpio/export
# echo 205 > /sys/class/gpio/export
# echo 236 > /sys/class/gpio/export
# echo 237 > /sys/class/gpio/export
# echo 14 > /sys/class/gpio/export
# echo 165 > /sys/class/gpio/export
# echo 212 > /sys/class/gpio/export
# echo 213 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo low > /sys/class/gpio/gpio204/direction
# echo low > /sys/class/gpio/gpio205/direction
# echo in > /sys/class/gpio/gpio14/direction
# echo in > /sys/class/gpio/gpio165/direction
# echo low > /sys/class/gpio/gpio236/direction
# echo low > /sys/class/gpio/gpio237/direction
# echo in > /sys/class/gpio/gpio212/direction
# echo in > /sys/class/gpio/gpio213/direction
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio28/current_pinmux
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio27/current_pinmux
# echo high > /sys/class/gpio/gpio214/direction

Now, it should be possible to use IO18 and IO19 for I2C communication.  

Example 5: Configure IO10-13 for SPI connectivity

1. The shield pins are IO10, IO11, IO12 and IO13. Corresponding GPIO numbers are GPIO 111, 115, 114, and 109, respectively.
2. The function required is SPI. According to Table 1, other functions available on these pins are: GPIO, PWM
3. According to Table 3, GPIO 263 must be set to 1 to select GPIO/SPI, GPIO 240 must be set to 1 to select SPI, and GPIO 111 pin-mux must be set to ‘mode1’ to select SPI for IO10
4. According to Table 3, GPIO 262 must be set to 1 to select GPIO/SPI, GPIO 241 must be set to 1 to select SPI, and GPIO 115 pin-mux must be set to ‘mode1’ to select SPI for IO11
5. According to Table 3, GPIO 242 must be set to 1 to select SPI, and GPIO 114 pin-mux must be set to ‘mode1’ to select SPI for IO12
6. According to Table 3, GPIO 243 must be set to 1 to select SPI, and GPIO 109 pin-mux must be set to ‘mode1’ to select SPI for IO13
7. According to Table 4, GPIO 258 must be set to 1 to enable the output direction for IO10, GPIO 259 must be set to 1 to enable the output direction for IO11, GPIO 260 must be set to 0 to disable the output direction for IO12, and GPIO 261 must be set to 1 to enable the output direction for IO13.
8. According to Table 4, GPIOs 226-229 must be set as high-impedance inputs to disable the pull-up resistors for IO10-13.
9. According to Table 5, the TRI_STATE_ALL signal is controlled by GPIO 214

  So, the commands in Linux to achieve this are as follows:

# echo 111 > /sys/class/gpio/expor
# echo 115 > /sys/class/gpio/export
# echo 114 > /sys/class/gpio/export
# echo 109 > /sys/class/gpio/export
# echo 263 > /sys/class/gpio/export
# echo 240 > /sys/class/gpio/export
# echo 262 > /sys/class/gpio/export
# echo 241 > /sys/class/gpio/export
# echo 242 > /sys/class/gpio/export
# echo 243 > /sys/class/gpio/export
# echo 258 > /sys/class/gpio/export
# echo 259 > /sys/class/gpio/export
# echo 260 > /sys/class/gpio/export
# echo 261 > /sys/class/gpio/export
# echo 226 > /sys/class/gpio/export
# echo 227 > /sys/class/gpio/export
# echo 228 > /sys/class/gpio/export
# echo 229 > /sys/class/gpio/export
# echo 214 > /sys/class/gpio/export
# echo low > /sys/class/gpio/gpio214/direction
# echo high > /sys/class/gpio/gpio263/direction
# echo high > /sys/class/gpio/gpio240/direction
# echo high > /sys/class/gpio/gpio262/direction
# echo high > /sys/class/gpio/gpio241/direction
# echo high > /sys/class/gpio/gpio242/direction
# echo high > /sys/class/gpio/gpio243/direction
# echo high > /sys/class/gpio/gpio258/direction
# echo high > /sys/class/gpio/gpio259/direction
# echo low > /sys/class/gpio/gpio260/direction
# echo high > /sys/class/gpio/gpio261/direction
# echo in > /sys/class/gpio/gpio226/direction
# echo in > /sys/class/gpio/gpio227/direction
# echo in > /sys/class/gpio/gpio228/direction
# echo in > /sys/class/gpio/gpio229/direction
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio111/current_pinmux
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio115/current_pinmux
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio114/current_pinmux
# echo mode1 > /sys/kernel/debug/gpio_debug/gpio109/current_pinmux
# echo high > /sys/class/gpio/gpio214/direction

About Us

Emutex is a software engineering company based in Ireland. We are passionate about developing innovative software solutions for embedded systems. To learn more about us, please visit our company website: http://www.emutex.com