Raspberries/mraa
Private
Public Access
2
0
Fork 0
Code Activity

android-things: Possibly working gpio

Browse Source 
Signed-off-by: Brendan Le Foll <brendan.le.foll@intel.com>
This commit is contained in:
Brendan Le Foll
2016-12-28 13:46:01 +00:00
committed by Noel Eck
parent 533517a864
commit 60ca81a3e1
6 changed files with 271 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
docs/building.md
View File

@@ -188,8 +188,17 @@ cmake -DRPM=ON -DCMAKE_INSTALL_PREFIX=/usr ..
## Building for Peripheralmanager Android Things
Change src/CMakeLists.txt:146 to the location of libperipheralman.so on your
machine or have it in your Android NDK
machine or have it in your Android NDK. Switch the toolchain file var to point
to where your Android NDK is (here android-ndk is in /opt).
NDK r13b
~~~~~~~~~~~~~{.sh}
cmake -DBUILDSWIG=OFF -DBUILDARCH=PERIPHERALMAN -DANDROID_TOOLCHAIN_NAME=x86-i686 -DCMAKE_TOOLCHAIN_FILE=/opt/android-ndk-r13b/build/cmake/android.toolchain.cmake ..
~~~~~~~~~~~~~
NDK r14-beta1
~~~~~~~~~~~~~{.sh}
cmake -DBUILDSWIG=OFF -DBUILDARCH=PERIPHERALMAN -DANDROID_TOOLCHAIN_NAME=x86-i686 -DCMAKE_TOOLCHAIN_FILE=/opt/android-ndk-r14-beta1/build/cmake/android.toolchain.cmake ..
~~~~~~~~~~~~~
For some reason this is broken on cmake 3.7+ Use cmake 3.6+ for the time being

4
include/mraa_internal_types.h
View File

@@ -314,7 +314,11 @@ typedef struct {
*/
typedef struct {
/*@{*/
#if defined(PERIPHERALMAN)
char *name; /**< Peripheral manager's pin name */
#else
char name[MRAA_PIN_NAME_SIZE]; /**< Pin's real world name */
#endif
mraa_pincapabilities_t capabilities; /**< Pin Capabiliites */
mraa_pin_t gpio; /**< GPIO structure */
mraa_pin_t pwm; /**< PWM structure */

5
include/peripheralman.h
View File

@@ -30,8 +30,9 @@ extern "C" {
#include "mraa_internal.h"
mraa_platform_t
mraa_peripheralman_platform();
mraa_platform_t mraa_peripheralman_platform();
void pman_mraa_deinit();
#ifdef __cplusplus
}

2
src/mraa.c
View File

@@ -286,6 +286,8 @@ mraa_deinit()
free(plat_iio);
plat_iio = NULL;
}
#else
pman_mraa_deinit();
#endif
closelog();
}

333
src/peripheralman/peripheralman.c
View File

@@ -30,6 +30,155 @@
#include "peripheralman.h"
BPeripheralManagerClient *client = NULL;
char **gpios = NULL;
int gpios_count = 0;
char **i2c_busses = NULL;
int i2c_busses_count = 0;
char **spi_busses = NULL;
int spi_busses_count = 0;
char **uart_devices = NULL;
int uart_busses_count = 0;
static mraa_result_t
mraa_pman_gpio_init_internal_replace(mraa_gpio_context dev, int pin)
{
int rc = BPeripheralManagerClient_openGpio(client, gpios[pin], &dev->bgpio);
if (rc != 0) {
syslog(LOG_ERR, "peripheralmanager: Failed to init gpio");
return MRAA_ERROR_INVALID_HANDLE;
}
dev->pin = pin;
dev->phy_pin = pin;
return MRAA_SUCCESS;
}
static mraa_result_t
mraa_pman_gpio_close_replace(mraa_gpio_context dev)
{
if (dev->bgpio != NULL) {
BGpio_delete(dev->bgpio);
}
free(dev);
return MRAA_SUCCESS;
}
static mraa_result_t
mraa_pman_gpio_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t dir)
{
int rc;
if (dev->bgpio == NULL) {
syslog(LOG_ERR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE;
}
switch (dir) {
case MRAA_GPIO_IN:
rc = BGpio_setDirection(dev->bgpio, DIRECTION_IN);
break;
case MRAA_GPIO_OUT:
case MRAA_GPIO_OUT_HIGH:
rc = BGpio_setDirection(dev->bgpio, DIRECTION_OUT_INITIALLY_HIGH);
break;
case MRAA_GPIO_OUT_LOW:
rc = BGpio_setDirection(dev->bgpio, DIRECTION_OUT_INITIALLY_LOW);
break;
}
if (rc != 0) {
syslog(LOG_ERR, "peripheralman: Failed to switch direction");
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
}
static mraa_result_t
mraa_pman_gpio_read_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t *dir)
{
syslog(LOG_WARNING, "peripheralman: mraa_gpio_read_dir() dunction not implemented on this backend");
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
static mraa_result_t
mraa_pman_gpio_write_replace(mraa_gpio_context dev, int val)
{
int rc;
if (dev->bgpio == NULL) {
syslog(LOG_ERR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE;
}
rc = BGpio_setValue(dev->bgpio, val);
if (rc != 0) {
return MRAA_ERROR_INVALID_RESOURCE;
}
return MRAA_SUCCESS;
}
static int
mraa_pman_gpio_read_replace(mraa_gpio_context dev)
{
int rc, val;
if (dev->bgpio == NULL) {
syslog(LOG_ERR, "peripheralman: Invalid internal gpio handle");
return -1;
}
rc = BGpio_getValue(dev->bgpio, &val);
if (rc != 0) {
syslog(LOG_ERR, "peripheralman: Unable to read internal gpio");
return -1;
}
return val;
}
static mraa_result_t
mraa_pman_gpio_edge_mode_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode)
{
int rc;
if (dev->bgpio == NULL) {
return MRAA_ERROR_INVALID_HANDLE;
}
switch (mode) {
case MRAA_GPIO_EDGE_BOTH:
rc = BGpio_setEdgeTriggerType(dev->bgpio, BOTH_EDGE);
break;
case MRAA_GPIO_EDGE_FALLING:
rc = BGpio_setEdgeTriggerType(dev->bgpio, FALLING_EDGE);
break;
case MRAA_GPIO_EDGE_RISING:
rc = BGpio_setEdgeTriggerType(dev->bgpio, RISING_EDGE);
break;
case MRAA_GPIO_EDGE_NONE:
rc = BGpio_setEdgeTriggerType(dev->bgpio, NONE_EDGE);
break;
}
if (rc != 0) {
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
};
static mraa_result_t
mraa_pman_gpio_isr_replace(mraa_gpio_context dev, mraa_gpio_edge_t edge, void (*fptr)(void*), void* args)
{
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
static mraa_result_t
mraa_pman_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode)
{
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_board_t*
mraa_peripheralman_plat_init()
@@ -48,27 +197,26 @@ mraa_peripheralman_plat_init()
return NULL;
}
int gpios_count, i2c_busses_count, spi_busses_count, uart_busses_count;
int gpios = BPeripheralManagerClient_listGpio(client, &gpios_count);
int i2c_busses = BPeripheralManagerClient_listI2cBuses(client, &i2c_busses_count);
int spi_busses = BPeripheralManagerClient_listSpiBuses(client, &spi_busses_count);
int uart_devices = BPeripheralManagerClient_listUartDevices(client, &uart_busses_count);
// error checking?
gpios = BPeripheralManagerClient_listGpio(client, &gpios_count);
i2c_busses = BPeripheralManagerClient_listI2cBuses(client, &i2c_busses_count);
spi_busses = BPeripheralManagerClient_listSpiBuses(client, &spi_busses_count);
uart_devices = BPeripheralManagerClient_listUartDevices(client, &uart_busses_count);
b->platform_name = "peripheralmanager";
// query this from peripheral manager?
b->platform_version = "1.0";
b->gpio_count = 14;
// disable AIO support
b->aio_count = 0;
b->adc_supported = 0;
// get this from PM
b->phy_pin_count = 20;
b->i2c_bus_count = 1;
b->gpio_count = gpios_count;
b->phy_pin_count = gpios_count;
b->i2c_bus_count = i2c_busses_count;
b->spi_bus_count = spi_busses_count;
b->uart_dev_count = uart_busses_count;
b->def_i2c_bus = 0;
b->i2c_bus[0].bus_id = 0;
b->pwm_min_period = 2048;
b->pwm_max_period = 2048;
b->pins = (mraa_pininfo_t*) calloc(b->phy_pin_count, sizeof(mraa_pininfo_t));
if (b->pins == NULL) {
@@ -76,74 +224,12 @@ mraa_peripheralman_plat_init()
return NULL;
}
#if 0
strncpy(b->pins[0].name, "IO0", 8);
b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[0].gpio.pinmap = 0;
strncpy(b->pins[1].name, "IO1", 8);
b->pins[1].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[1].gpio.pinmap = 1;
strncpy(b->pins[2].name, "IO2", 8);
b->pins[2].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[2].gpio.pinmap = 2;
strncpy(b->pins[3].name, "IO3", 8);
b->pins[3].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
b->pins[3].gpio.pinmap = 3;
strncpy(b->pins[4].name, "IO4", 8);
b->pins[4].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[4].gpio.pinmap = 4;
strncpy(b->pins[5].name, "IO5", 8);
b->pins[5].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
b->pins[5].gpio.pinmap = 5;
strncpy(b->pins[6].name, "IO6", 8);
b->pins[6].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
b->pins[6].gpio.pinmap = 6;
strncpy(b->pins[7].name, "IO7", 8);
b->pins[7].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[7].gpio.pinmap = 7;
strncpy(b->pins[8].name, "IO8", 8);
b->pins[8].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[8].gpio.pinmap = 8;
strncpy(b->pins[9].name, "IO9", 8);
b->pins[9].capabilities = (mraa_pincapabilities_t){ 1, 1, 1, 0, 0, 0, 0, 0 };
b->pins[9].gpio.pinmap = 9;
strncpy(b->pins[10].name, "IO10", 8);
b->pins[10].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[10].gpio.pinmap = 10;
strncpy(b->pins[11].name, "IO11", 8);
b->pins[11].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[11].gpio.pinmap = 11;
strncpy(b->pins[12].name, "IO12", 8);
b->pins[12].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[12].gpio.pinmap = 12;
strncpy(b->pins[13].name, "IO13", 8);
b->pins[13].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[13].gpio.pinmap = 13;
strncpy(b->pins[10].name, "A0", 8);
b->pins[14].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[14].gpio.pinmap = 14;
b->pins[14].aio.pinmap = 14;
strncpy(b->pins[11].name, "A1", 8);
b->pins[15].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[15].gpio.pinmap = 15;
b->pins[15].aio.pinmap = 15;
strncpy(b->pins[12].name, "A2", 8);
b->pins[16].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[16].gpio.pinmap = 16;
b->pins[16].aio.pinmap = 16;
strncpy(b->pins[13].name, "A3", 8);
b->pins[17].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[17].gpio.pinmap = 17;
b->pins[17].aio.pinmap = 17;
strncpy(b->pins[13].name, "A4", 8);
b->pins[18].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[18].gpio.pinmap = 18;
b->pins[18].aio.pinmap = 18;
strncpy(b->pins[13].name, "A5", 8);
b->pins[19].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 1, 0 };
b->pins[19].gpio.pinmap = 19;
b->pins[19].aio.pinmap = 19;
#endif
int i = 0;
for (; i < gpios_count; i++) {
b->pins[i].name = gpios[i];
b->pins[i].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
b->pins[i].gpio.pinmap = -1;
}
b->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t));
if (b->adv_func == NULL) {
@@ -152,38 +238,38 @@ mraa_peripheralman_plat_init()
return NULL;
}
b->adv_func->gpio_init_internal_replace = &mraa_pman_gpio_init_internal_replace;
b->adv_func->gpio_close_replace = &mraa_pman_gpio_close_replace;
b->adv_func->gpio_dir_replace = &mraa_pman_gpio_dir_replace;
b->adv_func->gpio_read_dir_replace = &mraa_pman_gpio_read_dir_replace;
b->adv_func->gpio_write_replace = &mraa_pman_gpio_write_replace;
b->adv_func->gpio_read_replace = &mraa_pman_gpio_read_replace;
b->adv_func->gpio_edge_mode_replace = &mraa_pman_gpio_edge_mode_replace;
b->adv_func->gpio_mode_replace = &mraa_pman_gpio_mode_replace;
b->adv_func->gpio_isr_replace = &mraa_pman_gpio_isr_replace;
#if 0
b->adv_func->gpio_init_internal_replace = &mraa_firmata_gpio_init_internal_replace;
b->adv_func->gpio_mode_replace = &mraa_firmata_gpio_mode_replace;
b->adv_func->gpio_dir_replace = &mraa_firmata_gpio_dir_replace;
b->adv_func->gpio_edge_mode_replace = &mraa_firmata_gpio_edge_mode_replace;
b->adv_func->gpio_interrupt_handler_init_replace = &mraa_firmata_gpio_interrupt_handler_init_replace;
b->adv_func->gpio_wait_interrupt_replace = &mraa_firmata_gpio_wait_interrupt_replace;
b->adv_func->gpio_read_replace = &mraa_firmata_gpio_read_replace;
b->adv_func->gpio_write_replace = &mraa_firmata_gpio_write_replace;
b->adv_func->gpio_close_replace = &mraa_firmata_gpio_close_replace;
b->adv_func->aio_init_internal_replace = &mraa_pman_aio_init_internal_replace;
b->adv_func->aio_read_replace = &mraa_pman_aio_read;
b->adv_func->aio_init_internal_replace = &mraa_firmata_aio_init_internal_replace;
b->adv_func->aio_read_replace = &mraa_firmata_aio_read;
b->adv_func->pwm_init_internal_replace = &mraa_pman_pwm_init_internal_replace;
b->adv_func->pwm_write_replace = &mraa_pman_pwm_write_replace;
b->adv_func->pwm_read_replace = &mraa_pman_pwm_read_replace;
b->adv_func->pwm_enable_replace = &mraa_pman_pwm_enable_replace;
b->adv_func->pwm_init_internal_replace = &mraa_firmata_pwm_init_internal_replace;
b->adv_func->pwm_write_replace = &mraa_firmata_pwm_write_replace;
b->adv_func->pwm_read_replace = &mraa_firmata_pwm_read_replace;
b->adv_func->pwm_enable_replace = &mraa_firmata_pwm_enable_replace;
b->adv_func->i2c_init_bus_replace = &mraa_firmata_i2c_init_bus_replace;
b->adv_func->i2c_set_frequency_replace = &mraa_firmata_i2c_frequency;
b->adv_func->i2c_address_replace = &mraa_firmata_i2c_address;
b->adv_func->i2c_read_replace = &mraa_firmata_i2c_read;
b->adv_func->i2c_read_byte_replace = &mraa_firmata_i2c_read_byte;
b->adv_func->i2c_read_byte_data_replace = &mraa_firmata_i2c_read_byte_data;
b->adv_func->i2c_read_word_data_replace = &mraa_firmata_i2c_read_word_data;
b->adv_func->i2c_read_bytes_data_replace = &mraa_firmata_i2c_read_bytes_data;
b->adv_func->i2c_write_replace = &mraa_firmata_i2c_write;
b->adv_func->i2c_write_byte_replace = &mraa_firmata_i2c_write_byte;
b->adv_func->i2c_write_byte_data_replace = &mraa_firmata_i2c_write_byte_data;
b->adv_func->i2c_write_word_data_replace = &mraa_firmata_i2c_write_word_data;
b->adv_func->i2c_stop_replace = &mraa_firmata_i2c_stop;
b->adv_func->i2c_init_bus_replace = &mraa_pman_i2c_init_bus_replace;
b->adv_func->i2c_set_frequency_replace = &mraa_pman_i2c_frequency;
b->adv_func->i2c_address_replace = &mraa_pman_i2c_address;
b->adv_func->i2c_read_replace = &mraa_pman_i2c_read;
b->adv_func->i2c_read_byte_replace = &mraa_pman_i2c_read_byte;
b->adv_func->i2c_read_byte_data_replace = &mraa_pman_i2c_read_byte_data;
b->adv_func->i2c_read_word_data_replace = &mraa_pman_i2c_read_word_data;
b->adv_func->i2c_read_bytes_data_replace = &mraa_pman_i2c_read_bytes_data;
b->adv_func->i2c_write_replace = &mraa_pman_i2c_write;
b->adv_func->i2c_write_byte_replace = &mraa_pman_i2c_write_byte;
b->adv_func->i2c_write_byte_data_replace = &mraa_pman_i2c_write_byte_data;
b->adv_func->i2c_write_word_data_replace = &mraa_pman_i2c_write_word_data;
b->adv_func->i2c_stop_replace = &mraa_pman_i2c_stop;
#endif
return b;
}
@@ -195,3 +281,32 @@ mraa_peripheralman_platform()
return MRAA_ANDROID_PERIPHERALMANAGER;
}
static void
free_resources(char ***resources, int count)
{
int i;
if (*resources != NULL) {
for(i = 0; i < count; i++) {
free((*resources)[i]);
}
free(*resources);
}
*resources = NULL;
}
void
pman_mraa_deinit()
{
free_resources(&uart_devices, uart_busses_count);
free_resources(&spi_busses, spi_busses_count);
free_resources(&i2c_busses, i2c_busses_count);
free_resources(&gpios, gpios_count);
if (client != NULL) {
BPeripheralManagerClient_delete(client);
client = NULL;
}
}

98
src/peripheralman/peripheralman_gpio.c
View File

@@ -1,5 +1,6 @@
/*
* Author: Constantin Musca <constantin.musca@intel.com>
* Brendan Le Foll <brendan.le.foll@intel.com>
* Copyright (c) 2016 Intel Corporation.
*
* Permission is hereby granted, free of charge, to any person obtaining
@@ -36,39 +37,22 @@ extern BPeripheralManagerClient *client;
extern char **gpios;
extern int gpios_count;
mraa_gpio_context
mraa_gpio_init_raw(int pin)
static mraa_result_t
mraa_pman_gpio_init_internal_replace(mraa_gpio_context dev, int pin)
{
return NULL;
}
mraa_gpio_context
mraa_gpio_init(int pin)
{
mraa_gpio_context dev;
int rc;
if (pin > gpios_count) {
// invalid pin number specified
return NULL;
}
if ((dev = (mraa_gpio_context)calloc(sizeof(struct _gpio), 1)) == NULL) {
return NULL;
}
rc = BPeripheralManagerClient_openGpio(client, gpios[pin], &dev->bgpio);
if (rc != 0) {
free(dev);
return NULL;
syslog(LOG_ERROR, "peripheralmanager: Failed to init gpio");
return MRAA_ERROR_INVALID_HANDLE;
}
dev->pin = pin;
dev->phy_pin = pin;
return dev;
}
mraa_result_t
mraa_gpio_close(mraa_gpio_context dev)
static mraa_result_t
mraa_pman_gpio_close_replace(mraa_gpio_context dev)
{
if (dev->bgpio != NULL) {
BGpio_delete(dev->bgpio);
@@ -78,12 +62,13 @@ mraa_gpio_close(mraa_gpio_context dev)
return MRAA_SUCCESS;
}
mraa_result_t
mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
static mraa_result_t
mraa_pman_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
{
int rc;
if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE;
}
@@ -100,25 +85,27 @@ mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
break;
}
if (rc != 0) {
syslog(LOG_ERROR, "peripheralman: Failed to switch direction");
return MRAA_ERROR_INVALID_HANDLE;
}
return MRAA_SUCCESS;
}
mraa_result_t
mraa_gpio_read_dir(mraa_gpio_context dev, mraa_gpio_dir_t *dir)
static mraa_result_t
mraa_pman_gpio_read_dir_replace(mraa_gpio_context dev, mraa_gpio_dir_t *dir)
{
syslog(LOG_WARNING, "gpio mraa: function not implemented in PMRAA\n");
syslog(LOG_WARNING, "peripheralman: mraa_gpio_read_dir() dunction not implemented on this backend");
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_result_t
mraa_gpio_write(mraa_gpio_context dev, int val)
static mraa_result_t
mraa_pman_gpio_write_replace(mraa_gpio_context dev, int val)
{
int rc;
if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE;
}
@@ -130,25 +117,27 @@ mraa_gpio_write(mraa_gpio_context dev, int val)
return MRAA_SUCCESS;
}
int
mraa_gpio_read(mraa_gpio_context dev)
static int
mraa_pman_gpio_read_replace(mraa_gpio_context dev)
{
int rc, val;
if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return -1;
}
rc = BGpio_getValue(dev->bgpio, &val);
if (rc != 0) {
syslog(LOG_ERROR, "peripheralman: Unable to read internal gpio")
return -1;
}
return val;
}
mraa_result_t
mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
static mraa_result_t
mraa_pman_gpio_edge_mode_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode)
{
int rc;
@@ -177,46 +166,15 @@ mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
return MRAA_SUCCESS;
};
mraa_result_t
mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t edge, void (*fptr)(void*), void* args)
static mraa_result_t
mraa_pman_gpio_isr_replace(mraa_gpio_context dev, mraa_gpio_edge_t edge, void (*fptr)(void*), void* args)
{
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_result_t
mraa_gpio_isr_exit(mraa_gpio_context dev)
static mraa_result_t
mraa_pman_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode)
{
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_result_t
mraa_gpio_owner(mraa_gpio_context dev, mraa_boolean_t own)
{
syslog(LOG_WARNING, "gpio mraa: function not implemented in PMRAA");
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_result_t
mraa_gpio_mode(mraa_gpio_context dev, mraa_gpio_mode_t mode)
{
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
mraa_result_t
mraa_gpio_use_mmaped(mraa_gpio_context dev, mraa_boolean_t mmap_en)
{
syslog(LOG_WARNING, "gpio mraa: function not implemented in PMRAA");
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
}
int
mraa_gpio_get_pin(mraa_gpio_context dev)
{
return dev->pin;
}
int
mraa_gpio_get_pin_raw(mraa_gpio_context dev)
{
syslog(LOG_WARNING, "mraa: function not implemented in PMRAA");
return -1;
}