topic Re: Dynamic configuration in sja1110 in S32G

Dynamic configuration in sja1110

Atkinson — Wed, 02 Jul 2025 08:37:53 GMT

Hi,

I would like to configure l2 lookup table dynamically how can I configure it ?

Without using ECT tool how can I configure the l2 lookup table ?

Any examples?

Regards

Atkinson

Re: Dynamic configuration in sja1110

PavelL — Thu, 03 Jul 2025 10:01:23 GMT

Hello @Atkinson ,

The method of dynamic configuration depends on your use case — it can be performed either by the internal M7 core or externally via SPI. Below is a list of possible solutions:

1. ECT (Ethernet Control Tool)
Dynamic configuration via external Ethernet (UDP) frames. The internal firmware running on the M7 core receives the configuration and applies it to the switch core.

2. Modified ECT
The ECT source code can be adapted to accept any Ethernet frame format (not just UDP). This allows integration into custom protocols or systems. The internal logic remains the same — the M7 core performs the actual register updates.

3. SPI_HAP (Host Access Protocol)
The write_l2_lookup_table.py script from the host tools demonstrates how to configure the L2 table dynamically via SPI. This approach can be used by any external MCU or host processor. The logic from this script can also be ported to run directly on the internal M7 core if needed.

All of the above methods follow the same principle described in AN12925, section 5.1.3.2. The register-level flow is identical and includes polling the control register, writing to the entry registers, and triggering the update via the control register.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Fri, 04 Jul 2025 05:50:38 GMT

Hi @PavelL

In the Method of configuring via SPI_HAP
where can i find the write_l2_lookup_table.py?
How this needs to be communicated via SPI_HAP? when after the device bootup
In Previously during the static configuration, we have configured it each data via each index?
so whether data if static initially configured is fine or none of the static configuration its shouldn't be connected?
whether this write_l2_lookup_table.py can you share it?
when running this script from where (which port it need to be connected to pass the data) the script will be polling the data?

Regards
Atkinson

Re: Dynamic configuration in sja1110

Atkinson — Fri, 04 Jul 2025 11:24:48 GMT

Hi @PavelL

#include <stdint.h>
#include <stdbool.h>

// Define register addresses as per your SoC mapping
#define DYN_BE_LKP_ENTRY0 0x000 // Replace with actual address
#define DYN_BE_LKP_ENTRY1 0x004
#define DYN_BE_LKP_ENTRY2 0x008
#define DYN_BE_LKP_ENTRY3 0x00C
#define DYN_BE_LKP_ENTRY4 0x010
#define DYN_BE_LKP_ENTRY5 0x014
#define DYN_BE_LKP_CTRL 0x018

void insert_l2_unicast_entry(void)
{
// === INPUTS ===
uint64_t mac = 0x021122334455ULL; // MAC address
uint16_t vlan_id = 3;
uint8_t dest_port = 3; // Port 3
uint16_t dest_ports_mask = (1 << dest_port);
uint16_t index = 5;

// === STEP 1: Wait for previous operation to complete ===
while (read_register(DYN_BE_LKP_CTRL) & ETHSW_DYN_BE_LKP_CTRL_bValid_MASK);

// === STEP 2: Prepare entry fields ===
uint32_t mac_lo = (uint32_t)(mac & 0xFFFFFFFF); // Lower 32 bits
uint32_t mac_hi = (uint32_t)((mac >> 32) & 0xFFFF); // Upper 16 bits

uint32_t entry0 = ETHSW_DYN_BE_LKP_ENTRY0_uvEntry_30__0_(0x00000000);
uint32_t entry1 = ETHSW_DYN_BE_LKP_ENTRY1_uvEntry_62__31_(mac_lo);
uint32_t entry2 = ETHSW_DYN_BE_LKP_ENTRY2_uvEntry_94__63_(mac_hi);
uint32_t entry3 = ETHSW_DYN_BE_LKP_ENTRY3_uvEntry_126__95_(
((vlan_id & 0xFFF) << 16) | (dest_ports_mask & 0xFFFF));
uint32_t entry4 = ETHSW_DYN_BE_LKP_ENTRY4_uvEntry_158__127_(0x00000000); // optional flags/reserved
uint32_t entry5 = ETHSW_DYN_BE_LKP_ENTRY5_uvEntry_190__159_(index);

// === STEP 3: Write entries to DYN registers ===
write_register(DYN_BE_LKP_ENTRY0, entry0);
write_register(DYN_BE_LKP_ENTRY1, entry1);
write_register(DYN_BE_LKP_ENTRY2, entry2);
write_register(DYN_BE_LKP_ENTRY3, entry3);
write_register(DYN_BE_LKP_ENTRY4, entry4);
write_register(DYN_BE_LKP_ENTRY5, entry5);

// === STEP 4: Trigger WRITE via control register ===
uint32_t ctrl_val = 0;
ctrl_val |= ETHSW_DYN_BE_LKP_CTRL_bValid(1);
ctrl_val |= ETHSW_DYN_BE_LKP_CTRL_bWrRdB(1); // Write operation
ctrl_val |= ETHSW_DYN_BE_LKP_CTRL_uvHostCommand(0b011); // Host write
ctrl_val |= ETHSW_DYN_BE_LKP_CTRL_bValidEntry(1); // Valid entry

write_register(DYN_BE_LKP_CTRL, ctrl_val);

// === STEP 5: Wait for operation to complete ===
while (read_register(DYN_BE_LKP_CTRL) & ETHSW_DYN_BE_LKP_CTRL_bValid_MASK);

// === STEP 6: Check for error ===
uint32_t status = read_register(DYN_BE_LKP_CTRL);
if (status & ETHSW_DYN_BE_LKP_CTRL_bError_MASK) {
// Handle the error
// You can print or log this as needed
}
}

whether can i insert this code for Dynamically Writing the data to L2 Lookup Table
Where should i insert this code to test ?
Looking forward for your reply

Regards
Atkinson

Re: Dynamic configuration in sja1110

Atkinson — Mon, 07 Jul 2025 11:28:27 GMT

Hello @PavelL

static status_t wait_for_valid_clear(uint8_t swt) {
status_t status;
uint32_t ctrl = 0;
do {
status = SWITCH_DRV_Read(swt, 1, DYN_BE_LKP_CTRL, &ctrl);
if (status != STATUS_SUCCESS) return status;
} while (ctrl & DYN_BE_LKP_CTRL_VALID_MASK);

if (ctrl & DYN_BE_LKP_CTRL_ERROR_MASK) return STATUS_ERROR;
return STATUS_SUCCESS;
}

status_t SJA1110_AddL2LookupEntry_Dynamic(uint8_t swt) {
status_t status;

// MAC = 66:11:22:33:44:55
uint8_t mac[6] = {0x66, 0x11, 0x22, 0x33, 0x44, 0x55};
uint64_t mac64 = ((uint64_t)mac[0] << 40) | ((uint64_t)mac[1] << 32) | ((uint64_t)mac[2] << 24) |
((uint64_t)mac[3] << 16) | ((uint64_t)mac[4] << | (uint64_t)mac[5];

// Prepare L2 lookup entry fields
uint32_t entry[WORD_COUNT] = {0};

entry[0] = ((5 & 0xF) << 24) | (1 << 11); // SrcPort, DestPorts 1 & 2
entry[1] = (uint32_t)(mac64 & 0xFFFFFFFF);
entry[2] = (uint32_t)((mac64 >> 32) & 0xFFFF);
entry[2] |= (3 << 16); // VLAN ID = 3
entry[3] = 0; // Optional masks
entry[4] = 0;
entry[5] = (8 << 4) | (1 << 10); // CB_SID_IN = 8, CB_ON_DA = 1

// Wait until previous operation completes
status = wait_for_valid_clear(swt);
if (status != STATUS_SUCCESS) return status;

// Write L2 entry data to registers
status = SWITCH_DRV_Write(swt, WORD_COUNT, DYN_BE_LKP_ENTRY0, entry);
if (status != STATUS_SUCCESS) return status;

// Construct control register value
uint32_t ctrl = DYN_BE_LKP_CTRL_VALID_MASK |
DYN_BE_LKP_CTRL_RDWRSET_MASK |
(HOSTCMD_WRITE << DYN_BE_LKP_CTRL_HOSTCMD_SHIFT);

// Trigger write
status = SWITCH_DRV_Write(swt, 1, DYN_BE_LKP_CTRL, &ctrl);
if (status != STATUS_SUCCESS) return status;

// Wait for operation to complete
return wait_for_valid_clear(swt);
}

Whether this code can be utilized for generating a Dynamic entry ?
if this code is correct, where the function needs to be called??

Regards
Atkinson

Re: Dynamic configuration in sja1110

PavelL — Wed, 09 Jul 2025 05:42:51 GMT

Hello @Atkinson ,

I apologize for the delayed response due to public holidays.

Thank you for sharing your code. I had a quick look, and at first glance, it appears to align with the principles outlined in AN12925, chapter 5.1.3.2 Writing a L2 Lookup table entry. I also noticed that the #define statements seem to be reused from SJA1110.h, which is standard practice.

Please note, however, that an in-depth custom code review goes beyond the scope of our complimentary online support. Additionally, the timing and context in which this function should be called are highly application-specific and may vary depending on your system architecture and requirements.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Wed, 09 Jul 2025 09:25:30 GMT

Hello @PavelL

As you mentioned it i tried incorporating the code
can you confirm where do i need to place the code which will help us in creating the entry
Earlier Message you have mentioned there were Two Methods via doing it using ECT (Ethernet configuration Tool) and SPI_HAP
so these tools and files are needed to process on run -time ryt ??
The code which i shared is which i am trying to implement it without these tools
I am looking to create a Dynamic L2 Lookup Entry whether it is fine to do ??

Regards
Atkinson

Re: Dynamic configuration in sja1110

PavelL — Wed, 09 Jul 2025 13:29:00 GMT

Hello @Atkinson ,

Could you please clarify your use case for using a dynamic L2 lookup table?

Personally, I would consider using dynamic entries in two typical scenarios:

When you want to maintain a common switch configuration across multiple devices and then "personalize" each switch dynamically after power-up.
When you need to modify the switch configuration at runtime based on application-specific requirements.

In either case, there are generally three ways to update the switch configuration dynamically:

From the internal M7 core
From the host processor via SPI_HAP
From the host processor via Ethernet

Does your use case fall into one of these categories, or are you aiming for something different?

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Thu, 10 Jul 2025 04:09:51 GMT

Hello @PavelL

As you mentioned I would like to configure the switch_core configuration Dynamically
When a System boots the static configuration which we configured in peripherals is getting loaded
I am looking in a way to configure the Table entry which are configured in Static needs to be configured it via, Dynamically.

In either case, there are generally three ways to update the switch configuration dynamically:

From the internal M7 core
From the host processor via SPI_HAP
From the host processor via Ethernet
so you are saying these are the only ways of updating the system dynamically ?

if these are the only possible way, then configuring it in as a code which i provided will work or will not work ?
and also the three process which mentioned here is it same as the ECT & write_l2_lookup_table.py? or these are different one !!

Re: Dynamic configuration in sja1110

Atkinson — Thu, 10 Jul 2025 06:15:11 GMT

Hi @PavelL

3. SPI_HAP (Host Access Protocol)
The write_l2_lookup_table.py script from the host tools demonstrates how to configure the L2 table dynamically via SPI. This approach can be used by any external MCU or host processor. The logic from this script can also be ported to run directly on the internal M7 core if needed.

I am looking to configure an entry via write_l2_lookup_table.py
via how the configuration which we written in write_l2_lookup_table.py file will be moving to the RDB32 Board
what interface need to be done from laptop to RDB32Board?
what are the communication mechanism through which we can pass our l2 lookup entry to the device (RDB32 Board)
can you give me a procedure or where i can find the procedure for implementation

Re: Dynamic configuration in sja1110

PavelL — Thu, 10 Jul 2025 08:41:22 GMT

Hello @Atkinson ,

Yes, you're right — when the system boots, the static configuration is automatically loaded from external flash.

Let me clarify the concept of dynamic configuration in more detail.

The task of dynamic configuration can be split into two parts:

Assembling a valid entry — see UM11107, chapter 5.6 "Dynamic configuration"
Writing this entry to the switch — see AN12925, chapter 5.1.3.2 "Writing an L2 Lookup Table Entry"

There are three interfaces that can be used for this:

AHB — via the internal M7 core. SDK support is available, and the ECT server source code can serve as a starting point.
SPI_HAP — the host processor assembles a valid entry and writes it to the switch. This is what write_l2_lookup_table.py does.
Ethernet — the host processor sends a user-defined message (UDP, TCP, etc.), which is processed by the internal M7 core. The M7 decodes the message, assembles a valid entry, and writes it to the switch — so we’re effectively back to point 1. This is how ECT works internally.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Thu, 10 Jul 2025 09:17:50 GMT

Re: Dynamic configuration in sja1110

PavelL — Thu, 10 Jul 2025 11:17:14 GMT

Hello @Atkinson ,

If you're planning to do this from the S32G-VNP-RDB3 board, that changes things significantly. Will you be running the Linux BSP on the board, or do you plan to use your own firmware?

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Thu, 10 Jul 2025 11:23:17 GMT

Hi @PavelL

I am currently trying to implement it in S32G-VNP-RDB32 -- SJA1110 Switch
currently, I don't have any firmware on my own
Which Linux BSP need to be utilized
What might be the complete changes need to be done

Re: Dynamic configuration in sja1110

PavelL — Thu, 10 Jul 2025 13:41:45 GMT

Hello @Atkinson ,

The Linux BSP is already pre-installed on the SD card delivered with the S32G-VNP-RDB3 board, so no additional action is required in that regard.

I assume you have successfully brought up the board (apologies if you already mentioned this in previous messages).

The BSP includes the SJA1110 DSA driver, which provides a range of useful features — including support for dynamic L2 lookup table configuration.
The DSA driver is enabled by default.

As this case has evolved into a multi-domain topic, I’ve reached out to your FAE to discuss how we should proceed further.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Fri, 11 Jul 2025 06:05:56 GMT

Hi @PavelL

So since the Linux BSP is pre-installed on the SD Card if the SD card is getting inserted into the S32G-VNP-RDB board. so whether the BSP which present in SD card which will be enabling Dynamic configuration automatically

For configuring the L2 lookup entry via Dynamically using the write_l2_lookup.py (python evm host tools) whether that process remains same ?or for S32G-VNP-RDB board it will change
If the Process remains same how can we interface laptop & RDB32Board when interfacing it via Laptop and SJA1110 EVM board it will be connected using USB interface which will help to configure it Dynamic entry So in the case of S32G-VNP-RDB32 Board How the interface will be?
Whether it is possible to interface Laptop & S32G-VNP_RDB32 board creating a Dynamic entry?

and one more thing whether SJA1110_SDK_1.0.2 is a main thing needed for implementing RTM1.0.0 would that be fine ?

Re: Dynamic configuration in sja1110

PavelL — Fri, 11 Jul 2025 08:43:55 GMT

Hello @Atkinson ,

Q1: "So since the Linux BSP is pre-installed on the SD Card... will it enable dynamic configuration automatically?"
A1: No, the BSP includes the DSA driver, which supports dynamic configuration, but it is not automatically enabled for all use cases.

Q2: "For configuring the L2 lookup entry via Dynamically using the write_l2_lookup.py (python evm host tools) whether that process remains same ?or for S32G-VNP-RDB board it will change"
A2: The general flow for creating and uploading a dynamic entry remains the same, as described in UM11107 and AN12925.
However, the write_l2_lookup_table.py script uses the FTDI driver to access the SJA1110-EVM via USB.
To use this script with the S32G-VNP-RDB2 or RDB3 board, the FTDI layer would need to be modified to communicate via DSPI5 on the S32G processor.

Q3: "Whether it is possible to interface Laptop & S32G-VNP_RDB32 board creating a Dynamic entry?"
A3: Yes, it is possible. You are free to develop custom software running on Linux to handle your own protocol over SPI or Ethernet to configure dynamic entries.

Q4: "and one more thing whether SJA1110_SDK_1.0.2 is a main thing needed for implementing RTM1.0.0 would that be fine?"
A4: No, it is recommended to use the latest version of SJA1110 SDK 1.0.2 for compatibility and stability.

For further support, please contact your FAE or submit a ticket via https://support.nxp.com/s/?language=en_US.
Thank you for your understanding.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Fri, 11 Jul 2025 08:59:06 GMT

Hi @PavelL

To use this script with the S32G-VNP-RDB2 or RDB3 board, the FTDI layer would need to be modified to communicate via DSPI5 on the S32G processor.
How to do that? is there any supporting documents?

Re: Dynamic configuration in sja1110

PavelL — Fri, 11 Jul 2025 09:48:15 GMT

Hello @Atkinson ,

I'm not aware of any supporting documents - that's a general knowledge, device independent. I have consulted this topic with Copilot and it should be possible to modify sja11xx_ftdi4232.py to use DSPI5 instead of FTDI.

Best regards,

Pavel

Re: Dynamic configuration in sja1110

Atkinson — Mon, 14 Jul 2025 05:39:42 GMT

Hi @PavelL

can you give me the complete address for Reading and writing
Address Name Access Reset Description
8Ch DYN_BE_LKP_
ENTRY0
R/W 0h
(FFFFFFFEh)

before 8ch what would be the base address?
like for example it will have 0x3fc0008c so for this dynamic entry table we will have a complete address can you give me the complete address for
8Ch DYN_BE_LKP_
ENTRY0
R/W 0h
(FFFFFFFEh)
90h DYN_BE_LKP_
ENTRY1
R/W 0h
94h DYN_BE_LKP_
ENTRY2
R/W 0h
98h DYN_BE_LKP_
ENTRY3
R/W 0h
9Ch DYN_BE_LKP_
ENTRY4
R/W 0h
A0h DYN_BE_LKP_
ENTRY5
R/W 0h
A4h DYN_BE_LKP_CTRL R/W 0h
(FF800000h)