pru.c

/** \file
 * Userspace interface to the BeagleBone PRU.
 *
 * Wraps the prussdrv library in a sane interface.
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <inttypes.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include "am335x/app_loader/include/prussdrv.h"
#include "am335x/app_loader/include/pruss_intc_mapping.h"
#include "pru.h"


static unsigned int
proc_read(
	const char * const fname
)
{
	FILE * const f = fopen(fname, "r");
	if (!f)
		die("%s: Unable to open: %s", fname, strerror(errno));
	unsigned int x;
	fscanf(f, "%x", &x);
	fclose(f);
	return x;
}


pru_t *
pru_init(
	const unsigned short pru_num
)
{
	prussdrv_init();

	int ret = prussdrv_open(PRU_EVTOUT_0);
	if (ret)
		die("prussdrv_open open failed\n");

	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	prussdrv_pruintc_init(&pruss_intc_initdata);

	void * pru_data_mem;
	prussdrv_map_prumem(
		pru_num == 0 ? PRUSS0_PRU0_DATARAM : PRUSS0_PRU1_DATARAM,
		&pru_data_mem
	);

	const int mem_fd = open("/dev/mem", O_RDWR);
	if (mem_fd < 0)
		die("Failed to open /dev/mem: %s\n", strerror(errno));

	const uintptr_t ddr_addr = proc_read("/sys/class/uio/uio0/maps/map1/addr");
	const uintptr_t ddr_size = proc_read("/sys/class/uio/uio0/maps/map1/size");

	const uintptr_t ddr_start = 0x10000000;
	const uintptr_t ddr_offset = ddr_addr - ddr_start;
	const size_t ddr_filelen = ddr_size + ddr_start;

	/* map the memory */
	uint8_t * const ddr_mem = mmap(
		0,
		ddr_filelen,
		PROT_WRITE | PROT_READ,
		MAP_SHARED,
		mem_fd,
		ddr_offset
	);
	if (ddr_mem == MAP_FAILED)
		die("Failed to mmap offset %"PRIxPTR" @ %zu bytes: %s\n",
			ddr_offset,
			ddr_filelen,
			strerror(errno)
		);

	close(mem_fd);

	pru_t * const pru = calloc(1, sizeof(*pru));
	if (!pru)
		die("calloc failed: %s", strerror(errno));

	*pru = (pru_t) {
		.pru_num	= pru_num,
		.data_ram	= pru_data_mem,
		.data_ram_size	= 8192, // how to determine?
		.ddr_addr	= ddr_addr,
		.ddr		= (void*)(ddr_mem + ddr_start),
		.ddr_size	= ddr_size,
	};
    
	printf("%s: PRU %d: data %p @ %zu bytes,  DMA %p / %"PRIxPTR" @ %zu bytes\n",
		__func__,
		pru_num,
		pru->data_ram,
		pru->data_ram_size,
		pru->ddr,
		pru->ddr_addr,
		pru->ddr_size
	);

	return pru;
}


void
pru_exec(
	pru_t * const pru,
	const char * const program
)
{
	char * program_unconst = (char*)(uintptr_t) program;
	if (prussdrv_exec_program(pru->pru_num, program_unconst) < 0)
		die("%s failed", program);
}

void
pru_wait_interrupt() {
	prussdrv_pru_wait_event(PRU_EVTOUT_0);
	// Handle event
	prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
	prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT);
}

void
pru_close(
	pru_t * const pru
)
{
	// \todo unmap memory
	pru_wait_interrupt();
	prussdrv_pru_disable(pru->pru_num); 
	prussdrv_exit();
}


int
pru_gpio(
	const unsigned gpio,
	const unsigned pin,
	const unsigned direction,
	const unsigned initial_value
)
{
	const unsigned pin_num = gpio * 32 + pin;
	const char * export_name = "/sys/class/gpio/export";
	FILE * const export = fopen(export_name, "w");
	if (!export)
		die("%s: Unable to open? %s\n",
			export_name,
			strerror(errno)
		);

	fprintf(export, "%d\n", pin_num);
	fclose(export);

	char value_name[64];
	snprintf(value_name, sizeof(value_name),
		"/sys/class/gpio/gpio%u/value",
		pin_num
	);

	FILE * const value = fopen(value_name, "w");
	if (!value)
		die("%s: Unable to open? %s\n",
			value_name,
			strerror(errno)
		);

	fprintf(value, "%d\n", initial_value);
	fclose(value);

	char dir_name[64];
	snprintf(dir_name, sizeof(dir_name),
		"/sys/class/gpio/gpio%u/direction",
		pin_num
	);

	FILE * const dir = fopen(dir_name, "w");
	if (!dir)
		die("%s: Unable to open? %s\n",
			dir_name,
			strerror(errno)
		);

	fprintf(dir, "%s\n", direction ? "out" : "in");
	fclose(dir);

	return 0;
}