soc: mediatek: mtk-cmdq: Move cmdq_instruction init to declaration

Move, where possible, the initialization of struct cmdq_instruction
variables to their declaration to compress the code.

While at it, also change an instance of open-coded mask to use the
GENMASK() macro instead, and instances of `ret = func(); return ret;`
to the equivalent (but shorter) `return func()`.

Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>

diff --git a/drivers/soc/mediatek/mtk-cmdq-helper.c b/drivers/soc/mediatek/mtk-cmdq-helper.c
index 620c371fd1fc5b90a95674d44d6eb21a27021668..0a05ee87a0fce836f16a0a86508bd72e50b8e801 100644 (file)
--- a/drivers/soc/mediatek/mtk-cmdq-helper.c
+++ b/drivers/soc/mediatek/mtk-cmdq-helper.c
@@ -191,13 +191,12 @@ static int cmdq_pkt_mask(struct cmdq_pkt *pkt, u32 mask)
 
 int cmdq_pkt_write(struct cmdq_pkt *pkt, u8 subsys, u16 offset, u32 value)
 {
-       struct cmdq_instruction inst;
-
-       inst.op = CMDQ_CODE_WRITE;
-       inst.value = value;
-       inst.offset = offset;
-       inst.subsys = subsys;
-
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WRITE,
+               .value = value,
+               .offset = offset,
+               .subsys = subsys
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_write);
@@ -208,30 +207,27 @@ int cmdq_pkt_write_mask(struct cmdq_pkt *pkt, u8 subsys,
        u16 offset_mask = offset;
        int err;
 
-       if (mask != 0xffffffff) {
+       if (mask != GENMASK(31, 0)) {
                err = cmdq_pkt_mask(pkt, mask);
                if (err < 0)
                        return err;
 
                offset_mask |= CMDQ_WRITE_ENABLE_MASK;
        }
-       err = cmdq_pkt_write(pkt, subsys, offset_mask, value);
-
-       return err;
+       return cmdq_pkt_write(pkt, subsys, offset_mask, value);
 }
 EXPORT_SYMBOL(cmdq_pkt_write_mask);
 
 int cmdq_pkt_read_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx, u16 addr_low,
                    u16 reg_idx)
 {
-       struct cmdq_instruction inst = {};
-
-       inst.op = CMDQ_CODE_READ_S;
-       inst.dst_t = CMDQ_REG_TYPE;
-       inst.sop = high_addr_reg_idx;
-       inst.reg_dst = reg_idx;
-       inst.src_reg = addr_low;
-
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_READ_S,
+               .dst_t = CMDQ_REG_TYPE,
+               .sop = high_addr_reg_idx,
+               .reg_dst = reg_idx,
+               .src_reg = addr_low
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_read_s);
@@ -239,14 +235,13 @@ EXPORT_SYMBOL(cmdq_pkt_read_s);
 int cmdq_pkt_write_s(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
                     u16 addr_low, u16 src_reg_idx)
 {
-       struct cmdq_instruction inst = {};
-
-       inst.op = CMDQ_CODE_WRITE_S;
-       inst.src_t = CMDQ_REG_TYPE;
-       inst.sop = high_addr_reg_idx;
-       inst.offset = addr_low;
-       inst.src_reg = src_reg_idx;
-
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WRITE_S,
+               .src_t = CMDQ_REG_TYPE,
+               .sop = high_addr_reg_idx,
+               .offset = addr_low,
+               .src_reg = src_reg_idx
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_write_s);
@@ -254,20 +249,19 @@ EXPORT_SYMBOL(cmdq_pkt_write_s);
 int cmdq_pkt_write_s_mask(struct cmdq_pkt *pkt, u16 high_addr_reg_idx,
                          u16 addr_low, u16 src_reg_idx, u32 mask)
 {
-       struct cmdq_instruction inst = {};
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WRITE_S_MASK,
+               .src_t = CMDQ_REG_TYPE,
+               .sop = high_addr_reg_idx,
+               .offset = addr_low,
+               .src_reg = src_reg_idx,
+       };
        int err;
 
        err = cmdq_pkt_mask(pkt, mask);
        if (err < 0)
                return err;
 
-       inst.mask = 0;
-       inst.op = CMDQ_CODE_WRITE_S_MASK;
-       inst.src_t = CMDQ_REG_TYPE;
-       inst.sop = high_addr_reg_idx;
-       inst.offset = addr_low;
-       inst.src_reg = src_reg_idx;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_write_s_mask);
@@ -275,13 +269,12 @@ EXPORT_SYMBOL(cmdq_pkt_write_s_mask);
 int cmdq_pkt_write_s_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
                           u16 addr_low, u32 value)
 {
-       struct cmdq_instruction inst = {};
-
-       inst.op = CMDQ_CODE_WRITE_S;
-       inst.sop = high_addr_reg_idx;
-       inst.offset = addr_low;
-       inst.value = value;
-
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WRITE_S,
+               .sop = high_addr_reg_idx,
+               .offset = addr_low,
+               .value = value
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_write_s_value);
@@ -289,18 +282,18 @@ EXPORT_SYMBOL(cmdq_pkt_write_s_value);
 int cmdq_pkt_write_s_mask_value(struct cmdq_pkt *pkt, u8 high_addr_reg_idx,
                                u16 addr_low, u32 value, u32 mask)
 {
-       struct cmdq_instruction inst = {};
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WRITE_S_MASK,
+               .sop = high_addr_reg_idx,
+               .offset = addr_low,
+               .value = value
+       };
        int err;
 
        err = cmdq_pkt_mask(pkt, mask);
        if (err < 0)
                return err;
 
-       inst.op = CMDQ_CODE_WRITE_S_MASK;
-       inst.sop = high_addr_reg_idx;
-       inst.offset = addr_low;
-       inst.value = value;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_write_s_mask_value);
@@ -333,61 +326,61 @@ EXPORT_SYMBOL(cmdq_pkt_mem_move);
 
 int cmdq_pkt_wfe(struct cmdq_pkt *pkt, u16 event, bool clear)
 {
-       struct cmdq_instruction inst = { {0} };
        u32 clear_option = clear ? CMDQ_WFE_UPDATE : 0;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WFE,
+               .value = CMDQ_WFE_OPTION | clear_option,
+               .event = event
+       };
 
        if (event >= CMDQ_MAX_EVENT)
                return -EINVAL;
 
-       inst.op = CMDQ_CODE_WFE;
-       inst.value = CMDQ_WFE_OPTION | clear_option;
-       inst.event = event;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_wfe);
 
 int cmdq_pkt_acquire_event(struct cmdq_pkt *pkt, u16 event)
 {
-       struct cmdq_instruction inst = {};
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WFE,
+               .value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE | CMDQ_WFE_WAIT,
+               .event = event
+       };
 
        if (event >= CMDQ_MAX_EVENT)
                return -EINVAL;
 
-       inst.op = CMDQ_CODE_WFE;
-       inst.value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE | CMDQ_WFE_WAIT;
-       inst.event = event;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_acquire_event);
 
 int cmdq_pkt_clear_event(struct cmdq_pkt *pkt, u16 event)
 {
-       struct cmdq_instruction inst = { {0} };
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WFE,
+               .value = CMDQ_WFE_UPDATE,
+               .event = event
+       };
 
        if (event >= CMDQ_MAX_EVENT)
                return -EINVAL;
 
-       inst.op = CMDQ_CODE_WFE;
-       inst.value = CMDQ_WFE_UPDATE;
-       inst.event = event;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_clear_event);
 
 int cmdq_pkt_set_event(struct cmdq_pkt *pkt, u16 event)
 {
-       struct cmdq_instruction inst = {};
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_WFE,
+               .value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE,
+               .event = event
+       };
 
        if (event >= CMDQ_MAX_EVENT)
                return -EINVAL;
 
-       inst.op = CMDQ_CODE_WFE;
-       inst.value = CMDQ_WFE_UPDATE | CMDQ_WFE_UPDATE_VALUE;
-       inst.event = event;
-
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_set_event);
@@ -395,16 +388,13 @@ EXPORT_SYMBOL(cmdq_pkt_set_event);
 int cmdq_pkt_poll(struct cmdq_pkt *pkt, u8 subsys,
                  u16 offset, u32 value)
 {
-       struct cmdq_instruction inst = { {0} };
-       int err;
-
-       inst.op = CMDQ_CODE_POLL;
-       inst.value = value;
-       inst.offset = offset;
-       inst.subsys = subsys;
-       err = cmdq_pkt_append_command(pkt, inst);
-
-       return err;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_POLL,
+               .value = value,
+               .offset = offset,
+               .subsys = subsys
+       };
+       return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_poll);
 
@@ -418,9 +408,7 @@ int cmdq_pkt_poll_mask(struct cmdq_pkt *pkt, u8 subsys,
                return err;
 
        offset = offset | CMDQ_POLL_ENABLE_MASK;
-       err = cmdq_pkt_poll(pkt, subsys, offset, value);
-
-       return err;
+       return cmdq_pkt_poll(pkt, subsys, offset, value);
 }
 EXPORT_SYMBOL(cmdq_pkt_poll_mask);
 
@@ -474,11 +462,12 @@ int cmdq_pkt_logic_command(struct cmdq_pkt *pkt, u16 result_reg_idx,
                           enum cmdq_logic_op s_op,
                           struct cmdq_operand *right_operand)
 {
-       struct cmdq_instruction inst = { {0} };
+       struct cmdq_instruction inst;
 
        if (!left_operand || !right_operand || s_op >= CMDQ_LOGIC_MAX)
                return -EINVAL;
 
+       inst.value = 0;
        inst.op = CMDQ_CODE_LOGIC;
        inst.dst_t = CMDQ_REG_TYPE;
        inst.src_t = cmdq_operand_get_type(left_operand);
@@ -494,43 +483,43 @@ EXPORT_SYMBOL(cmdq_pkt_logic_command);
 
 int cmdq_pkt_assign(struct cmdq_pkt *pkt, u16 reg_idx, u32 value)
 {
-       struct cmdq_instruction inst = {};
-
-       inst.op = CMDQ_CODE_LOGIC;
-       inst.dst_t = CMDQ_REG_TYPE;
-       inst.reg_dst = reg_idx;
-       inst.value = value;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_LOGIC,
+               .dst_t = CMDQ_REG_TYPE,
+               .reg_dst = reg_idx,
+               .value = value
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_assign);
 
 int cmdq_pkt_jump_abs(struct cmdq_pkt *pkt, dma_addr_t addr, u8 shift_pa)
 {
-       struct cmdq_instruction inst = {};
-
-       inst.op = CMDQ_CODE_JUMP;
-       inst.offset = CMDQ_JUMP_ABSOLUTE;
-       inst.value = addr >> shift_pa;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_JUMP,
+               .offset = CMDQ_JUMP_ABSOLUTE,
+               .value = addr >> shift_pa
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_jump_abs);
 
 int cmdq_pkt_jump_rel(struct cmdq_pkt *pkt, s32 offset, u8 shift_pa)
 {
-       struct cmdq_instruction inst = { {0} };
-
-       inst.op = CMDQ_CODE_JUMP;
-       inst.value = (u32)offset >> shift_pa;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_JUMP,
+               .value = (u32)offset >> shift_pa
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_jump_rel);
 
 int cmdq_pkt_eoc(struct cmdq_pkt *pkt)
 {
-       struct cmdq_instruction inst = { {0} };
-
-       inst.op = CMDQ_CODE_EOC;
-       inst.value = CMDQ_EOC_IRQ_EN;
+       struct cmdq_instruction inst = {
+               .op = CMDQ_CODE_EOC,
+               .value = CMDQ_EOC_IRQ_EN
+       };
        return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_eoc);
@@ -541,9 +530,7 @@ int cmdq_pkt_finalize(struct cmdq_pkt *pkt)
        int err;
 
        /* insert EOC and generate IRQ for each command iteration */
-       inst.op = CMDQ_CODE_EOC;
-       inst.value = CMDQ_EOC_IRQ_EN;
-       err = cmdq_pkt_append_command(pkt, inst);
+       err = cmdq_pkt_eoc(pkt);
        if (err < 0)
                return err;
 
@@ -551,9 +538,7 @@ int cmdq_pkt_finalize(struct cmdq_pkt *pkt)
        inst.op = CMDQ_CODE_JUMP;
        inst.value = CMDQ_JUMP_PASS >>
                cmdq_get_shift_pa(((struct cmdq_client *)pkt->cl)->chan);
-       err = cmdq_pkt_append_command(pkt, inst);
-
-       return err;
+       return cmdq_pkt_append_command(pkt, inst);
 }
 EXPORT_SYMBOL(cmdq_pkt_finalize);