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 ## Building for Peripheralmanager Android Things
Change src/CMakeLists.txt:146 to the location of libperipheralman.so on your 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} ~~~~~~~~~~~~~{.sh}
cmake -DBUILDSWIG=OFF -DBUILDARCH=PERIPHERALMAN -DANDROID_TOOLCHAIN_NAME=x86-i686 -DCMAKE_TOOLCHAIN_FILE=/opt/android-ndk-r13b/build/cmake/android.toolchain.cmake .. 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 { typedef struct {
/*@{*/ /*@{*/
#if defined(PERIPHERALMAN)
char *name; /**< Peripheral manager's pin name */
#else
char name[MRAA_PIN_NAME_SIZE]; /**< Pin's real world name */ char name[MRAA_PIN_NAME_SIZE]; /**< Pin's real world name */
#endif
mraa_pincapabilities_t capabilities; /**< Pin Capabiliites */ mraa_pincapabilities_t capabilities; /**< Pin Capabiliites */
mraa_pin_t gpio; /**< GPIO structure */ mraa_pin_t gpio; /**< GPIO structure */
mraa_pin_t pwm; /**< PWM structure */ mraa_pin_t pwm; /**< PWM structure */

5
include/peripheralman.h
View File

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

2
src/mraa.c
View File

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

333
src/peripheralman/peripheralman.c
View File

@@ -30,6 +30,155 @@
#include "peripheralman.h" #include "peripheralman.h"
BPeripheralManagerClient *client = NULL; 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_board_t*
mraa_peripheralman_plat_init() mraa_peripheralman_plat_init()
@@ -48,27 +197,26 @@ mraa_peripheralman_plat_init()
return NULL; return NULL;
} }
int gpios_count, i2c_busses_count, spi_busses_count, uart_busses_count; // error checking?
int gpios = BPeripheralManagerClient_listGpio(client, &gpios_count); gpios = BPeripheralManagerClient_listGpio(client, &gpios_count);
int i2c_busses = BPeripheralManagerClient_listI2cBuses(client, &i2c_busses_count); i2c_busses = BPeripheralManagerClient_listI2cBuses(client, &i2c_busses_count);
int spi_busses = BPeripheralManagerClient_listSpiBuses(client, &spi_busses_count); spi_busses = BPeripheralManagerClient_listSpiBuses(client, &spi_busses_count);
int uart_devices = BPeripheralManagerClient_listUartDevices(client, &uart_busses_count); uart_devices = BPeripheralManagerClient_listUartDevices(client, &uart_busses_count);
b->platform_name = "peripheralmanager"; b->platform_name = "peripheralmanager";
// query this from peripheral manager? // query this from peripheral manager?
b->platform_version = "1.0"; b->platform_version = "1.0";
b->gpio_count = 14;
// disable AIO support // disable AIO support
b->aio_count = 0; b->aio_count = 0;
b->adc_supported = 0; b->adc_supported = 0;
// get this from PM b->gpio_count = gpios_count;
b->phy_pin_count = 20; b->phy_pin_count = gpios_count;
b->i2c_bus_count = 1; 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->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)); b->pins = (mraa_pininfo_t*) calloc(b->phy_pin_count, sizeof(mraa_pininfo_t));
if (b->pins == NULL) { if (b->pins == NULL) {
@@ -76,74 +224,12 @@ mraa_peripheralman_plat_init()
return NULL; return NULL;
} }
#if 0 int i = 0;
strncpy(b->pins[0].name, "IO0", 8); for (; i < gpios_count; i++) {
b->pins[0].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 }; b->pins[i].name = gpios[i];
b->pins[0].gpio.pinmap = 0; b->pins[i].capabilities = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 };
strncpy(b->pins[1].name, "IO1", 8); b->pins[i].gpio.pinmap = -1;
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
b->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t)); b->adv_func = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t));
if (b->adv_func == NULL) { if (b->adv_func == NULL) {
@@ -152,38 +238,38 @@ mraa_peripheralman_plat_init()
return NULL; 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 #if 0
b->adv_func->gpio_init_internal_replace = &mraa_firmata_gpio_init_internal_replace; b->adv_func->aio_init_internal_replace = &mraa_pman_aio_init_internal_replace;
b->adv_func->gpio_mode_replace = &mraa_firmata_gpio_mode_replace; b->adv_func->aio_read_replace = &mraa_pman_aio_read;
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_firmata_aio_init_internal_replace; b->adv_func->pwm_init_internal_replace = &mraa_pman_pwm_init_internal_replace;
b->adv_func->aio_read_replace = &mraa_firmata_aio_read; 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->i2c_init_bus_replace = &mraa_pman_i2c_init_bus_replace;
b->adv_func->pwm_write_replace = &mraa_firmata_pwm_write_replace; b->adv_func->i2c_set_frequency_replace = &mraa_pman_i2c_frequency;
b->adv_func->pwm_read_replace = &mraa_firmata_pwm_read_replace; b->adv_func->i2c_address_replace = &mraa_pman_i2c_address;
b->adv_func->pwm_enable_replace = &mraa_firmata_pwm_enable_replace; 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_init_bus_replace = &mraa_firmata_i2c_init_bus_replace; b->adv_func->i2c_read_byte_data_replace = &mraa_pman_i2c_read_byte_data;
b->adv_func->i2c_set_frequency_replace = &mraa_firmata_i2c_frequency; b->adv_func->i2c_read_word_data_replace = &mraa_pman_i2c_read_word_data;
b->adv_func->i2c_address_replace = &mraa_firmata_i2c_address; b->adv_func->i2c_read_bytes_data_replace = &mraa_pman_i2c_read_bytes_data;
b->adv_func->i2c_read_replace = &mraa_firmata_i2c_read; b->adv_func->i2c_write_replace = &mraa_pman_i2c_write;
b->adv_func->i2c_read_byte_replace = &mraa_firmata_i2c_read_byte; b->adv_func->i2c_write_byte_replace = &mraa_pman_i2c_write_byte;
b->adv_func->i2c_read_byte_data_replace = &mraa_firmata_i2c_read_byte_data; b->adv_func->i2c_write_byte_data_replace = &mraa_pman_i2c_write_byte_data;
b->adv_func->i2c_read_word_data_replace = &mraa_firmata_i2c_read_word_data; b->adv_func->i2c_write_word_data_replace = &mraa_pman_i2c_write_word_data;
b->adv_func->i2c_read_bytes_data_replace = &mraa_firmata_i2c_read_bytes_data; b->adv_func->i2c_stop_replace = &mraa_pman_i2c_stop;
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;
#endif #endif
return b; return b;
} }
@@ -195,3 +281,32 @@ mraa_peripheralman_platform()
return MRAA_ANDROID_PERIPHERALMANAGER; 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> * Author: Constantin Musca <constantin.musca@intel.com>
* Brendan Le Foll <brendan.le.foll@intel.com>
* Copyright (c) 2016 Intel Corporation. * Copyright (c) 2016 Intel Corporation.
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
@@ -36,39 +37,22 @@ extern BPeripheralManagerClient *client;
extern char **gpios; extern char **gpios;
extern int gpios_count; extern int gpios_count;
mraa_gpio_context static mraa_result_t
mraa_gpio_init_raw(int pin) 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); rc = BPeripheralManagerClient_openGpio(client, gpios[pin], &dev->bgpio);
if (rc != 0) { if (rc != 0) {
free(dev); syslog(LOG_ERROR, "peripheralmanager: Failed to init gpio");
return NULL; return MRAA_ERROR_INVALID_HANDLE;
} }
dev->pin = pin; dev->pin = pin;
dev->phy_pin = pin;
return dev; return dev;
} }
mraa_result_t static mraa_result_t
mraa_gpio_close(mraa_gpio_context dev) mraa_pman_gpio_close_replace(mraa_gpio_context dev)
{ {
if (dev->bgpio != NULL) { if (dev->bgpio != NULL) {
BGpio_delete(dev->bgpio); BGpio_delete(dev->bgpio);
@@ -78,12 +62,13 @@ mraa_gpio_close(mraa_gpio_context dev)
return MRAA_SUCCESS; return MRAA_SUCCESS;
} }
mraa_result_t static mraa_result_t
mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir) mraa_pman_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
{ {
int rc; int rc;
if (dev->bgpio == NULL) { if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE; return MRAA_ERROR_INVALID_HANDLE;
} }
@@ -100,25 +85,27 @@ mraa_gpio_dir(mraa_gpio_context dev, mraa_gpio_dir_t dir)
break; break;
} }
if (rc != 0) { if (rc != 0) {
syslog(LOG_ERROR, "peripheralman: Failed to switch direction");
return MRAA_ERROR_INVALID_HANDLE; return MRAA_ERROR_INVALID_HANDLE;
} }
return MRAA_SUCCESS; return MRAA_SUCCESS;
} }
mraa_result_t static mraa_result_t
mraa_gpio_read_dir(mraa_gpio_context dev, mraa_gpio_dir_t *dir) 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; return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
} }
mraa_result_t static mraa_result_t
mraa_gpio_write(mraa_gpio_context dev, int val) mraa_pman_gpio_write_replace(mraa_gpio_context dev, int val)
{ {
int rc; int rc;
if (dev->bgpio == NULL) { if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return MRAA_ERROR_INVALID_HANDLE; return MRAA_ERROR_INVALID_HANDLE;
} }
@@ -130,25 +117,27 @@ mraa_gpio_write(mraa_gpio_context dev, int val)
return MRAA_SUCCESS; return MRAA_SUCCESS;
} }
int static int
mraa_gpio_read(mraa_gpio_context dev) mraa_pman_gpio_read_replace(mraa_gpio_context dev)
{ {
int rc, val; int rc, val;
if (dev->bgpio == NULL) { if (dev->bgpio == NULL) {
syslog(LOG_ERROR, "peripheralman: Invalid internal gpio handle");
return -1; return -1;
} }
rc = BGpio_getValue(dev->bgpio, &val); rc = BGpio_getValue(dev->bgpio, &val);
if (rc != 0) { if (rc != 0) {
syslog(LOG_ERROR, "peripheralman: Unable to read internal gpio")
return -1; return -1;
} }
return val; return val;
} }
mraa_result_t static mraa_result_t
mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode) mraa_pman_gpio_edge_mode_replace(mraa_gpio_context dev, mraa_gpio_edge_t mode)
{ {
int rc; int rc;
@@ -177,46 +166,15 @@ mraa_gpio_edge_mode(mraa_gpio_context dev, mraa_gpio_edge_t mode)
return MRAA_SUCCESS; return MRAA_SUCCESS;
}; };
mraa_result_t static mraa_result_t
mraa_gpio_isr(mraa_gpio_context dev, mraa_gpio_edge_t edge, void (*fptr)(void*), void* args) 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; return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
} }
mraa_result_t static mraa_result_t
mraa_gpio_isr_exit(mraa_gpio_context dev) mraa_pman_gpio_mode_replace(mraa_gpio_context dev, mraa_gpio_mode_t mode)
{ {
return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED; 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;
}