Djam/arm-trusted-firmware
1
0
Fork 0
mirror of https://github.com/ARM-software/arm-trusted-firmware.git synced 2025-05-03 17:38:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix(zynqmp): typecast operands to match data type

Browse source 
This corrects the MISRA violation C2012-10.3:
The value of an expression shall not be assigned to an object with a
narrower essential type or of a different essential type category.
The condition is explicitly checked against 0U, appending 'U' and
typecasting for unsigned comparison.

Change-Id: I141fbc554265173df0ca90c2ddc7f28137c6b0f1
Signed-off-by: Nithin G <nithing@amd.com>
Signed-off-by: Maheedhar Bollapalli <maheedharsai.bollapalli@amd.com>
This commit is contained in:
Maheedhar Bollapalli 2024-04-24 16:20:26 +05:30
parent 3dc93e5139
commit 6ae9562473
10 changed files with 306 additions and 305 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
plat/xilinx/zynqmp/aarch64/zynqmp_common.c
View file

@ -333,7 +333,7 @@ int32_t plat_get_soc_version(void)
int32_t plat_get_soc_revision(void) int32_t plat_get_soc_revision(void)
{ {
return mmio_read_32(ZYNQMP_CSU_BASEADDR + ZYNQMP_CSU_IDCODE_OFFSET); return (int32_t)mmio_read_32(ZYNQMP_CSU_BASEADDR + ZYNQMP_CSU_IDCODE_OFFSET);
} }
static uint32_t zynqmp_get_ps_ver(void) static uint32_t zynqmp_get_ps_ver(void)

2
plat/xilinx/zynqmp/bl31_zynqmp_setup.c
View file

@ -59,7 +59,7 @@ static inline void bl31_set_default_config(void)
bl32_image_ep_info.pc = BL32_BASE; bl32_image_ep_info.pc = BL32_BASE;
bl32_image_ep_info.spsr = arm_get_spsr_for_bl32_entry(); bl32_image_ep_info.spsr = arm_get_spsr_for_bl32_entry();
bl33_image_ep_info.pc = plat_get_ns_image_entrypoint(); bl33_image_ep_info.pc = plat_get_ns_image_entrypoint();
bl33_image_ep_info.spsr = SPSR_64(MODE_EL2, MODE_SP_ELX, bl33_image_ep_info.spsr = (uint32_t)SPSR_64(MODE_EL2, MODE_SP_ELX,
DISABLE_ALL_EXCEPTIONS); DISABLE_ALL_EXCEPTIONS);
} }

2
plat/xilinx/zynqmp/plat_zynqmp.c
View file

@ -18,5 +18,5 @@ int32_t plat_core_pos_by_mpidr(u_register_t mpidr)
return -1; return -1;
} }
return zynqmp_calc_core_pos(mpidr); return (int32_t)zynqmp_calc_core_pos(mpidr);
} }

394
plat/xilinx/zynqmp/pm_service/pm_api_clock.c
View file

File diff suppressed because it is too large Load diff

2
plat/xilinx/zynqmp/pm_service/pm_api_ioctl.c
View file

@ -703,7 +703,7 @@ enum pm_ret_status tfa_ioctl_bitmask(uint32_t *bit_mask)
IOCTL_AFI, IOCTL_AFI,
}; };
uint8_t i, ioctl_id; uint8_t i, ioctl_id;
int32_t ret; enum pm_ret_status ret;
for (i = 0U; i < ARRAY_SIZE(supported_ids); i++) { for (i = 0U; i < ARRAY_SIZE(supported_ids); i++) {
ioctl_id = supported_ids[i]; ioctl_id = supported_ids[i];

2
plat/xilinx/zynqmp/pm_service/pm_api_pinctrl.c
View file

@ -2058,7 +2058,7 @@ enum pm_ret_status pm_api_pinctrl_get_function_groups(uint32_t fid,
if ((grps + index + i) >= end_of_grp_offset) { if ((grps + index + i) >= end_of_grp_offset) {
break; break;
} }
groups[i] = (grps + index + i); groups[i] = (uint16_t)(grps + index + i);
} }
return PM_RET_SUCCESS; return PM_RET_SUCCESS;

13
plat/xilinx/zynqmp/pm_service/pm_client.c
View file

@ -46,22 +46,22 @@ static uint32_t suspend_mode = PM_SUSPEND_MODE_STD;
/* Order in pm_procs_all array must match cpu ids */ /* Order in pm_procs_all array must match cpu ids */
static const struct pm_proc pm_procs_all[] = { static const struct pm_proc pm_procs_all[] = {
{ {
.node_id = NODE_APU_0, .node_id = (uint32_t)NODE_APU_0,
.pwrdn_mask = APU_0_PWRCTL_CPUPWRDWNREQ_MASK, .pwrdn_mask = APU_0_PWRCTL_CPUPWRDWNREQ_MASK,
.ipi = &apu_ipi, .ipi = &apu_ipi,
}, },
{ {
.node_id = NODE_APU_1, .node_id = (uint32_t)NODE_APU_1,
.pwrdn_mask = APU_1_PWRCTL_CPUPWRDWNREQ_MASK, .pwrdn_mask = APU_1_PWRCTL_CPUPWRDWNREQ_MASK,
.ipi = &apu_ipi, .ipi = &apu_ipi,
}, },
{ {
.node_id = NODE_APU_2, .node_id = (uint32_t)NODE_APU_2,
.pwrdn_mask = APU_2_PWRCTL_CPUPWRDWNREQ_MASK, .pwrdn_mask = APU_2_PWRCTL_CPUPWRDWNREQ_MASK,
.ipi = &apu_ipi, .ipi = &apu_ipi,
}, },
{ {
.node_id = NODE_APU_3, .node_id = (uint32_t)NODE_APU_3,
.pwrdn_mask = APU_3_PWRCTL_CPUPWRDWNREQ_MASK, .pwrdn_mask = APU_3_PWRCTL_CPUPWRDWNREQ_MASK,
.ipi = &apu_ipi, .ipi = &apu_ipi,
}, },
@ -206,9 +206,10 @@ static void pm_client_set_wakeup_sources(void)
while (reg != 0U) { while (reg != 0U) {
enum pm_node_id node; enum pm_node_id node;
uint32_t idx, ret, irq, lowest_set = reg & (-reg); uint32_t idx, irq, lowest_set = reg & (-reg);
enum pm_ret_status ret;
idx = __builtin_ctz(lowest_set); idx = (uint32_t)__builtin_ctz(lowest_set);
irq = base_irq + idx; irq = base_irq + idx;
if (irq > IRQ_MAX) { if (irq > IRQ_MAX) {

186
plat/xilinx/zynqmp/pm_service/zynqmp_pm_api_sys.c
View file

@ -51,164 +51,164 @@ typedef struct __attribute__((packed)) {
/* Dependent APIs for TF-A to check their version from firmware */ /* Dependent APIs for TF-A to check their version from firmware */
static const eemi_api_dependency api_dep_table[] = { static const eemi_api_dependency api_dep_table[] = {
{ {
.id = PM_SELF_SUSPEND, .id = (uint8_t)PM_SELF_SUSPEND,
.api_id = PM_SELF_SUSPEND, .api_id = (uint8_t)PM_SELF_SUSPEND,
}, },
{ {
.id = PM_REQ_WAKEUP, .id = (uint8_t)PM_REQ_WAKEUP,
.api_id = PM_REQ_WAKEUP, .api_id = (uint8_t)PM_REQ_WAKEUP,
}, },
{ {
.id = PM_ABORT_SUSPEND, .id = (uint8_t)PM_ABORT_SUSPEND,
.api_id = PM_ABORT_SUSPEND, .api_id = (uint8_t)PM_ABORT_SUSPEND,
}, },
{ {
.id = PM_SET_WAKEUP_SOURCE, .id = (uint8_t)PM_SET_WAKEUP_SOURCE,
.api_id = PM_SET_WAKEUP_SOURCE, .api_id = (uint8_t)PM_SET_WAKEUP_SOURCE,
}, },
{ {
.id = PM_SYSTEM_SHUTDOWN, .id = (uint8_t)PM_SYSTEM_SHUTDOWN,
.api_id = PM_SYSTEM_SHUTDOWN, .api_id = (uint8_t)PM_SYSTEM_SHUTDOWN,
}, },
{ {
.id = PM_GET_API_VERSION, .id = (uint8_t)PM_GET_API_VERSION,
.api_id = PM_GET_API_VERSION, .api_id = (uint8_t)PM_GET_API_VERSION,
}, },
{ {
.id = PM_CLOCK_ENABLE, .id = (uint8_t)PM_CLOCK_ENABLE,
.api_id = PM_PLL_SET_MODE, .api_id = (uint8_t)PM_PLL_SET_MODE,
}, },
{ {
.id = PM_CLOCK_ENABLE, .id = (uint8_t)PM_CLOCK_ENABLE,
.api_id = PM_CLOCK_ENABLE, .api_id = (uint8_t)PM_CLOCK_ENABLE,
}, },
{ {
.id = PM_CLOCK_DISABLE, .id = (uint8_t)PM_CLOCK_DISABLE,
.api_id = PM_PLL_SET_MODE, .api_id = (uint8_t)PM_PLL_SET_MODE,
}, },
{ {
.id = PM_CLOCK_DISABLE, .id = (uint8_t)PM_CLOCK_DISABLE,
.api_id = PM_CLOCK_DISABLE, .api_id = (uint8_t)PM_CLOCK_DISABLE,
}, },
{ {
.id = PM_CLOCK_GETSTATE, .id = (uint8_t)PM_CLOCK_GETSTATE,
.api_id = PM_PLL_GET_MODE, .api_id = (uint8_t)PM_PLL_GET_MODE,
}, },
{ {
.id = PM_CLOCK_GETSTATE, .id = (uint8_t)PM_CLOCK_GETSTATE,
.api_id = PM_CLOCK_GETSTATE, .api_id = (uint8_t)PM_CLOCK_GETSTATE,
}, },
{ {
.id = PM_CLOCK_SETDIVIDER, .id = (uint8_t)PM_CLOCK_SETDIVIDER,
.api_id = PM_PLL_SET_PARAMETER, .api_id = (uint8_t)PM_PLL_SET_PARAMETER,
}, },
{ {
.id = PM_CLOCK_SETDIVIDER, .id = (uint8_t)PM_CLOCK_SETDIVIDER,
.api_id = PM_CLOCK_SETDIVIDER, .api_id = (uint8_t)PM_CLOCK_SETDIVIDER,
}, },
{ {
.id = PM_CLOCK_GETDIVIDER, .id = (uint8_t)PM_CLOCK_GETDIVIDER,
.api_id = PM_PLL_GET_PARAMETER, .api_id = (uint8_t)PM_PLL_GET_PARAMETER,
}, },
{ {
.id = PM_CLOCK_GETDIVIDER, .id = (uint8_t)PM_CLOCK_GETDIVIDER,
.api_id = PM_CLOCK_GETDIVIDER, .api_id = (uint8_t)PM_CLOCK_GETDIVIDER,
}, },
{ {
.id = PM_CLOCK_SETPARENT, .id = (uint8_t)PM_CLOCK_SETPARENT,
.api_id = PM_PLL_SET_PARAMETER, .api_id = (uint8_t)PM_PLL_SET_PARAMETER,
}, },
{ {
.id = PM_CLOCK_SETPARENT, .id = (uint8_t)PM_CLOCK_SETPARENT,
.api_id = PM_CLOCK_SETPARENT, .api_id = (uint8_t)PM_CLOCK_SETPARENT,
}, },
{ {
.id = PM_CLOCK_GETPARENT, .id = (uint8_t)PM_CLOCK_GETPARENT,
.api_id = PM_PLL_GET_PARAMETER, .api_id = (uint8_t)PM_PLL_GET_PARAMETER,
}, },
{ {
.id = PM_CLOCK_GETPARENT, .id = (uint8_t)PM_CLOCK_GETPARENT,
.api_id = PM_CLOCK_GETPARENT, .api_id = (uint8_t)PM_CLOCK_GETPARENT,
}, },
{ {
.id = PM_PLL_SET_PARAMETER, .id = (uint8_t)PM_PLL_SET_PARAMETER,
.api_id = PM_PLL_SET_PARAMETER, .api_id = (uint8_t)PM_PLL_SET_PARAMETER,
}, },
{ {
.id = PM_PLL_GET_PARAMETER, .id = (uint8_t)PM_PLL_GET_PARAMETER,
.api_id = PM_PLL_GET_PARAMETER, .api_id = (uint8_t)PM_PLL_GET_PARAMETER,
}, },
{ {
.id = PM_PLL_SET_MODE, .id = (uint8_t)PM_PLL_SET_MODE,
.api_id = PM_PLL_SET_MODE, .api_id = (uint8_t)PM_PLL_SET_MODE,
}, },
{ {
.id = PM_PLL_GET_MODE, .id = (uint8_t)PM_PLL_GET_MODE,
.api_id = PM_PLL_GET_MODE, .api_id = (uint8_t)PM_PLL_GET_MODE,
}, },
{ {
.id = PM_REGISTER_ACCESS, .id = (uint8_t)PM_REGISTER_ACCESS,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = PM_REGISTER_ACCESS, .id = (uint8_t)PM_REGISTER_ACCESS,
.api_id = PM_MMIO_READ, .api_id = (uint8_t)PM_MMIO_READ,
}, },
{ {
.id = PM_FEATURE_CHECK, .id = (uint8_t)PM_FEATURE_CHECK,
.api_id = PM_FEATURE_CHECK, .api_id = (uint8_t)PM_FEATURE_CHECK,
}, },
{ {
.id = IOCTL_SET_TAPDELAY_BYPASS, .id = (uint8_t)IOCTL_SET_TAPDELAY_BYPASS,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_SD_DLL_RESET, .id = (uint8_t)IOCTL_SD_DLL_RESET,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_SET_SD_TAPDELAY, .id = (uint8_t)IOCTL_SET_SD_TAPDELAY,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_SET_SD_TAPDELAY, .id = (uint8_t)IOCTL_SET_SD_TAPDELAY,
.api_id = PM_MMIO_READ, .api_id = (uint8_t)PM_MMIO_READ,
}, },
{ {
.id = IOCTL_SET_PLL_FRAC_DATA, .id = (uint8_t)IOCTL_SET_PLL_FRAC_DATA,
.api_id = PM_PLL_SET_PARAMETER, .api_id = (uint8_t)PM_PLL_SET_PARAMETER,
}, },
{ {
.id = IOCTL_GET_PLL_FRAC_DATA, .id = (uint8_t)IOCTL_GET_PLL_FRAC_DATA,
.api_id = PM_PLL_GET_PARAMETER, .api_id = (uint8_t)PM_PLL_GET_PARAMETER,
}, },
{ {
.id = IOCTL_WRITE_GGS, .id = (uint8_t)IOCTL_WRITE_GGS,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_READ_GGS, .id = (uint8_t)IOCTL_READ_GGS,
.api_id = PM_MMIO_READ, .api_id = (uint8_t)PM_MMIO_READ,
}, },
{ {
.id = IOCTL_WRITE_PGGS, .id = (uint8_t)IOCTL_WRITE_PGGS,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_READ_PGGS, .id = (uint8_t)IOCTL_READ_PGGS,
.api_id = PM_MMIO_READ, .api_id = (uint8_t)PM_MMIO_READ,
}, },
{ {
.id = IOCTL_ULPI_RESET, .id = (uint8_t)IOCTL_ULPI_RESET,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_SET_BOOT_HEALTH_STATUS, .id = (uint8_t)IOCTL_SET_BOOT_HEALTH_STATUS,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
{ {
.id = IOCTL_AFI, .id = (uint8_t)IOCTL_AFI,
.api_id = PM_MMIO_WRITE, .api_id = (uint8_t)PM_MMIO_WRITE,
}, },
}; };
@ -770,7 +770,7 @@ enum pm_ret_status check_api_dependency(uint8_t id)
{ {
uint8_t i; uint8_t i;
uint32_t version_type; uint32_t version_type;
int ret; enum pm_ret_status ret;
for (i = 0U; i < ARRAY_SIZE(api_dep_table); i++) { for (i = 0U; i < ARRAY_SIZE(api_dep_table); i++) {
if (api_dep_table[i].id == id) { if (api_dep_table[i].id == id) {
@ -1521,47 +1521,47 @@ void pm_query_data(enum pm_query_ids qid, uint32_t arg1, uint32_t arg2,
pm_clock_get_name(arg1, (char *)data); pm_clock_get_name(arg1, (char *)data);
break; break;
case PM_QID_CLOCK_GET_TOPOLOGY: case PM_QID_CLOCK_GET_TOPOLOGY:
data[0] = pm_clock_get_topology(arg1, arg2, &data[1]); data[0] = (uint32_t)pm_clock_get_topology(arg1, arg2, &data[1]);
break; break;
case PM_QID_CLOCK_GET_FIXEDFACTOR_PARAMS: case PM_QID_CLOCK_GET_FIXEDFACTOR_PARAMS:
data[0] = pm_clock_get_fixedfactor_params(arg1, &data[1], data[0] = (uint32_t)pm_clock_get_fixedfactor_params(arg1, &data[1],
&data[2]); &data[2]);
break; break;
case PM_QID_CLOCK_GET_PARENTS: case PM_QID_CLOCK_GET_PARENTS:
data[0] = pm_clock_get_parents(arg1, arg2, &data[1]); data[0] = (uint32_t)pm_clock_get_parents(arg1, arg2, &data[1]);
break; break;
case PM_QID_CLOCK_GET_ATTRIBUTES: case PM_QID_CLOCK_GET_ATTRIBUTES:
data[0] = pm_clock_get_attributes(arg1, &data[1]); data[0] = (uint32_t)pm_clock_get_attributes(arg1, &data[1]);
break; break;
case PM_QID_PINCTRL_GET_NUM_PINS: case PM_QID_PINCTRL_GET_NUM_PINS:
data[0] = pm_pinctrl_get_num_pins(&data[1]); data[0] = (uint32_t)pm_pinctrl_get_num_pins(&data[1]);
break; break;
case PM_QID_PINCTRL_GET_NUM_FUNCTIONS: case PM_QID_PINCTRL_GET_NUM_FUNCTIONS:
data[0] = pm_pinctrl_get_num_functions(&data[1]); data[0] = (uint32_t)pm_pinctrl_get_num_functions(&data[1]);
break; break;
case PM_QID_PINCTRL_GET_NUM_FUNCTION_GROUPS: case PM_QID_PINCTRL_GET_NUM_FUNCTION_GROUPS:
data[0] = pm_pinctrl_get_num_function_groups(arg1, &data[1]); data[0] = (uint32_t)pm_pinctrl_get_num_function_groups(arg1, &data[1]);
break; break;
case PM_QID_PINCTRL_GET_FUNCTION_NAME: case PM_QID_PINCTRL_GET_FUNCTION_NAME:
pm_pinctrl_get_function_name(arg1, (char *)data); pm_pinctrl_get_function_name(arg1, (char *)data);
break; break;
case PM_QID_PINCTRL_GET_FUNCTION_GROUPS: case PM_QID_PINCTRL_GET_FUNCTION_GROUPS:
data[0] = pm_pinctrl_get_function_groups(arg1, arg2, data[0] = (uint32_t)pm_pinctrl_get_function_groups(arg1, arg2,
(uint16_t *)&data[1]); (uint16_t *)&data[1]);
break; break;
case PM_QID_PINCTRL_GET_PIN_GROUPS: case PM_QID_PINCTRL_GET_PIN_GROUPS:
data[0] = pm_pinctrl_get_pin_groups(arg1, arg2, data[0] = (uint32_t)pm_pinctrl_get_pin_groups(arg1, arg2,
(uint16_t *)&data[1]); (uint16_t *)&data[1]);
break; break;
case PM_QID_CLOCK_GET_NUM_CLOCKS: case PM_QID_CLOCK_GET_NUM_CLOCKS:
data[0] = pm_clock_get_num_clocks(&data[1]); data[0] = (uint32_t)pm_clock_get_num_clocks(&data[1]);
break; break;
case PM_QID_CLOCK_GET_MAX_DIVISOR: case PM_QID_CLOCK_GET_MAX_DIVISOR:
data[0] = pm_clock_get_max_divisor(arg1, arg2, &data[1]); data[0] = (uint32_t)pm_clock_get_max_divisor(arg1, (uint8_t)arg2, &data[1]);
break; break;
default: default:
data[0] = PM_RET_ERROR_ARGS; data[0] = (uint32_t)PM_RET_ERROR_ARGS;
WARN("Unimplemented query service call: 0x%x\n", qid); WARN("Unimplemented query service call: 0x%x\n", qid);
break; break;
} }

6
plat/xilinx/zynqmp/pm_service/zynqmp_pm_defs.h
View file

@ -187,9 +187,9 @@ enum pm_shutdown_type {
* *
*/ */
enum pm_shutdown_subtype { enum pm_shutdown_subtype {
PMF_SHUTDOWN_SUBTYPE_SUBSYSTEM, PMF_SHUTDOWN_SUBTYPE_SUBSYSTEM = (0U),
PMF_SHUTDOWN_SUBTYPE_PS_ONLY, PMF_SHUTDOWN_SUBTYPE_PS_ONLY = (1U),
PMF_SHUTDOWN_SUBTYPE_SYSTEM, PMF_SHUTDOWN_SUBTYPE_SYSTEM = (2U),
}; };
/** /**

2
plat/xilinx/zynqmp/pm_service/zynqmp_pm_svc_main.c
View file

@ -560,7 +560,7 @@ uint64_t pm_smc_handler(uint32_t smc_fid, uint64_t x1, uint64_t x2, uint64_t x3,
uint32_t bit_mask[2] = {0}; uint32_t bit_mask[2] = {0};
ret = pm_feature_check(pm_arg[0], &version_type, bit_mask, ret = pm_feature_check(pm_arg[0], &version_type, bit_mask,
ARRAY_SIZE(bit_mask)); (uint8_t)ARRAY_SIZE(bit_mask));
SMC_RET2(handle, ((uint64_t)ret | ((uint64_t)version_type << 32U)), SMC_RET2(handle, ((uint64_t)ret | ((uint64_t)version_type << 32U)),
((uint64_t)bit_mask[0] | ((uint64_t)bit_mask[1] << 32U))); ((uint64_t)bit_mask[0] | ((uint64_t)bit_mask[1] << 32U)));
} }