iio: adc: adrv9002: api: fix multi device support

One some functions of the API, in order to avoid huge arrays in the
stack (which is problematic for the kernel), we just made those arrays
global and move them into the data section. Well, if we have more than
one adr9002 instantiated in one system, we'll be in trouble.

Hence, to fix it just create some local global locks to protect that data.
None of the affected paths is a fast path and the contention should be
minimal to the point of being neglectable (and can only exist in case
we do have multiple devices in the system). This way we do not need to
increase the adi_adrv9001_Device struct which is already huge.

Signed-off-by: Nuno Sa <nuno.sa@analog.com>

Author: nunojsa

drivers/iio/adc/navassa/devices/adrv9001/private/src/adrv9001_arm.c

@@ -37,7 +37,11 @@
 #include "adrv9001_bf.h"
 #include "adi_adrv9001_hal.h"
 #ifdef __KERNEL__
+#include <linux/cleanup.h>
+#include <linux/mutex.h>
 #include <linux/string.h>
+
+static DEFINE_MUTEX(dma_wr_lock);
 #endif
 
 /* Header files related to libraries */
@@ -103,8 +107,8 @@ const char* const adrv9001_error_table_CmdCtrlMboxCmdError[] =
     "Command error"
 };
 
-const char* const adrv9001_error_table_CmdError[] = 
-{ 
+const char* const adrv9001_error_table_CmdError[] =
+{
     "Error occurred during an Init Calibration. Check that no signal is being applied to the Rx ports. Check that "
         "correct external LOs are applied, and synchronized,  where appropriate",
     "Error occurred during a Tracking Calibration. Disable tracking calibrations, reset and program. If enabled "
@@ -253,7 +257,7 @@ static __maybe_unused int32_t adrv9001_DmaMemReadByte(adi_adrv9001_Device_t *dev
     }
 
     regRead |= ADRV9001_DMA_CTL_LEGACY_MODE;
-    
+
     /* bus size, 2'b00=byte; 2'b01=half-word; 2'b10=full-word; 2'b11=invalid */
     /* core_bf.bus_size.write(bf_status, 2'b10); */
     regRead |= ADRV9001_BF_ENCODE(0, ADRV9001_DMA_CTL_BUS_SIZE_MASK, ADRV9001_DMA_CTL_BUS_SIZE_SHIFT);
@@ -325,7 +329,7 @@ static __maybe_unused int32_t adrv9001_DmaMemReadByte(adi_adrv9001_Device_t *dev
             returnData[i + 1] = dataRead0;
             ADRV9001_SPIREADBYTEDMA(device, "ARM_DMA_DATA_2", ADRV9001_ADDR_ARM_DMA_DATA2, &dataRead0);
             returnData[i + 2] = dataRead0;
-            
+
             /* 'single_instruction' has to be cleared before reading DMA_DATA3 and set back after */
             ADI_EXPECT(adrv9001_NvsRegmapCore_SingleInstruction_Set, device, 0x0);
             ADRV9001_SPIREADBYTEDMA(device, "ARM_DMA_DATA_3", ADRV9001_ADDR_ARM_DMA_DATA3, &dataRead0);
@@ -1042,7 +1046,7 @@ static void adrv9001_LoadSsiConfig(adi_adrv9001_Device_t *device, uint32_t *offs
     cfgData[tempOffset++] = (uint8_t)ssiConfig->cmosClkInversionEn;
 
     cfgData[tempOffset++] = (uint8_t)ssiConfig->ddrEn;
-    
+
     cfgData[tempOffset++] = (uint8_t)ssiConfig->rxMaskStrobeEn;
 
     /* 4 bytes of padding is needed for alignment */
@@ -1563,15 +1567,15 @@ typedef struct
     duplexMode_e    duplexMode;
     uint8_t         fhModeOn;
     uint8_t         reserved1[1u];       //< Reserved for future feature
-    uint8_t         numDynamicProfile;   // Number of Profile. =1 means only one profile and no switching 
+    uint8_t         numDynamicProfile;   // Number of Profile. =1 means only one profile and no switching
     mcsMode_e       mcsMode;             // MCS mode selection: 0 - Disable, 1 - MCS Only, 2 - MCS + RFPLL phase sync
-    adcType_e       adcTypeMonitor;      // ADC type used in Monitor Mode 
-    uint16_t        pllLockTime_us;      // Required lock time in microseconds for PLLs, based on ref_clk and loop bandwidth 
-    pllModulus_t    pllModuli;           // PLL moduli 
-    uint16_t        pllPhaseSyncWait_us; // Worst case phase sync wait time in FH 
-    mcsInf_e        mcsInterfaceType;    // 0-Disabled, 1-CMOS, 2-LVDS 
-    uint8_t         warmBootEnable;      // Enable WarmBoot - Load initCal cefficients instead of running initCals     
-    uint32_t        reserved[1u];        // Reserved for future feature 
+    adcType_e       adcTypeMonitor;      // ADC type used in Monitor Mode
+    uint16_t        pllLockTime_us;      // Required lock time in microseconds for PLLs, based on ref_clk and loop bandwidth
+    pllModulus_t    pllModuli;           // PLL moduli
+    uint16_t        pllPhaseSyncWait_us; // Worst case phase sync wait time in FH
+    mcsInf_e        mcsInterfaceType;    // 0-Disabled, 1-CMOS, 2-LVDS
+    uint8_t         warmBootEnable;      // Enable WarmBoot - Load initCal cefficients instead of running initCals
+    uint32_t        reserved[1u];        // Reserved for future feature
 } deviceSysConfig_t;
 */
 static void adrv9001_DeviceSysConfigWrite(adi_adrv9001_Device_t *device, const adi_adrv9001_DeviceSysConfig_t *sysConfig, uint8_t cfgData[], uint32_t *offset)
@@ -1609,13 +1613,13 @@ static void adrv9001_DeviceSysConfigWrite(adi_adrv9001_Device_t *device, const a
     {
         adrv9001_LoadFourBytes(&tempOffset, cfgData, sysConfig->pllModulus.dmModulus[i]);
     }
-    
+
     /* PLL phase sync wait time in us */
     adrv9001_LoadTwoBytes(&tempOffset, cfgData, sysConfig->pllPhaseSyncWait_us);
 
     cfgData[tempOffset++] = sysConfig->mcsInterfaceType;
     cfgData[tempOffset++] = sysConfig->warmBootEnable;
-    
+
     /* 4 bytes padding; Reserved for future use */
     tempOffset += 4;
 
@@ -1994,7 +1998,7 @@ int32_t adrv9001_DmaMemWrite(adi_adrv9001_Device_t *device, uint32_t address, co
     int32_t recoveryAction = ADI_COMMON_ACT_NO_ACTION;
     uint8_t singleInstruction = 0;
     uint8_t spiMode = 0;
-    
+
     ADI_ENTRY_PTR_ARRAY_EXPECT(device, data, byteCount);
 
     ADRV9001_DMAINFO("ARM_MEM_WRITE", armMemAddress, byteCount);
@@ -2015,7 +2019,7 @@ int32_t adrv9001_DmaMemWrite(adi_adrv9001_Device_t *device, uint32_t address, co
     /* If Address is not on word boundary, Or ByteCount is not on Word boundary */
     if (((armMemAddress & 0x00000003) > 0) || ((byteCount & 0x00000003) > 0))
     {
-        if ((ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STANDARD_BYTES_252 == spiWriteMode) || 
+        if ((ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STANDARD_BYTES_252 == spiWriteMode) ||
             (ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STREAMING_BYTES_4 == spiWriteMode))
         {
             ADI_ERROR_REPORT(&device->common,
@@ -2059,7 +2063,7 @@ int32_t adrv9001_DmaMemWrite(adi_adrv9001_Device_t *device, uint32_t address, co
 
     /* setting up the DMA control register for a write */
     ADRV9001_SPIWRITEBYTEDMA(device, "ARM_DMA_CTL", ADRV9001_ADDR_ARM_DMA_CTL, regWrite);
-    
+
     /* Enable single instruction and disable SPI streaming mode by default.
      * If ADRV9001 SPI streming mode is selected, then single instruction and single instruction are disbled */
     ADI_EXPECT(adrv9001_NvsRegmapCore_SingleInstruction_Set, device, 0x1);
@@ -2194,14 +2198,15 @@ int32_t adrv9001_DmaMemWriteFH(adi_adrv9001_Device_t *device, adi_adrv9001_FhHop
 	static uint8_t     addrLsbArray[ADI_ADRV9001_FREQ_HOPPING_MAX_NUM_BYTES];
 	static uint8_t     dataArray[ADI_ADRV9001_FREQ_HOPPING_MAX_NUM_BYTES];
 
+    guard(mutex)(&dma_wr_lock);
     memset(addrMsbArray, 0, sizeof(addrMsbArray));
     memset(addrLsbArray, 0, sizeof(addrLsbArray));
     memset(dataArray, 0, sizeof(dataArray));
 #endif
 
 	ADI_ENTRY_PTR_ARRAY_EXPECT(device, numHopTableEntries, numHopTableEntriesByteCount);
 	ADI_ENTRY_PTR_ARRAY_EXPECT(device, hopTableBufferData, hopTableBufferDataByteCount);
-	
+
 	/* Trigger appropriate SPI Interrupt upon table load */
 	if (hopSignal == ADI_ADRV9001_FH_HOP_SIGNAL_1)
 	{
@@ -2217,7 +2222,7 @@ int32_t adrv9001_DmaMemWriteFH(adi_adrv9001_Device_t *device, adi_adrv9001_FhHop
 	}
 
 	ADRV9001_DMAINFO("ARM_MEM_WRITE", armMemAddress, byteCount);
-	
+
 	regWrite &= ~ADRV9001_DMA_CTL_RD_WRB;
 	regWrite |= ADRV9001_DMA_CTL_SYS_CODEB;
 	regWrite |= ADRV9001_BF_ENCODE(2, ADRV9001_DMA_CTL_BUS_SIZE_MASK, ADRV9001_DMA_CTL_BUS_SIZE_SHIFT);
@@ -2227,7 +2232,7 @@ int32_t adrv9001_DmaMemWriteFH(adi_adrv9001_Device_t *device, adi_adrv9001_FhHop
 	{
 		regWrite |= ADRV9001_DMA_CTL_AUTO_INCR;
 	}
-    
+
 	/* setting up the DMA control register for a write */
 	addrMsbArray[addrIndex] = (uint8_t)(((ADRV9001_SPI_WRITE_POLARITY & 0x01) << 7) | ((ADRV9001_ADDR_ARM_DMA_CTL >> 8) & 0x7F));
 	addrLsbArray[addrIndex] = (uint8_t)ADRV9001_ADDR_ARM_DMA_CTL;
@@ -2267,7 +2272,7 @@ int32_t adrv9001_DmaMemWriteFH(adi_adrv9001_Device_t *device, adi_adrv9001_FhHop
 		dataArray[addrIndex] = numHopTableEntries[dataIndex];
 		addrIndex++;
 	}
-    
+
 	addrMsbArray[addrIndex] = (uint8_t)(((ADRV9001_SPI_WRITE_POLARITY & 0x01) << 7) | ((ADRV9001_ADDR_ARM_DMA_ADDR3 >> 8) & 0x7F));
 	addrLsbArray[addrIndex] = (uint8_t)ADRV9001_ADDR_ARM_DMA_ADDR3;
 	dataArray[addrIndex] = (uint8_t)((hopTableBufferAddress) >> ADRV9001_ADDR_ARM_DMA_ADDR3_BYTE_SHIFT);
@@ -2421,7 +2426,7 @@ int32_t adrv9001_DmaMemRead(adi_adrv9001_Device_t *device, uint32_t address, uin
         returnData[i + 2] = dataRead;
         ADRV9001_SPIREADBYTEDMA(device, "ARM_DMA_DATA_1", ADRV9001_ADDR_ARM_DMA_DATA1, &dataRead);
         returnData[i + 1] = dataRead;
-        
+
         /* 'single_instruction' has to be cleared before reading DMA_DATA3 and set back after */
         ADI_EXPECT(adrv9001_NvsRegmapCore_SingleInstruction_Set, device, 0x0);
         ADRV9001_SPIREADBYTEDMA(device, "ARM_DMA_DATA_0", ADRV9001_ADDR_ARM_DMA_DATA0, &dataRead);
@@ -2491,7 +2496,7 @@ int32_t adrv9001_FlexStreamProcessorMemWrite(adi_adrv9001_Device_t *device,
     /* If Address is not on word boundary, Or ByteCount is not on Word boundary */
     if (((flexSpAddress & 0x00000003) > 0) || ((byteCount & 0x00000003) > 0))
     {
-        if ((ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STANDARD_BYTES_252 == spiWriteMode) || 
+        if ((ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STANDARD_BYTES_252 == spiWriteMode) ||
             (ADI_ADRV9001_ARM_SINGLE_SPI_WRITE_MODE_STREAMING_BYTES_4 == spiWriteMode))
         {
             ADI_ERROR_REPORT(&device->common,
@@ -2526,7 +2531,7 @@ int32_t adrv9001_FlexStreamProcessorMemWrite(adi_adrv9001_Device_t *device,
 
     /* setting up the flex SP DMA control register for a write */
     ADRV9001_SPIWRITEBYTEDMA(device, "FLEX_SP_ARM_DMA_CTL", ADRV9001_ADDR_FLEX_SP_ARM_DMA_CTL, regWrite);
-    
+
     /* Enable single instruction and disable SPI streaming mode by default.
      * If ADRV9001 SPI streming mode is selected, then single instruction and single instruction are disbled */
     ADI_EXPECT(adrv9001_NvsRegmapCore_SingleInstruction_Set, device, 0x1);
@@ -2792,7 +2797,7 @@ static const char* adrv9001_CmdErrMsgGet(uint32_t errCode)
     {
         return adrv9001_error_table_CmdError[6];
     }
-    
+
     return NULL;
 }
 
@@ -2849,7 +2854,7 @@ int32_t adrv9001_ArmCmdErrorHandler(adi_adrv9001_Device_t *device, uint32_t detE
 
             ADI_EXPECT(adrv9001_ArmMailBoxErrCodeGet, device, &mailboxErrCode);
             errorString = adrv9001_CmdErrMsgGet(mailboxErrCode);
-            
+
             ADI_ERROR_REPORT(&device->common,
                              ADI_ADRV9001_SRC_ARMCMD,
                              mailboxErrCode,
@@ -2951,7 +2956,7 @@ static uint32_t adrv9001_ArmProfileWrite_Validate(adi_adrv9001_Device_t *device,
             ADI_ERROR_RETURN(device->common.error.newAction);
         }
     }
-    
+
     /* Range check parameters in adi_adrv9001_TxSettings_t */
     for (i = 0; i < ADI_ADRV9001_MAX_TXCHANNELS; i++)
     {
@@ -2967,7 +2972,7 @@ static uint32_t adrv9001_ArmProfileWrite_Validate(adi_adrv9001_Device_t *device,
             ADI_RANGE_CHECK(device, init->tx.txProfile[i].txSsiConfig.ssiDataFormatSel, ADI_ADRV9001_SSI_FORMAT_2_BIT_SYMBOL_DATA, ADI_ADRV9001_SSI_FORMAT_22_BIT_I_Q_DATA_1_BIT_GAIN_CHANGE_8_BIT_GAIN_INDEX);
             ADI_RANGE_CHECK(device, init->tx.txProfile[i].txSsiConfig.numLaneSel, ADI_ADRV9001_SSI_1_LANE, ADI_ADRV9001_SSI_4_LANE);
             ADI_RANGE_CHECK(device, init->tx.txProfile[i].txSsiConfig.strobeType, ADI_ADRV9001_SSI_SHORT_STROBE, ADI_ADRV9001_SSI_LONG_STROBE);
-            
+
             if ((ADI_ADRV9001_SSI_TYPE_LVDS == init->tx.txProfile[i].txSsiConfig.ssiType) &&
                 (false == init->tx.txProfile[i].txSsiConfig.ddrEn) &&
                 (init->tx.txProfile[i].txInterfaceSampleRate_Hz > 30720000))
@@ -3144,7 +3149,7 @@ int32_t adrv9001_ArmProfileWrite(adi_adrv9001_Device_t *device, const adi_adrv90
     cfgData[offset++] = (uint8_t)(init->clocks.armPowerSavingClkDiv - 1);
 
     cfgData[offset++] = (uint8_t)init->clocks.refClockOutEnable;
-    
+
     cfgData[offset++] = (uint8_t)init->clocks.auxPllPower;
     cfgData[offset++] = (uint8_t)init->clocks.clkPllPower;
 
@@ -3203,14 +3208,14 @@ int32_t adrv9001_ArmProfileWrite(adi_adrv9001_Device_t *device, const adi_adrv90
     if (ADRV9001_BF_EQUAL(device->devStateInfo.profilesValid, ADI_ADRV9001_TX_PROFILE_VALID))
     {
         armChannels |= (init->tx.txInitChannelMask & (ADI_ADRV9001_TX1 | ADI_ADRV9001_TX2));
-        
+
         /* Tx channels must have a valid and enabled ILB channel unless the signaling is Direct FM/FSK */
         if(ADRV9001_BF_EQUAL(init->tx.txInitChannelMask, ADI_ADRV9001_TX1) &&
             (init->tx.txProfile[0].outputSignaling != ADI_ADRV9001_TX_DIRECT_FM_FSK))
         {
             armChannels |= (init->rx.rxInitChannelMask & ADI_ADRV9001_ILB1);
         }
-            
+
         if (ADRV9001_BF_EQUAL(init->tx.txInitChannelMask, ADI_ADRV9001_TX2) &&
             (init->tx.txProfile[1].outputSignaling != ADI_ADRV9001_TX_DIRECT_FM_FSK))
         {
@@ -3499,7 +3504,7 @@ int32_t adrv9001_DynamicProfile_Write(adi_adrv9001_Device_t *device,
     int32_t recoveryAction = ADI_COMMON_ACT_NO_ACTION;
     uint32_t offset = 0;
     uint8_t cfgData[ADRV9001_DYNAMIC_PROFILE_BLOB_SIZE] = { 0 };
-    
+
     cfgData[offset++] = dynamicProfile->dynamicProfileIndex;
     cfgData[offset++] = 0; // padding
     cfgData[offset++] = 0; // padding

drivers/iio/adc/navassa/devices/adrv9001/public/src/adi_adrv9001_cals.c

@@ -25,10 +25,15 @@
 #include "adrv9001_arm_macros.h"
 #include "adrv9001_init.h"
 #include "adrv9001_reg_addr_macros.h"
+#include "linux/mutex.h"
 #include "object_ids.h"
 
 #ifdef __KERNEL__
+#include <linux/cleanup.h>
+#include <linux/mutex.h>
 #include <linux/string.h>
+
+static DEFINE_MUTEX(warmboot_lock);
 #else
 #include <string.h>
 #endif
@@ -84,7 +89,7 @@ int32_t adi_adrv9001_cals_InitCals_Run(adi_adrv9001_Device_t *adrv9001,
 
     /* Mode to select the Init calibration algorithms to run */
     payload[1] = (uint8_t)(initCals->calMode);
-    
+
     /* A value of true will force all enabled calibrations to re-run */
     payload[2] = (uint8_t)(initCals->force);
 
@@ -596,15 +601,15 @@ int32_t adi_adrv9001_cals_InternalPathDelay_Get_Validate(adi_adrv9001_Device_t *
 {
     static uint8_t MAX_NUM_PROFILE = 6;
     adi_adrv9001_ChannelState_e state = ADI_ADRV9001_CHANNEL_STANDBY;
-    
+
     ADI_RANGE_CHECK(adrv9001, port, ADI_RX, ADI_TX);
     ADI_RANGE_CHECK(adrv9001, channel, ADI_CHANNEL_1, ADI_CHANNEL_2);
     ADI_NULL_PTR_RETURN(&adrv9001->common, internalPathDelays_ns);
     ADI_RANGE_CHECK(adrv9001, length, 1, MAX_NUM_PROFILE);
     ADI_EXPECT(adi_adrv9001_Radio_Channel_State_Get, adrv9001, port, channel, &state);
     if (ADI_ADRV9001_CHANNEL_STANDBY == state)
     {
-        ADI_ERROR_REPORT(&adrv9001->common, 
+        ADI_ERROR_REPORT(&adrv9001->common,
             ADI_COMMON_ERRSRC_API,
             ADI_COMMON_ERR_INV_PARAM,
             ADI_COMMON_ACT_ERR_CHECK_PARAM,
@@ -736,7 +741,7 @@ int32_t adi_adrv9001_cals_Dynamic_profiles_calibrate_Validate(adi_adrv9001_Devic
     ADI_ENTRY_PTR_EXPECT(adrv9001, initCals);
     ADI_NULL_PTR_RETURN(&adrv9001->common, errorFlag);
 
-    ADI_NULL_PTR_RETURN(&adrv9001->common, dynamicProfile); 
+    ADI_NULL_PTR_RETURN(&adrv9001->common, dynamicProfile);
     ADI_RANGE_CHECK(adrv9001, length, 1, MAX_NUM_PROFILE);
 
     for (port = ADI_RX; port <= ADI_TX; port++)
@@ -774,7 +779,7 @@ int32_t adi_adrv9001_cals_Dynamic_profiles_calibrate(adi_adrv9001_Device_t *adrv
 {
     int8_t i = 0;
     ADI_EXPECT(adi_adrv9001_cals_Dynamic_profiles_calibrate_Validate, adrv9001, initCals, errorFlag, dynamicProfile, length);
-    
+
     for (i = 0; i <= (length - 1); i++)
     {
         ADI_EXPECT(adi_adrv9001_arm_NextDynamicProfile_Set, adrv9001, &dynamicProfile[i]);
@@ -796,14 +801,16 @@ int32_t adi_adrv9001_cals_InitCals_WarmBoot_UniqueEnabledCals_Get(adi_adrv9001_D
 #else
 	static uint32_t tblSize[4];
 	static uint32_t vecTbl[ADI_ADRV9001_WB_MAX_NUM_VECTOR_TABLE_WORDS];
+
+	guard(mutex)(&warmboot_lock);
 #endif
 	int calNo;
 	int arrayIndex = 0;
 	calNumbers->numberUniqueEnabledCals = 0;
 
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020000, tblSize, sizeof(tblSize), 0);
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020004, vecTbl, tblSize[0] * 16, 1);
-	
+
 	for (calNo = 0; calNo < tblSize[0]; calNo++)
 	{
 		uint32_t initMask = vecTbl[(4*calNo) + 2];
@@ -850,12 +857,14 @@ int32_t adi_adrv9001_cals_InitCals_WarmBoot_Coefficients_MaxArray_Get(adi_adrv90
 	static uint32_t tblSize[4];
 	static uint32_t vecTbl[ADI_ADRV9001_WB_MAX_NUM_ENTRY];
 	static uint8_t calVal[ADI_ADRV9001_WB_MAX_NUM_COEFF];
+
+	guard(mutex)(&warmboot_lock);
 #endif
 	int calNo;
 
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020000, tblSize, sizeof(tblSize), 0);
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020004, vecTbl, tblSize[0] * 16, 1);
-	
+
 	for (calNo = 0; calNo < tblSize[0]; calNo++)
 	{
 		uint32_t addr = vecTbl[4*calNo];
@@ -906,11 +915,13 @@ int32_t adi_adrv9001_cals_InitCals_WarmBoot_Coefficients_UniqueArray_Get(adi_adr
 	static uint32_t tblSize[4];
 	static uint32_t vecTbl[ADI_ADRV9001_WB_MAX_NUM_ENTRY];
 	static uint8_t calVal[ADI_ADRV9001_WB_MAX_NUM_COEFF];
+
+	guard(mutex)(&warmboot_lock);
 #endif
 	int calNo;
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020000, tblSize, sizeof(tblSize), 0);
 	ADI_EXPECT(adi_adrv9001_arm_Memory_Read32, device, 0x20020004, vecTbl, tblSize[0] * 16, 1);
-	
+
 	for (calNo = 0; calNo < tblSize[0]; calNo++)
 	{
 		uint32_t addr = vecTbl[4*calNo];
@@ -958,6 +969,8 @@ int32_t adi_adrv9001_cals_InitCals_WarmBoot_Coefficients_MaxArray_Set(adi_adrv90
 	static uint32_t tblSize[4];
 	static uint32_t vecTbl[ADI_ADRV9001_WB_MAX_NUM_ENTRY];
 	static uint8_t calVal[ADI_ADRV9001_WB_MAX_NUM_COEFF];
+
+	guard(mutex)(&warmboot_lock);
 #endif
 	int calNo;
 
@@ -1014,6 +1027,8 @@ int32_t adi_adrv9001_cals_InitCals_WarmBoot_Coefficients_UniqueArray_Set(adi_adr
 	static uint32_t tblSize[4];
 	static uint32_t vecTbl[ADI_ADRV9001_WB_MAX_NUM_ENTRY];
 	static uint8_t calVal[ADI_ADRV9001_WB_MAX_NUM_COEFF];
+
+	guard(mutex)(&warmboot_lock);
 #endif
 	int calNo;