Conducción de Beaglebone GPIO a través de / dev / mem

Ten cuidado. Esto funciona a primera vista, pero escribe directamente en un registro que el controlador del controlador GPIO cree que posee. Causará efectos secundarios extraños y difíciles de rastrear, ya sea en esta línea GPIO o en un GPIO que está en el mismo banco. Para que esto funcione de manera confiable, debe deshabilitar todo el banco desde el controlador GPIO del núcleo.

El código mostrado en el post original no funciona con el último Beaglebone Black y su núcleo 3.12 asociado. Las compensaciones del registro de control parecen haber cambiado; se verifica que el siguiente código funciona correctamente:

#define GPIO0_BASE 0x44E07000
#define GPIO1_BASE 0x4804C000
#define GPIO2_BASE 0x481AC000
#define GPIO3_BASE 0x481AE000

#define GPIO_SIZE  0x00000FFF

// OE: 0 is output, 1 is input
#define GPIO_OE 0x14d
#define GPIO_IN 0x14e
#define GPIO_OUT 0x14f

#define USR0_LED (1<<21)
#define USR1_LED (1<<22)
#define USR2_LED (1<<23)
#define USR3_LED (1<<24)

int mem_fd;
char *gpio_mem, *gpio_map;

// I/O access
volatile unsigned *gpio;

static void io_setup(void)
{
    // Enable all GPIO banks
    // Without this, access to deactivated banks (i.e. those with no clock source set up) will (logically) fail with SIGBUS
    // Idea taken from https://groups.google.com/forum/#!msg/beagleboard/OYFp4EXawiI/Mq6s3sg14HoJ
    system("echo 5 > /sys/class/gpio/export");
    system("echo 65 > /sys/class/gpio/export");
    system("echo 105 > /sys/class/gpio/export");

    /* open /dev/mem */
    if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
            printf("can't open /dev/mem \n");
            exit (-1);
    }

    /* mmap GPIO */
    gpio_map = (char *)mmap(
            0,
            GPIO_SIZE,
            PROT_READ|PROT_WRITE,
            MAP_SHARED,
            mem_fd,
            GPIO1_BASE
    );

    if (gpio_map == MAP_FAILED) {
            printf("mmap error %d\n", (int)gpio_map);
            exit (-1);
    }

    // Always use the volatile pointer!
    gpio = (volatile unsigned *)gpio_map;

    // Get direction control register contents
    unsigned int creg = *(gpio + GPIO_OE);

    // Set outputs
    creg = creg & (~USR0_LED);
    creg = creg & (~USR1_LED);
    creg = creg & (~USR2_LED);
    creg = creg & (~USR3_LED);

    // Set new direction control register contents
    *(gpio + GPIO_OE) = creg;
}

int main(int argc, char **argv)
{
    io_setup();
    while (1) {
        // Set LEDs
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) | USR0_LED;
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) | USR1_LED;
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) | USR2_LED;
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) | USR3_LED;

        sleep(1);

        // Clear LEDs
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) & (~USR0_LED);
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) & (~USR1_LED);
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) & (~USR2_LED);
        *(gpio + GPIO_OUT) = *(gpio + GPIO_OUT) & (~USR3_LED);

        sleep(1);
    }

    return 0;
}

Publico esto aquí ya que parece que el acceso mmap-ed dejó de funcionar alrededor del núcleo 3.8, y nadie ha publicado una solución que funcione desde entonces. Tuve que aplicar ingeniería inversa a las compensaciones del registro de control utilizando la interfaz / sys / class / gpio; espero que esta respuesta reduce parte de la frustración asociada con el uso de los GPIOs de BeagleBone con los núcleos más nuevos.

El código está licenciado bajo una licencia BSD feel siéntase libre de usarlo donde quiera.

EDITAR: user3078565 es correcto en su respuesta anterior. Tendrá que desactivar los controladores GPIO por defecto, ya sea configurando sus disparadores en ninguno o escondiéndolos completamente del núcleo a través de la edición del árbol de dispositivos. Si no se hace esto, los led parpadearán, ya que se supone que deben, pero también de vez en cuando tener sus estados anulados por el controlador GPIO del núcleo.

Esto no fue un problema para mi aplicación original, ya que utiliza GPIO bank 0, que es ignorado en gran medida por los controladores GPIO del núcleo.

Es posible que también necesite habilitar el reloj para cualquier pieza de hardware que esté tratando de controlar en el espacio de usuario. Afortunadamente, puedes usar dev / mem y mmap () para jugar con el registro de control de reloj para tu pieza de hardware en particular, como este código que escribí para habilitar SPI0: (definir valores son todos de spruh73i.pdf registro descripciones)

#define CM_PER_BASE     0x44E00000  /* base address of clock control regs */
#define CM_PER_SPI0_CLKCTRL     0x4C        /* offset of SPI0 clock control reg */

#define SPIO_CLKCTRL_MODE_ENABLE 2          /* value to enable SPI0 clock */

int mem;            // handle for /dev/mem

int  InitSlaveSPI(void) // maps the SPI hardware into user space
{
    char *pClockControl;    // pointer to clock controlregister block (virtualized by OS)
    unsigned int value;

    // Open /dev/mem:
    if ((mem = open ("/dev/mem", O_RDWR | O_SYNC)) < 0)
    {
        printf("Cannot open /dev/mem\n");
        return 1;
    }
    printf("Opened /dev/mem\n");

    // map a pointer to the clock control block:
    pClockControl = (char *)mmap(0, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, mem, CM_PER_BASE);

    if(pClockControl == (char *)0xFFFFFFFF) 
    {
        printf("Memory map failed. error %i\n", (uint32_t)pClockControl);
        close( mem );
        return 2;
    }

    value = *(uint32_t *)(pClockControl + CM_PER_SPI0_CLKCTRL);
    printf("CM_PER_SPI0_CLKCTRL was 0x%08X\n", value);

    *(uint32_t *)(pClockControl + CM_PER_SPI0_CLKCTRL) = SPIO_CLKCTRL_MODE_ENABLE;

    value = *(uint32_t *)(pClockControl + CM_PER_SPI0_CLKCTRL);
    printf("CM_PER_SPI0_CLKCTRL now 0x%08X\n", value);

    munmap( pClockControl, 4096 );              // free this memory map element

Una vez que he ejecutado este fragmento de código, puedo acceder a los registros SPI0 usando otro puntero mmap (). Si no habilito el módulo SPI0 clock primero, luego recibo un error de bus cuando intento acceder a esos registros SPI. Habilitar el reloj es persistente: Una vez habilitado de esta manera, permanece encendido hasta que lo deshabilite, o tal vez hasta que use el spidev y luego lo cierre, o reinicie. Por lo tanto, si su aplicación ha terminado con el hardware que habilitó, es posible que desee desactivarla para ahorrar energía.

Para habilitar bancos GPIO....

enableClockModules () {
    // Enable disabled GPIO module clocks.
    if (mapAddress[(CM_WKUP_GPIO0_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK) {
      mapAddress[(CM_WKUP_GPIO0_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] |= MODULEMODE_ENABLE;
      // Wait for the enable complete.
      while (mapAddress[(CM_WKUP_GPIO0_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK);
    }
    if (mapAddress[(CM_PER_GPIO1_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK) {
      mapAddress[(CM_PER_GPIO1_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] |= MODULEMODE_ENABLE;
      // Wait for the enable complete.
      while (mapAddress[(CM_PER_GPIO1_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK);
    }
    if (mapAddress[(CM_PER_GPIO2_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK) {
      mapAddress[(CM_PER_GPIO2_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] |= MODULEMODE_ENABLE;
      // Wait for the enable complete.
      while (mapAddress[(CM_PER_GPIO2_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK);
    }
    if (mapAddress[(CM_PER_GPIO3_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK) {
      mapAddress[(CM_PER_GPIO3_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] |= MODULEMODE_ENABLE;
      // Wait for the enable complete.
      while (mapAddress[(CM_PER_GPIO3_CLKCTRL - MMAP_OFFSET) / GPIO_REGISTER_SIZE] & IDLEST_MASK);
    }
}

Dónde...

MMAP_OFFSET = 0x44C00000

MMAP_SIZE = 0x481AEFFF-MMAP_OFFSET

GPIO_REGISTER_SIZE = 4

MODULEMODE_ENABLE = 0x02

IDLEST_MASK = (0x03

CM_WKUP = 0x44E00400

CM_PER = 0x44E00000

CM_WKUP_GPIO0_CLKCTRL = (CM_WKUP + 0x8)

CM_PER_GPIO1_CLKCTRL = (CM_PER + 0xAC)

CM_PER_GPIO2_CLKCTRL = (CM_PER + 0xB0)

CM_PER_GPIO3_CLKCTRL = (CM_PER + 0xB4)

He escrito una pequeña biblioteca que quizás podría interesarle. Por el momento solo funciona con pines digitales.

Saludos

REF: madscientist159

// OE: 0 is output, 1 is input
#define GPIO_OE 0x14d
#define GPIO_IN 0x14e
#define GPIO_OUT 0x14f
should be
// OE: 0 is output, 1 is input
#define GPIO_OE 0x4d
#define GPIO_IN 0x4e
#define GPIO_OUT 0x4f

Dirección de desplazamiento int sin signo derivada de la dirección char sin signo

Esta anomalía parece ser un artefacto de decodificación incompleta de direcciones en el chip AM335x. Tiene sentido que 0x4D, 0x4E y 0x4F funcionen como compensaciones desde la dirección base para acceder a estos registros. La aritmética del puntero C / C++ multiplica estas compensaciones por 4 para producir compensaciones verdaderas de 0x134, 0x138 y 0x13C. Sin embargo, se puede acceder a una copia' sombra ' de estos registros a través de 0x14D, 0x14E y 0x14F. He verificado que ambos conjuntos de compensaciones funcionan. No me molesté en probar 0x24D sucesivamente.

Se puede acceder al registro GPIO_CLEARDATAOUT usando el offset 0x64 y al registro GPIO_SETDATAOUT usando el offset 0x65.