Add mutex for mailbox access.
Signed-off-by: Sandor Yu <Sandor.yu@nxp.com>
CDN_API_STATUS CDN_API_AudioMute_blocking(state_struct *state,
AUDIO_MUTE_MODE mode)
{
- internal_block_function(CDN_API_AudioMute(state, mode));
+ internal_block_function(&state->mutex, CDN_API_AudioMute(state, mode));
}
CDN_API_STATUS CDN_API_AudioMode(state_struct *state, AUDIO_MODE mode)
CDN_API_STATUS CDN_API_AudioMode_blocking(state_struct *state, AUDIO_MODE mode)
{
- internal_block_function(CDN_API_AudioMode(state, mode));
+ internal_block_function(&state->mutex, CDN_API_AudioMode(state, mode));
}
CDN_API_STATUS CDN_API_AudioConfigCore(state_struct *state,
AUDIO_FREQ freq, int lanes,
AUDIO_WIDTH width)
{
- internal_block_function(CDN_API_AudioConfigCore
+ internal_block_function(&state->mutex, CDN_API_AudioConfigCore
(state, audioType, numOfChannels, freq, lanes,
width));
}
CDN_PROTOCOL_TYPE protocol,
int ncts, AUDIO_MUTE_MODE mode)
{
- internal_block_function(CDN_API_AudioAutoConfig
+ internal_block_function(&state->mutex, CDN_API_AudioAutoConfig
(state, audioType, numOfChannels, freq, lanes,
width, protocol, ncts, mode));
}
CDN_API_STATUS CDN_API_AudioOff_blocking(state_struct *state,
AUDIO_TYPE audioType)
{
- internal_block_function(CDN_API_AudioOff(state, audioType));
+ internal_block_function(&state->mutex, CDN_API_AudioOff(state, audioType));
}
DPTX_Read_DPCD_response *resp,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_DPTX_Read_DPCD
+ internal_block_function(&state->mutex, CDN_API_DPTX_Read_DPCD
(state, numOfBytes, addr, resp, bus_type));
}
u8 extension,
DPTX_Read_EDID_response *resp)
{
- internal_block_function(CDN_API_DPTX_Read_EDID
+ internal_block_function(&state->mutex, CDN_API_DPTX_Read_EDID
(state, segment, extension, resp));
}
u8 fastLinkTraining,
u8 laneMapping, u8 enchanced)
{
- internal_block_function(CDN_API_DPTX_SetHostCap
+ internal_block_function(&state->mutex, CDN_API_DPTX_SetHostCap
(state, maxLinkRate, lanesCount_SSC,
maxVoltageSwing, maxPreemphasis,
testPatternsSupported, fastLinkTraining,
CDN_API_STATUS CDN_API_DPTX_SetPowerMode_blocking(state_struct *state,
CDN_API_PWR_MODE mode)
{
- internal_block_function(CDN_API_DPTX_SetPowerMode(state, mode));
+ internal_block_function(&state->mutex, CDN_API_DPTX_SetPowerMode(state, mode));
}
CDN_API_STATUS CDN_API_DPTX_Control(state_struct *state, u32 mode)
CDN_API_STATUS CDN_API_DPTX_Control_blocking(state_struct *state, u32 mode)
{
- internal_block_function(CDN_API_DPTX_Control(state, mode));
+ internal_block_function(&state->mutex, CDN_API_DPTX_Control(state, mode));
}
CDN_API_STATUS CDN_API_DPTX_Write_DPCD(state_struct *state, u32 numOfBytes,
DPTX_Write_DPCD_response *resp,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_DPTX_Write_DPCD
+ internal_block_function(&state->mutex, CDN_API_DPTX_Write_DPCD
(state, numOfBytes, addr, buff, resp,
bus_type));
}
u8 base, u8 regNo,
DPTX_Read_Register_response *resp)
{
- internal_block_function(CDN_API_DPTX_Read_Register
+ internal_block_function(&state->mutex, CDN_API_DPTX_Read_Register
(state, base, regNo, resp));
}
CDN_API_STATUS CDN_API_DPTX_Write_Register_blocking(state_struct *state,
u8 base, u8 regNo, u32 val)
{
- internal_block_function(CDN_API_DPTX_Write_Register
+ internal_block_function(&state->mutex, CDN_API_DPTX_Write_Register
(state, base, regNo, val));
}
u8 startBit,
u8 bitsNo, u32 val)
{
- internal_block_function(CDN_API_DPTX_Write_Field
+ internal_block_function(&state->mutex, CDN_API_DPTX_Write_Field
(state, base, regNo, startBit, bitsNo, val));
}
CDN_API_STATUS CDN_API_DPTX_EnableEvent_blocking(state_struct *state, bool hpd,
bool training)
{
- internal_block_function(CDN_API_DPTX_EnableEvent(state, hpd, training));
+ internal_block_function(&state->mutex, CDN_API_DPTX_EnableEvent(state, hpd, training));
}
CDN_API_STATUS CDN_API_DPTX_ReadEvent(state_struct *state, u8 *LinkeventId,
CDN_API_STATUS CDN_API_DPTX_ReadEvent_blocking(state_struct *state,
u8 *LinkeventId, u8 *HPDevents)
{
- internal_block_function(CDN_API_DPTX_ReadEvent
+ internal_block_function(&state->mutex, CDN_API_DPTX_ReadEvent
(state, LinkeventId, HPDevents));
}
STEREO_VIDEO_ATTR steroVidAttr,
BT_TYPE bt_type, int TU)
{
- internal_block_function(CDN_API_DPTX_Set_VIC
+ internal_block_function(&state->mutex, CDN_API_DPTX_Set_VIC
(state, vicMode, bitsPerPixel, NumOfLanes, rate,
pxlencformat, steroVidAttr, bt_type, TU));
}
CDN_API_STATUS CDN_API_DPTX_SetVideo_blocking(state_struct *state, u8 mode)
{
- internal_block_function(CDN_API_DPTX_SetVideo(state, mode));
+ internal_block_function(&state->mutex, CDN_API_DPTX_SetVideo(state, mode));
}
CDN_API_STATUS CDN_API_DPTX_ReadLinkStat(state_struct *state,
CDN_API_STATUS CDN_API_DPTX_ReadLinkStat_blocking(state_struct *state,
S_LINK_STAT *stat)
{
- internal_block_function(CDN_API_DPTX_ReadLinkStat(state, stat));
+ internal_block_function(&state->mutex, CDN_API_DPTX_ReadLinkStat(state, stat));
}
CDN_API_STATUS CDN_API_DPTX_TrainingControl(state_struct *state, u8 val)
CDN_API_STATUS CDN_API_DPTX_TrainingControl_blocking(state_struct *state,
u8 val)
{
- internal_block_function(CDN_API_DPTX_TrainingControl(state, val));
+ internal_block_function(&state->mutex, CDN_API_DPTX_TrainingControl(state, val));
}
CDN_API_STATUS CDN_API_DPTX_GetLastAuxStatus(state_struct *state, u8 *resp)
CDN_API_STATUS CDN_API_DPTX_GetLastAuxStatus_blocking(state_struct *state,
u8 *resp)
{
- internal_block_function(CDN_API_DPTX_GetLastAuxStatus(state, resp));
+ internal_block_function(&state->mutex, CDN_API_DPTX_GetLastAuxStatus(state, resp));
}
CDN_API_STATUS CDN_API_DPTX_GetHpdStatus(state_struct *state, u8 *resp)
u8 *resp)
{
- internal_block_function(CDN_API_DPTX_GetHpdStatus(state, resp));
+ internal_block_function(&state->mutex, CDN_API_DPTX_GetHpdStatus(state, resp));
}
CDN_API_STATUS CDN_API_DPTX_ForceLanes(state_struct *state, u8 linkRate,
u8 preemphasis_l3, u8 pattern,
u8 ssc)
{
- internal_block_function(CDN_API_DPTX_ForceLanes_blocking
+ internal_block_function(&state->mutex, CDN_API_DPTX_ForceLanes_blocking
(state, linkRate, numOfLanes, voltageSwing_l0,
preemphasis_l0, voltageSwing_l1,
preemphasis_l1, voltageSwing_l2,
CDN_API_STATUS CDN_API_DPTX_SetDbg_blocking(state_struct *state,
uint32_t dbg_cfg)
{
- internal_block_function(CDN_API_DPTX_SetDbg(state, dbg_cfg));
+ internal_block_function(&state->mutex, CDN_API_DPTX_SetDbg(state, dbg_cfg));
}
CDN_API_STATUS CDN_API_General_Test_Echo_blocking(state_struct *state, u32 val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_General_Test_Echo
+ internal_block_function(&state->mutex, CDN_API_General_Test_Echo
(state, val, bus_type));
}
u16 num_bytes,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_General_Test_Echo_Ext
+ internal_block_function(&state->mutex, CDN_API_General_Test_Echo_Ext
(state, msg, resp, num_bytes, bus_type));
}
CDN_API_STATUS CDN_API_CheckAlive_blocking(state_struct *state)
{
- internal_block_function(CDN_API_CheckAlive(state));
+ internal_block_function(&state->mutex, CDN_API_CheckAlive(state));
}
CDN_API_STATUS CDN_API_MainControl(state_struct *state, u8 mode, u8 *resp)
CDN_API_STATUS CDN_API_MainControl_blocking(state_struct *state, u8 mode,
u8 *resp)
{
- internal_block_function(CDN_API_MainControl(state, mode, resp));
+ internal_block_function(&state->mutex, CDN_API_MainControl(state, mode, resp));
}
CDN_API_STATUS CDN_API_ApbConf(state_struct *state, u8 dpcd_bus_sel,
u8 *dpcd_resp,
u8 *hdcp_resp, u8 *capb_resp)
{
- internal_block_function(CDN_API_ApbConf
+ internal_block_function(&state->mutex, CDN_API_ApbConf
(state, dpcd_bus_sel, dpcd_bus_lock,
hdcp_bus_sel, hdcp_bus_lock, capb_bus_sel,
capb_bus_lock, dpcd_resp, hdcp_resp,
CDN_API_STATUS CDN_API_General_Read_Register_blocking(state_struct *state,
u32 addr, GENERAL_Read_Register_response *resp)
{
- internal_block_function(CDN_API_General_Read_Register
+ internal_block_function(&state->mutex, CDN_API_General_Read_Register
(state, addr, resp));
}
CDN_API_STATUS CDN_API_General_Write_Register_blocking(state_struct *state,
u32 addr, u32 val)
{
- internal_block_function(CDN_API_General_Write_Register
+ internal_block_function(&state->mutex, CDN_API_General_Write_Register
(state, addr, val));
}
u32 addr, u8 startBit,
u8 bitsNo, u32 val)
{
- internal_block_function(CDN_API_General_Write_Field
+ internal_block_function(&state->mutex, CDN_API_General_Write_Field
(state, addr, startBit, bitsNo, val));
}
CDN_API_STATUS CDN_API_General_Phy_Test_Access_blocking(state_struct *state,
u8 *resp)
{
- internal_block_function(CDN_API_General_Phy_Test_Access(state, resp));
+ internal_block_function(&state->mutex, CDN_API_General_Phy_Test_Access(state, resp));
}
u8 val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP_TX_CONFIGURATION
+ internal_block_function(&state->mutex, CDN_API_HDCP_TX_CONFIGURATION
(state, val, bus_type));
}
S_HDCP_TRANS_PUBLIC_KEY_PARAMS *val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_SET_PUBLIC_KEY_PARAMS
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_SET_PUBLIC_KEY_PARAMS
(state, val, bus_type));
}
S_HDCP_TRANS_KM_KEY_PARAMS *val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_SET_KM_KEY_PARAMS
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_SET_KM_KEY_PARAMS
(state, val, bus_type));
}
S_HDCP_TRANS_DEBUG_RANDOM_NUMBERS *val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_SET_DEBUG_RANDOM_NUMBERS
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_SET_DEBUG_RANDOM_NUMBERS
(state, val, bus_type));
}
S_HDCP_TRANS_PAIRING_DATA *val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_RESPOND_KM
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_RESPOND_KM
(state, val, bus_type));
}
S_HDCP_TX_MAIL_BOX_CMD_HDCP1_TX_SEND_KEYS *val,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP1_TX_SEND_KEYS
+ internal_block_function(&state->mutex, CDN_API_HDCP1_TX_SEND_KEYS
(state, val, bus_type));
}
CDN_API_STATUS CDN_API_HDCP1_TX_SEND_RANDOM_AN_blocking(state_struct *state,
u8 An[8], CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP1_TX_SEND_RANDOM_AN
+ internal_block_function(&state->mutex, CDN_API_HDCP1_TX_SEND_RANDOM_AN
(state, An, bus_type));
}
u8 resp[5],
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP_TX_STATUS_REQ
+ internal_block_function(&state->mutex, CDN_API_HDCP_TX_STATUS_REQ
(state, resp, bus_type));
}
u8 resp[5],
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_IS_KM_STORED_REQ
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_IS_KM_STORED_REQ
(state, resp, bus_type));
}
*resp,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP2_TX_STORE_KM_REQ
+ internal_block_function(&state->mutex, CDN_API_HDCP2_TX_STORE_KM_REQ
(state, resp, bus_type));
}
CDN_BUS_TYPE
bus_type)
{
- internal_block_function(CDN_API_HDCP_TX_IS_RECEIVER_ID_VALID_REQ
+ internal_block_function(&state->mutex, CDN_API_HDCP_TX_IS_RECEIVER_ID_VALID_REQ
(state, num, id, bus_type));
}
CDN_BUS_TYPE
bus_type)
{
- internal_block_function(CDN_API_HDCP_TX_RESPOND_RECEIVER_ID_VALID
+ internal_block_function(&state->mutex, CDN_API_HDCP_TX_RESPOND_RECEIVER_ID_VALID
(state, valid, bus_type));
}
u8 *lc,
CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_HDCP_GENERAL_2_SET_LC
+ internal_block_function(&state->mutex, CDN_API_HDCP_GENERAL_2_SET_LC
(state, lc, bus_type));
}
CDN_API_STATUS CDN_API_TEST_KEYS_blocking(state_struct *state, u8 test_type,
u8 resp[1], CDN_BUS_TYPE bus_type)
{
- internal_block_function(CDN_API_TEST_KEYS
+ internal_block_function(&state->mutex, CDN_API_TEST_KEYS
(state, test_type, resp, bus_type));
}
HDMITX_TRANS_DATA *data_in,
HDMITX_TRANS_DATA *data_out)
{
- internal_block_function(CDN_API_HDMITX_DDC_READ
+ internal_block_function(&state->mutex, CDN_API_HDMITX_DDC_READ
(state, data_in, data_out));
}
HDMITX_TRANS_DATA *data_in,
HDMITX_TRANS_DATA *data_out)
{
- internal_block_function(CDN_API_HDMITX_DDC_WRITE
+ internal_block_function(&state->mutex, CDN_API_HDMITX_DDC_WRITE
(state, data_in, data_out));
}
HDMITX_TRANS_DATA *
data_out)
{
- internal_block_function(CDN_API_HDMITX_DDC_UPDATE_READ
+ internal_block_function(&state->mutex, CDN_API_HDMITX_DDC_UPDATE_READ
(state, data_out));
}
u8 segment,
HDMITX_TRANS_DATA *data_out)
{
- internal_block_function(CDN_API_HDMITX_READ_EDID
+ internal_block_function(&state->mutex, CDN_API_HDMITX_READ_EDID
(state, block, segment, data_out));
}
CDN_API_STATUS CDN_API_HDMITX_ReadEvents_blocking(state_struct *state,
uint32_t *events)
{
- internal_block_function(CDN_API_HDMITX_ReadEvents(state, events));
+ internal_block_function(&state->mutex, CDN_API_HDMITX_ReadEvents(state, events));
}
CDN_API_STATUS CDN_API_HDMITX_GetHpdStatus(state_struct *state, u8 *hpd_sts)
CDN_API_STATUS CDN_API_HDMITX_GetHpdStatus_blocking(state_struct *state,
u8 *hpd_sts)
{
- internal_block_function(CDN_API_HDMITX_GetHpdStatus(state, hpd_sts));
+ internal_block_function(&state->mutex, CDN_API_HDMITX_GetHpdStatus(state, hpd_sts));
}
* \param x - function call
*/
#define MAILBOX_FILL_TIMEOUT 1500
-#define internal_block_function(x) \
+#define internal_block_function(y, x) \
do { \
unsigned long end_jiffies = jiffies + \
msecs_to_jiffies(MAILBOX_FILL_TIMEOUT); \
CDN_API_STATUS ret; \
+ mutex_lock(y); \
do { \
ret = x; \
cpu_relax(); \
} while (time_after(end_jiffies, jiffies) && \
(ret == CDN_BSY || ret == CDN_STARTED)); \
+ mutex_unlock(y); \
return ret; \
} while (0)
projects / linux.git / commitdiff