7. PRU-ICSS Firmware¶

7.6.1. Introduction¶

7.6.2. Firmware Organization¶

7.6.3. Firmware Build Instruction¶

7.6.4. Supported EVMs¶

Supported EVMs and pin configurations for these EVMs are listed below. See the design document in <PDK>/packages/ti/drv/spi/docs/ for more information.

bbbAM335x

idkAM437x

7.6.5. eSPI Applications¶

We have included a simple example test application which handles PUT_IORD_SHORT, PUT_IOWR_SHORT, PUT_MEMRD32_SHORT, and PUT_MEMWR32_SHORT packets with expected address/data values. This can be used as a starting point to build your own applications, along with the following: - eSPI uses the MCSPI API

• Open as MCSPI instance 2

• HW interrupts must be enabled

  • i.e. HwiP_enableInterrupt(espi_cfg.intNum)

• MCSPI_transfer() is blocking and takes a SPI_Transaction parameter which is used as follows:

  • RX Transfer: - transaction.rxBuf = <some pre-allocated buffer> - transaction.txBuf = Null - transaction.count = max packet size
  • TX Transfer: - transaction.rxBuf = Null - transaction.txBuf = <some pre-allocated buffer> - transaction.count = <size of packet>

• The application must parse the full eSPI packet, and must respond with the full proper eSPI packet (the RSP code and CRC will be taken care of by the firmware)

example-application

/* Refer to eSPI FW Example for details */

Board_init(boardCfg);

...

/* Initialize the ESPI fw configuration */
ESPI_socInitFwCfg();

/* Get the default ESPI init configurations */
ESPI_socGetFwCfg(ESPI_INSTANCE, &espi_cfg);

/* Modify the default eSPI configurations if necessary */

/* Set the default ESPI init configurations */
  ESPI_socSetFwCfg(ESPI_INSTANCE, &espi_cfg);

/* Set GPIO pin configurations */
GPIO_setConfig(ESPI_GPIO_PIN_RESET, GPIO_DEVICE_CONFIG(espi_cfg.resetPin.port,
                                                espi_cfg.resetPin.pinNum) |
             GPIO_CFG_IN_INT_RISING | GPIO_CFG_INPUT);

/* Initialize GPIO */
GPIO_init();

/* Initialize the MCSPI paramters */
MCSPI_Params_init(&mcspiParams);

/* Init SPI driver */
MCSPI_init();

/* Enable interrupts (necessary for  */
HwiP_enableInterrupt(espi_cfg.intNum);

/* Grab ESPI handle from SoC config list */
fwHandle = (MCSPI_Handle)MCSPI_open(ESPI_INSTANCE, 0, &mcspiParams);

...

/* Read ESPI Packet */
transaction.txBuf = NULL; /* indicates we want RX */
transaction.rxBuf = (uint8_t*) rxBuf;
transaction.count = ESPI_PACKET_MAX_SIZE;
retVal = MCSPI_transfer(fwHandle, &transaction);  /* blocking */

...

/* Prepare TX response */
transaction.txBuf = (uint8_t*) txBuf;
transaction.rxBuf = NULL; /* indicates we want TX */
transaction.count = ESPI_PACKET_MAX_SIZE;

...

/* Put response in TX queue */
retVal = MCSPI_transfer(fwHandle, &transaction);

...

Examples List

Refer to the Release Notes for details concerning eSPI support across different EVMs.

Firmware Design Guide

NOTE: For normal use of eSPI FW, there is no need to refer to the design guide. This document can be cosulted in case of interest in details of internal firmware operation, or a desire to modify the firmware.

7.7.1. Introduction¶

7.7.2. FIRMWARE FEATURES¶

The following UART specifications are supported by the PRU UART firmware:

• Up to 3 UARTs are supported per PRU with the following configuration options

  • Baud rate: common baud rates up to 115200
  • Bits per transfer: 5-9 bit characters
  • Number of stop bits: 1, 1.5, 2
  • Parity: even, odd, none
  • Flow control: HW, none (SW flow control currently unsupported)
  • Full-duplex communication

• Each UART can simultaneously support different configurations

  • UART0 can have a different baud rate, number of stop bits, etc. when compared to UART1 or UART2 in the same PRU

• The firmware is self-contained in a single PRU

  • The firmware does not use shared resources within an ICSS including IEP Timer and Scratchpad
  • In case 3 or less UART instances are required, only one PRU core is required for the UART firmware

The table below shows a comparison of the features supported by the UART firmware with those available on hardware IP.

7.7.3. Firmware Organization¶

7.7.4. Firmware Build Instructions¶

7.7.5. Supported EVMs¶

Supported EVMs and pin configurations for these EVMs are listed below. See the design document in <PDK>/packages/ti/drv/uart/docs/ for more information.

bbbAM335x

7.7.6. UART Firmware Example & Test¶

Example are test applications are available in the package for reference purpose and starting point.

The example application uses the UART stdio API to repeatedly read characters transmitted from a PC UART. The acquired characters are then written (echoed) back to the PC UART.

The test applications are more complex than the example application, and perform many more types of UART transfers than the example application. The test applications performs transfers using UART software IP (implemented in PRU firmware) and hardware IPs with different combinations of UART settings. Both the UART and UART stdio APIs are exercised (note the UART software and hardware IPs use the same UART-LLD API). The test applications are further described in the Firmware Design Guide.

Sample code for UART write & read:

/* Refer to UART FW example & tests for details */
...

/* Initialize the UART FW configuration */
UART_socInitFwCfg();

Board_init(boardCfg);
...

UART_init();

/* Get the default UART init configuration */
UART_socGetFwCfg(uartInst, &uart_cfg);
/* Modify the default UART configurations if necessary */
/* Set the default UART init configurations */
UART_socSetFwCfg(uartInst, &uart_cfg);
...

UART_Params_init(&uartParams);
uartParams.readCallback = UART_callback;
uartParams.readMode = UART_MODE_CALLBACK;
uartParams.writeCallback = UART_callback;
uartParams.writeMode = UART_MODE_CALLBACK;
uartParams.parityType = UART_PAR_NONE;
handle = UART_open(uartInst, &uartParams);
...

/* Initiate UART write */
UART_transactionInit(&wrCbTransaction);
wrCbTransaction.buf = (void *)wrBuff;
wrCbTransaction.count = sizeof(wrBuffer)/2;
if (UART_write2(handle, &wrCbTransaction) == UART_ERROR) {
    /* UART write failed */
}
...

/* Initiate UART read */
UART_transactionInit(&rdCbTransaction);
rdCbTransaction.buf = (void *)rdBuff;
rdCbTransaction.count = sizeof(rdBuffer)/2;
if (UART_read2(handle, &callbackTransaction) == UART_ERROR) {
    /* UART read failed */
}

List of Examples & Tests

Refer to the Release Notes for details concerning UART support across different EVMs.

Firmware Design Guide

NOTE: Design document includes details for internal firmware implementation and can be used in case of modification required for firmware.