Dynamic configuration in sja1110

[Atkinson]

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

[PavelL]

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

[Atkinson]

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 

[Atkinson]

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 

[Atkinson]

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

[Atkinson]

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 

[PavelL]

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

[Atkinson]

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 

[PavelL]

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

[Atkinson]

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 !!

[PavelL]

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:

1. Assembling a valid entry — see UM11107, chapter 5.6 "Dynamic configuration"
2. 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:

1. AHB — via the internal M7 core. SDK support is available, and the ECT server source code can serve as a starting point.
2. SPI_HAP — the host processor assembles a valid entry and writes it to the switch. This is what write_l2_lookup_table.py does.
3. 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

[Atkinson]

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 

[PavelL]

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

[Atkinson]

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

[PavelL]

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

[Atkinson]

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 ?

[PavelL]

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

[Atkinson]

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?

[PavelL]

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

[Atkinson]

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)

[PavelL · Accepted solution]

Hello @Atkinson ,

I apologize for late response caused my current workload.

I understand it might not seem straightforward at first, but the concept is actually quite simple.

The final register address depends on the access method - whether you're accessing it internally via the M7 core over AHB, or externally via the SPI_AP interface. The base addresses differ depending on the access point.

The register address is calculated using the base address provided in Table 2 of UM11107. For example, for the switch subsystem, the base address is 0x00000000 for SPI_AP access and 0xFF000000 for AHB access.

In your case, the register 0x8C (DYN_BE_LKP_ENTRY0) becomes 0xFF00008C when accessed via AHB.

Now, here’s where it might get confusing: the SDK driver defines the following:

#define SJA1110_L2_ART_LE_ADDR (0x3fc00023) /**< Address of the l2ArtLockedEntry register *

The SWITCH_DRV_Write routine shifts the address left by 2 bits (<< 2) for internal (AHB) access. For SPI transfers (used in cascaded switch setups), no shift is applied. So, 0x3fc00023 << 2 results in 0xFF00008C.

I hope that with the explanation above, it makes sense now.

Best regards,

Pavel