A Class for Handling UIO

A simple user space class for handling UIO is in my github. First we want a structure that matches the register space. We can then create a pointer and hand this map to it.

struct gpio_map
{
uint32_t ch1Data;     // 0x00
uint32_t ch1Tristate; // 0x04 
uint32_t ch2Data;     // 0x08
uint32_t ch2Tristate; // 0x0C

uint32_t pad1[67];


uint32_t globalInt; //0x11C
uint32_t intStatus; //0x120
uint32_t pad2;		    
uint32_t intEn;     //0x128
};

Now we have a class that allows us to interact through getters and setters.

class gpio
{
  private:
    gpio_map *map;
    int fd;

  public:
    gpio(char *filename);

    void     enableInterrupt(bool ch1, bool ch2);
    void     enableInterruptGlobal(bool);
    void     waitInt();
    void     clearInt();

    uint32_t getCh1Data();
    uint32_t getCh1Tristate();
    void     setCh1Data(uint32_t data);
    void     setCh1Tristate(uint32_t tristate);
    
    uint32_t getCh2Data();
    uint32_t getCh2Tristate();
    void     setCh2Data(uint32_t data);
    void     setCh2Tristate(uint32_t tristate);
};

Walkthrough of Each Method

enableInterrupt – sets the interrupts for each channel

enableInterruptGlobal -sets the global interrupt

waitInt – calls read() on the file descriptor, does not return until interrupt happens

clearInt – writes ISR to reset, the calls write() on file descriptor to unmask interrupt

getChXData – returns a uint32_t containing the data in channel X register

setChXData – set the value of the data register

setChXTristate- sets the tristate register, allowing the direction of i/o pins to be changed

Complete Source of gpio.cpp

#include "gpio.h"
#include <iostream>

using namespace std;

gpio::gpio(char *filename)
{
  char *addr;
  fd = open (filename, O_RDWR | O_SYNC);

  if(fd == -1)
  {
    cout << "failed to open device" << endl;
    exit(1);
  }
  addr = (char *)mmap(NULL, 65536, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
  if(addr == MAP_FAILED)
  {
    cout << "mmap failed";
    exit(1);
  } 
  map = (gpio_map *) addr; 
}
void gpio::enableInterrupt(bool ch1, bool ch2)
{
  uint32_t val = 0;
  if(ch1)
  {
    val |= 0x1;
  }
  if(ch2)
  {
    val |= 0x2; 
  }
  map->intEn = val;
}
void gpio::enableInterruptGlobal(bool en)
{
  if(en)
  {
    map->globalInt = 0x80000000;  
  }
  else
  {
    map->globalInt = 0;
  }
}
void gpio::clearInt()
{
  uint32_t info = 1;
  uint32_t intStatus;

  intStatus = map->intStatus;
  if(intStatus)
  {
    map->intStatus = intStatus;
  }
  ssize_t nb = write(fd, &info, sizeof(info));
  
  if( nb != (ssize_t)sizeof(info))
  {
    cout << "write error" << endl;
    exit(1);
  }

}
void gpio::waitInt()
{
  
  uint32_t info = 1;

  ssize_t nb = read(fd, &info, sizeof(info));
}
void gpio::setCh1Data(uint32_t data)
{
  map->ch1Data = data;
}
void gpio::setCh2Data(uint32_t data)
{
  map->ch2Data = data;
}
uint32_t gpio::getCh1Data()
{
  return map->ch1Data;
}
uint32_t gpio::getCh2Data()
{
  return map->ch2Data;
}
void  gpio::setCh1Tristate(uint32_t tristate)
{
  map->ch1Tristate = tristate;
}
uint32_t  gpio::getCh1Tristate()
{
  return map->ch1Tristate;
}
void  gpio::setCh2Tristate(uint32_t tristate)
{
  map->ch2Tristate = tristate;
}
uint32_t  gpio::getCh2Tristate()
{
  return map->ch2Tristate;
}

A Simple Helloworld

First we create a new gpio instance, I’ve named it “leds. Pass it the path to the device you would like to open (“/dev/uio1”). Enable the channel two interrupt (thats where my switches are). Enable global interrupt. Clear the interrupt register and unmask it. Now we just wait until a switch is moved, print the current state, and clear the interrupt, in a loop:

#include <iostream>
#include "gpio.h"

using namespace std;



int main()
{
  gpio leds((char *) "/dev/uio1");
  leds.enableInterrupt(false, true);
  leds.enableInterruptGlobal(true);
  leds.clearInt(); 
  uint32_t i=0;
  while(1)
  {
    leds.waitInt();
    leds.setCh1Data(0xFFFF);
    cout << "switch changed " << leds.getCh2Data() << endl;
    leds.clearInt();
  }
}

Output

LinuxBoot:~/gpiodrv$ sudo ./helloworld
Password: 
switch changed 1
switch changed 5
switch changed 4
switch changed 6
switch changed 14
switch changed 10
switch changed 14
switch changed 12