Inquiry Regarding Fixed Parameter Addresses for Software Safeload (ADAU1452 vs. ADAU1466)

Hello Jin Shan Pan,

The safe load address is not completely fixed; in most cases it will be the address given in the table in datasheet. However, if your project is too high and uses a lot of memory then the compiler may place the safe load address to some other location.

So, to get it right, just design your project, compile it and export the system files. The files will tell you where the exact safe load address is for this project.

You can use that address for writing from your MCU.

Feel free to reach out if you need any clarification.

Regards,

Harish

Hello Harish,

Thank you for your clarification on the safe load address.

To follow up on the IPAT access:

Start Address (for indirect parameter access)

Number of Loads

I understand that these values are different between the ADAU1452 and ADAU1466. My key question is: Is this difference due to the addresses being fixed and unique for each chip model, or can they also vary depending on the project compilation (like the safe load address)?

In other words, for a given chip (e.g., ADAU1466), are the IPAT Start Address and Number of Loads constants defined by the hardware, or are they project-dependent variables?

Your guidance on this would be greatly appreciated.

Best regards,

Jin Shan Pan

Hello Jin Shan Pan,

pjs said:
I understand that these values are different between the ADAU1452 and ADAU1466.

It's not that these addresses are different between the processors, these addresses can be different for the same processor but different project.

This address allocation and everything is done by sigma studio at compile time, so depends on the project size and memory usage, SS places these IPAT or safe load addresses anywhere in the memory (in most cases it will be the address given in the datasheet, but it can be different too, if your project is too big), so it all depends on the project and sigma studio's compilation not the DSP.

pjs said:
Is this difference due to the addresses being fixed and unique for each chip model, or can they also vary depending on the project compilation (like the safe load address)?

These addresses are not at all fixed, it will vary depending on the project compilation.

pjs said:
In other words, for a given chip (e.g., ADAU1466), are the IPAT Start Address and Number of Loads constants defined by the hardware, or are they project-dependent variables?

Hardware has nothing to do with this address; there are no chip ID to differentiate the sigma 300/350 DSPs, only the SPI/I2C device address is there to program the DSP from SS/uC.

So, either if you are using safe load or IPAT, just design the project and compile (and enable IPAT) and export the system files, there you will see the actual address allocated for IPAT/safe load.

It seems you are confused between safe load and IPAT, The IPAT table writes are exactly the same as safeload writes. They are done at the end of the regular code before the end of the frame.

The IPAT and the safe load. They work pretty much the same way. You should either use a safe load or IPAT to directly write the co-effs into the memory.

Safe load: You load in the data, and the start address and then the number of bytes to trigger the transfer.

Indirect Parameter Access: You load in your data into the fixed address for the parameter, and then you load in the start address of the first parameter and the number of parameters to trigger the transfer.

They function in the same way. The Indirect Parameter Access Table allows you to FIX the addresses of the desired parameters, so you do not have to know where the compiler had placed them in memory.

Regards,

Harish

Hello Harish,

Thank you for your detailed explanation about IPAT and safe load addressing. I was on vacation for the past few days, so apologies for the delayed response.

I understand your explanation that IPAT provides a way to access parameters through fixed table entries rather than directly accessing variable memory addresses. However, I'm still facing a practical challenge in my implementation.

Currently, my MCU can control algorithm parameters in Sigma Studio through IPAT, but I need to send three commands:

1. Write the parameter value to the IPAT values_11 address (e.g., 0x6015)
2. Write the start_address value (e.g., 0x6008) pointing to the IPAT entry
3. Write the num_of_loads_and_trigger value (e.g., 0x6009) to execute the transfer

My concern is: If the addresses for `start_address` (0x6008) and `num_of_loads_and_trigger` (0x6009) can change with each project compilation, then IPAT hasn't completely solved the problem of variable addresses. I would still need to extract these two addresses from the compiled system files after each compilation, just like I would need to do with safe load addresses.

The core issue seems to be:
- IPAT fixes the addresses for parameter values (like values_11 at 0x6015)
- But the IPAT control registers themselves (start_address and num_of_loads_and_trigger) still have variable addresses

Could you clarify if there's a way to lock these IPAT control register addresses as well? Or is the standard practice to always extract these addresses from the compiled project?

Thank you for your continued assistance.

Best regards,
Jin Shan Pan