1 ACCEPTED SOLUTION
Accepted Solutions
Addresses aren't incremented: See below
SPI use: Yes.
- platform.h defines platformSpiTxRx() as spiTxRx() in pltfm_spi.c.
- platformSpiTxRx() is referenced heavily in rfal/Src/st25r3911/st25r3911_com.c
- platformI2CTx (and friends) are NULL definitions in platform.h and are not referenced anywhere else in rfal, common, platform or application code directories.
HW Platform: This is a custom board based on RK3399. It is not a Pi.
Here is (most of) the platform_gpio.h file that has the port to libgpiod.
static void gpio_setFlag( int bits )
{
pthread_mutex_lock( &gpioMutex );
gpioFlags |= bits;
pthread_mutex_unlock( &gpioMutex );
}
static void gpio_unsetFlag( int bits )
{
pthread_mutex_lock( &gpioMutex );
gpioFlags &= ~bits;
pthread_mutex_unlock( &gpioMutex );
}
static int gpio_isFlagSet( int bits )
{
int status = 0;
pthread_mutex_lock( &gpioMutex );
if ( gpioFlags & bits )
status = 1;
pthread_mutex_unlock( &gpioMutex );
return status;
}
ReturnCode gpio_init(void)
{
char *chipname = QSC_RFAL_GPIO_INTERRUPT_CHIPNAME;
unsigned int line_num = QSC_RFAL_GPIO_INTERRUPT_PIN; // GPIO2_A7
int ret;
// printf("GPIOD version: %s\n", gpiod_version_string());
/* Open chip */
intr_chip = gpiod_chip_open_by_name(chipname);
if (!intr_chip)
{
printf("Open chip failed for %s: %s\n", chipname, strerror(errno));
goto error;
}
/* Setup interrupt pin */
intr_line = gpiod_chip_get_line(intr_chip, line_num);
if (!intr_line)
{
printf("Get line failed for GPIO LED pin %d: %s\n", line_num, strerror(errno));
gpiod_chip_close(intr_chip);
intr_chip = NULL;
goto error;
}
ret = gpiod_line_request_rising_edge_events(intr_line, QSC_RFAL_INTR);
if (ret < 0)
{
printf("Request event notification failed for GPIO pin %d: %s\n", line_num, strerror(errno));
gpiod_line_release(intr_line);
gpiod_chip_close(intr_chip);
intr_line = NULL;
intr_chip = NULL;
goto error;
}
ret = pthread_mutex_init(&lock, NULL);
if (ret != 0)
{
printf("Error: mutex init to protect interrupt status is failed\n");
gpiod_line_release(intr_line);
gpiod_chip_close(intr_chip);
intr_line = NULL;
intr_chip = NULL;
goto error;
}
isGPIOInit = 1;
error:
if(isGPIOInit)
return ERR_NONE;
else
return ERR_IO;
}
/*
* Read Interrupt pin state.
* Input arguments were deprecated in STM original code (re: no longer used).
*/
GPIO_PinState gpio_readpin(int port, int pin_no)
{
int value;
/* First check if GPIOInit is done or not */
if (!isGPIOInit) {
printf("GPIO is not initialized\n");
return ERR_WRONG_STATE;
}
pthread_mutex_lock( &gpioMutex );
value = gpiod_line_get_value(intr_line);
pthread_mutex_unlock( &gpioMutex );
if ( value == 1 ) {
return GPIO_PIN_SET;
}
else {
return GPIO_PIN_RESET;
}
}
static void* pthread_func()
{
struct timespec ts = { 0, 200000000 }; // 200ms timeout waiting on events
struct gpiod_line_event event;
int ret = 0;
/* First check if GPIOInit is done or not */
if (!isGPIOInit) {
printf("GPIO is not initialized\n");
return NULL;
}
/* Wait on an event on the specified GPIO pin. */
while( true )
{
if ( !gpio_isFlagSet(GPIO_RUNNING) )
break;
ret = gpiod_line_event_wait(intr_line, &ts);
if (ret < 0)
{
// printf("Error waiting on event notification on interrupt line.\n");
continue;
}
else if (ret == 0)
{
// printf("Timeout waiting on event notification on interrupt line.\n");
continue;
}
ret = gpiod_line_event_read(intr_line, &event);
if (ret < 0)
continue;
if ( event.event_type != GPIOD_LINE_EVENT_RISING_EDGE )
continue;
/* Call RFAL Isr */
// printf("Calling st25r3911Isr\n");
st25r3911Isr();
}
return NULL;
}
ReturnCode interrupt_init(void)
{
struct sched_param params;
int ret;
/* create a pthread for interrupt handler */
gpio_setFlag(GPIO_RUNNING);
ret = pthread_create(&intr_thread, NULL, pthread_func, NULL);
if (ret) {
printf("Error: poll thread creation %d\n", ret);
return ERR_IO;
}
/* Assign highest priority to interrupt thread */
params.sched_priority = sched_get_priority_max(SCHED_FIFO);
ret = pthread_setschedparam(intr_thread, SCHED_FIFO, ¶ms);
if (ret) {
printf("Error: assigning high priority to interrupt thread\n");
return ERR_IO;
}
return ERR_NONE;
}
void interrupt_shutdown(void)
{
int cnt=0;
/* Stop thread and wait for it to exit. */
gpio_unsetFlag( GPIO_RUNNING );
pthread_join(intr_thread, NULL);
/* Now cleanup. */
pthread_mutex_lock( &gpioMutex );
if (intr_line)
{
gpiod_line_release(intr_line);
intr_line = NULL;
}
pthread_mutex_unlock( &gpioMutex );
if (intr_chip)
{
gpiod_chip_close(intr_chip);
intr_chip = NULL;
}
// printf("Interrupt thread has shut down.\n");
}
void gpio_set_pin(int pin_no, int value)
{
struct gpiod_chip *gpio_chip = NULL;
struct gpiod_line *gpio_line;
int chip_num = -1;
int line_num = -1;
char chipname[10];
int ret;
/* Find the chip and line we need */
chip_num = pin_no / 32;
line_num = pin_no % 32 - 1;
sprintf(chipname, "gpiochip%d", chip_num);
/* Open the chip */
gpio_chip = gpiod_chip_open_by_name(chipname);
if (!gpio_chip)
{
printf("Open chip failed for %s: %s\n", chipname, strerror(errno));
return;
}
/* Get the line */
gpio_line = gpiod_chip_get_line(gpio_chip, line_num);
if (!gpio_line)
{
printf("Get line failed for chip %d, GPIO pin %d: %s\n", chip_num, line_num, strerror(errno));
gpiod_chip_close(gpio_chip);
gpio_chip = NULL;
return;
}
/* Request it for output */
ret = gpiod_line_request_output(gpio_line, QSC_RFAL_GPIO_CONSUMER, 0);
if (ret != 0)
{
printf("Setting GPIO chip %d, line %d as output failed: %s\n", chip_num, line_num, strerror(errno));
gpiod_line_release(gpio_line);
gpiod_chip_close(gpio_chip);
gpio_chip = NULL;
return;
}
/* set the value as requested */
ret = gpiod_line_set_value(gpio_line, value);
if (ret < 0)
printf("Failed to %s GPIO chip %d, pin %d.\n", (value==1)?"enable":"disable", chip_num, line_num);
/* Close the chip */
gpiod_line_release(gpio_line);
gpiod_chip_close(gpio_chip);
gpio_chip = NULL;
}
void gpio_set(int port, int pin_no)
{
gpio_set_pin(pin_no, 1);
}
void gpio_clear(int port, int pin_no)
{
gpio_set_pin(pin_no, 0);
}
void pltf_protect_interrupt_status(void)
{
pthread_mutex_lock(&lock);
}
void pltf_unprotect_interrupt_status(void)
{
pthread_mutex_unlock(&lock);
}Addresses aren't incremented: I'm not exactly sure what was meant by this, but maybe the following pics will help. The first two show how a short/long timing interval swapped between gcc7.5 and gcc9.4.
