CCS/AM5728: GPIO interrupt reduce latency time

Yan Yandoff

Intellectual 330 points

Part Number: AM5728

Tool/software: Code Composer Studio

Hello!

Given:

1. CCS 9.0.1/CCS 9.3, pdk_am57xx_1_0_16

2. JTAG emulator: XDS220 ISO

3. Windows 7

4. AM5728, ARM frequency - 1.5 GHz

5. Pulse generator 100KHz

6. TI-RTOS

There is a code:

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/runtime/Error.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/hal/Hwi.h>

#include <stdio.h>
#include <string.h>

/* TI-RTOS Header files */
#include <ti/drv/gpio/GPIO.h>
#include <ti/drv/gpio/soc/GPIO_soc.h>

#include <ti/board/board.h>
#include <ti/csl/csl_clec.h>
#include <ti/csl/csl_gpio.h>
#include <ti/csl/example/utils/uart_console/inc/uartConfig.h>
#include <ti/csl/soc.h>
#include <ti/csl/hw_types.h>

/* Callback function */
void AppGpioCallbackFxn();


uint32_t gpio_base_address=CSL_MPU_GPIO2_REGS;
uint32_t gpio_pin[2] = {25, 28};

/*
 *  ======== main ========
 */
int main(void)
{
    Board_initCfg boardCfg;

    boardCfg = BOARD_INIT_PINMUX_CONFIG |
            BOARD_INIT_MODULE_CLOCK | //BOARD_INIT_PLL_OPP_HIGH |
            BOARD_INIT_UART_STDIO;

    Board_init(boardCfg);

    /*Enable GPIO clock*/
    HW_WR_REG32(CSL_MPU_L4PER_CM_CORE_REGS+CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_GPIO2_CLKCTRL_REG,0x102);
    while ((HW_RD_REG32(CSL_MPU_L4PER_CM_CORE_REGS+CSL_L4PER_CM_CORE_COMPONENT_CM_L4PER_GPIO2_CLKCTRL_REG) & (0x00030000U)) != 0x0)
    {
        ;
    }

    /*Reset GPIO*/
    GPIOModuleReset(gpio_base_address);

    /*Enable GPIO*/
    GPIOModuleEnable(gpio_base_address);

    GPIOIntTypeSet(gpio_base_address, gpio_pin[0], GPIO_INT_TYPE_RISE_EDGE);

    /*Set pin direction*/
    GPIODirModeSet(gpio_base_address, gpio_pin[0], GPIO_DIR_INPUT); //25 - input
    GPIODirModeSet(gpio_base_address, gpio_pin[1], GPIO_DIR_OUTPUT); //28 - output

    /*Clear interrupt*/
    GPIOPinIntDisable(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);

    GPIOPinIntClear(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);

    /*Enable interrupt*/
    GPIOPinIntEnable(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);


    Hwi_Params hwiParams;
    Hwi_Handle hwiHandle;
    Error_Block eb;

    Hwi_Params_init(&hwiParams);
    Error_init(&eb);

    hwiParams.eventId = 62; //MPU_IRQ_30(ID62)25 (MPU_IRQ_30 (ID62) 25 CTRL_CORE_MPU_IRQ_30_31[8:0] 25 GPIO2_IRQ_1 - AM572x TRM on page 4120)
    hwiParams.arg = 0;
    hwiParams.maskSetting = Hwi_MaskingOption_SELF;
    hwiParams.enableInt = FALSE;
    hwiHandle = Hwi_create(62, AppGpioCallbackFxn, &hwiParams, &eb);
    if (hwiHandle == NULL) {
        System_abort("Hwi create failed\n");
    }
    Hwi_enable();
    Hwi_enableInterrupt(62);


    /* Start BIOS */
    BIOS_start();
    return (0);
}

void AppGpioCallbackFxn()
{
//        GPIOPinWrite(gpio_base_address, gpio_pin[1], GPIO_PIN_HIGH);
    *(Uint32 *)0x48055194 = (Uint32)0x10000000;

    /*Disable interrupt*/
  //  GPIOPinIntDisable(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);

//    GPIOPinIntClear(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);
    *(Uint32 *)0x4805502CU = (Uint32)(0x02000000);

    /*Enable interrupt*/
    //GPIOPinIntEnable(gpio_base_address, GPIO_INT_LINE_1, gpio_pin[0]);

//   GPIOPinWrite(gpio_base_address, gpio_pin[1], GPIO_PIN_LOW);
    *(Uint32 *)0x48055190 = (Uint32)0x10000000;
}

Screenshot of the oscilloscope runtime code in function AppGpioCallbackFxn.

The blue line is the execution time from setting the pin to GPIO_PIN_HIGH and after removing the pin to GPIO_PIN_LOW.

As you can see, the execution time is 300 ns as seen in the screenshot. How can I reduce code execution time to at least 20-50 nanoseconds? Or is this already the limit of execution, what is impossible to further reduce the execution time?

Thanks!

over 5 years ago

0 Yan Yandoff over 5 years ago

Intellectual 330 points

Judging by the link (e2e.ti.com/.../768772), it is impossible to further reduce the toggling time by less than 200 ns on ARM core. How can I make the PRU run on the ARM core? The GPIO2_25 and GPIO2_28 pins are rigidly attached to the P16 connector (GP EVM AM572x) and there is no way to change it.

0 Stanley Liu over 5 years ago in reply to Yan Yandoff

TI__Guru 50045 points

Hi,

PRU-ICSS is another processor in AM5728 SoC.

Please refer to the below link for PRU applicatoin note.

https://www.ti.com/lit/pdf/sprach5

However, to use PRU to control IO pins, you have to connect to one of pr1_pru0/1_gpxx pins.

GPIO2_25 and GPIO2_28 can't be controlled by PRU.

If you have to those GPIO pins, you can only try to optimize ARM code to reduce the latency.

Regards,
Stanley

0 Yan Yandoff over 5 years ago in reply to Stanley Liu

Intellectual 330 points

Hi, Stanley Liu

Stanley Liu said:

If you have to those GPIO pins, you can only try to optimize ARM code to reduce the latency.

For example, how?

About the conclusions on the PRU, I am in the know, collecting information bit by bit on the forum and on the Internet. I would like to solve the problem with the delay on ARM.

0 Stanley Liu over 5 years ago in reply to Yan Yandoff

TI__Guru 50045 points

You can try to use the inline assembly code like the example code in the thread https://e2e.ti.com/support/processors/f/791/t/768772

0 Yan Yandoff over 5 years ago in reply to Stanley Liu

Intellectual 330 points

I never worked with assembler

        __asm ( " ldr r0, =0x48055194" "\n\t"
                " ldr r1, =0x48055190" "\n\t"
                " mov r2, #0x10000000" "\n\t"
                " str r2,[r0]" "\n\t"
                " str r2,[r1]" "\n\t"
                );

Not worked

Uint32 value1 = (*(volatile Uint32 *)0x48055194); //SET
    Uint32 value2 = (*(volatile Uint32 *)0x48055190); //CLEAR
    Uint32 value3;

    __asm (
            //            ".intel_syntax noprefix" "\n\t"
            " mov r0, %1" "\n\t"
            " mov r1, %2" "\n\t"
            " mov r2, #0x10000000" "\n\t"
            " str r2,[r0]" "\n\t"
            " str r2,[r1]" "\n\t"
            :"=r"(value3)
             :"r"(value1), "r"(value2)
    );
    *(Uint32 *)0x4805502C = (Uint32)(0x02000000); //GPIOPinIntClear

No difference, still 300 ns. Any other ideas?

0 Stanley Liu over 5 years ago in reply to Yan Yandoff

TI__Guru 50045 points

I think the latency is mostly from register access so you can't improve that assuming the instruction fetch is not taking much time.

Processors

Processors forum

CCS/AM5728: GPIO interrupt reduce latency time