To support hardware without subsys IDs on new SoCs, add a programming
flow that checks whether the subsys ID is valid.

If the subsys ID is valid, the flow will call cmdq_pkt_write_subsys()
and cmdq_pkt_write_mask_subsys() instead of the original
cmdq_pkt_write() and cmdq_pkt_write_mask().

If the subsys ID is invalid, the flow will call cmdq_pkt_write_pa() and
cmdq_pkt_write_mask_pa() to achieve the same functionality.

Signed-off-by: Jason-JH Lin <jason-jh....@mediatek.com>
---
 .../platform/mediatek/mdp3/mtk-mdp3-cmdq.c    | 14 +++-
 .../platform/mediatek/mdp3/mtk-mdp3-comp.h    | 70 ++++++++++++++-----
 2 files changed, 64 insertions(+), 20 deletions(-)

diff --git a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-cmdq.c 
b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-cmdq.c
index c4e0d376a055..c35fe0e3a4d5 100644
--- a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-cmdq.c
+++ b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-cmdq.c
@@ -321,7 +321,12 @@ static int mdp_path_config_subfrm(struct mdp_cmdq_cmd *cmd,
        /* Enable mux settings */
        for (index = 0; index < ctrl->num_sets; index++) {
                set = &ctrl->sets[index];
-               cmdq_pkt_write(&cmd->pkt, set->subsys_id, set->reg, set->value);
+               if (set->subsys_id != CMDQ_SUBSYS_INVALID)
+                       cmdq_pkt_write_subsys(&cmd->pkt, set->subsys_id, 
set->reg,
+                                             set->reg, set->value);
+               else /* only MMIO access, no need to check mminfro_offset */
+                       cmdq_pkt_write_pa(&cmd->pkt, set->subsys_id, set->reg,
+                                         set->reg, set->value);
        }
        /* Config sub-frame information */
        for (index = (num_comp - 1); index >= 0; index--) {
@@ -376,7 +381,12 @@ static int mdp_path_config_subfrm(struct mdp_cmdq_cmd *cmd,
        /* Disable mux settings */
        for (index = 0; index < ctrl->num_sets; index++) {
                set = &ctrl->sets[index];
-               cmdq_pkt_write(&cmd->pkt, set->subsys_id, set->reg, 0);
+               if (set->subsys_id != CMDQ_SUBSYS_INVALID)
+                       cmdq_pkt_write_subsys(&cmd->pkt, set->subsys_id, 
set->reg,
+                                             set->reg, 0);
+               else /* only MMIO access, no need to check mminfro_offset */
+                       cmdq_pkt_write_pa(&cmd->pkt, set->subsys_id, set->reg,
+                                         set->reg, 0);
        }
 
        return 0;
diff --git a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.h 
b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.h
index 681906c16419..ea65a988a26b 100644
--- a/drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.h
+++ b/drivers/media/platform/mediatek/mdp3/mtk-mdp3-comp.h
@@ -9,17 +9,35 @@
 
 #include "mtk-mdp3-cmdq.h"
 
-#define MM_REG_WRITE_MASK(cmd, id, base, ofst, val, mask)      \
-do {                                                           \
-       typeof(mask) (m) = (mask);                              \
-       cmdq_pkt_write_mask(&((cmd)->pkt), id, (base) + (ofst), \
-                           (val),                              \
-               (((m) & (ofst##_MASK)) == (ofst##_MASK)) ?      \
-                       (0xffffffff) : (m));                    \
+#define MM_REG_WRITE_MASK(cmd, id, base, ofst, val, mask)              \
+do {                                                                   \
+       typeof(cmd) (_c) = (cmd);                                       \
+       typeof(id) (_i) = (id);                                         \
+       typeof(base) (_b) = (base);                                     \
+       typeof(ofst) (_o) = (ofst);                                     \
+       typeof(val) (_v) = (val);                                       \
+       typeof(mask) (_m) = (mask);                                     \
+       _m = ((_m & (ofst##_MASK)) == (ofst##_MASK)) ? 0xffffffff : _m; \
+       if (_i != CMDQ_SUBSYS_INVALID)                                  \
+               cmdq_pkt_write_mask_subsys(&_c->pkt, _i, _b, _b + _o,   \
+                                          _v, _m);                     \
+       else /* only MMIO access, no need to check mminfro_offset */    \
+               cmdq_pkt_write_mask_pa(&_c->pkt, _i, _b, _b + _o,       \
+                                      _v, _m);                         \
 } while (0)
 
-#define MM_REG_WRITE(cmd, id, base, ofst, val)                 \
-       cmdq_pkt_write(&((cmd)->pkt), id, (base) + (ofst), (val))
+#define MM_REG_WRITE(cmd, id, base, ofst, val)                         \
+do {                                                                   \
+       typeof(cmd) (_c) = (cmd);                                       \
+       typeof(id) (_i) = (id);                                         \
+       typeof(base) (_b) = (base);                                     \
+       typeof(ofst) (_o) = (ofst);                                     \
+       typeof(val) (_v) = (val);                                       \
+       if (_i != CMDQ_SUBSYS_INVALID)                                  \
+               cmdq_pkt_write_subsys(&_c->pkt, _i, _b, _b + _o, _v);   \
+       else /* only MMIO access, no need to check mminfro_offset */    \
+               cmdq_pkt_write_pa(&_c->pkt, _i, _b, _b + _o, _v);       \
+} while (0)
 
 #define MM_REG_WAIT(cmd, evt)                                  \
 do {                                                           \
@@ -49,17 +67,33 @@ do {                                                        
        \
        cmdq_pkt_set_event(&((c)->pkt), (e));                   \
 } while (0)
 
-#define MM_REG_POLL_MASK(cmd, id, base, ofst, val, _mask)      \
-do {                                                           \
-       typeof(_mask) (_m) = (_mask);                           \
-       cmdq_pkt_poll_mask(&((cmd)->pkt), id,                   \
-               (base) + (ofst), (val),                         \
-               (((_m) & (ofst##_MASK)) == (ofst##_MASK)) ?     \
-                       (0xffffffff) : (_m));                   \
+#define MM_REG_POLL_MASK(cmd, id, base, ofst, val, mask)               \
+do {                                                                   \
+       typeof(cmd) (_c) = (cmd);                                       \
+       typeof(id) (_i) = (id);                                         \
+       typeof(base) (_b) = (base);                                     \
+       typeof(ofst) (_o) = (ofst);                                     \
+       typeof(val) (_v) = (val);                                       \
+       typeof(mask) (_m) = (mask);                                     \
+       _m = ((_m & (ofst##_MASK)) == (ofst##_MASK)) ? 0xffffffff : _m; \
+       if (_i != CMDQ_SUBSYS_INVALID)                                  \
+               cmdq_pkt_poll_mask(&_c->pkt, _i, _b + _o, _v, _m);      \
+       else /* POLL not support SPR, so use cmdq_pkt_poll_addr() */    \
+               cmdq_pkt_poll_addr(&_c->pkt, _b + _o, _v, _m);          \
 } while (0)
 
-#define MM_REG_POLL(cmd, id, base, ofst, val)                  \
-       cmdq_pkt_poll(&((cmd)->pkt), id, (base) + (ofst), (val))
+#define MM_REG_POLL(cmd, id, base, ofst, val)                          \
+do {                                                                   \
+       typeof(cmd) (_c) = (cmd);                                       \
+       typeof(id) (_i) = (id);                                         \
+       typeof(base) (_b) = (base);                                     \
+       typeof(ofst) (_o) = (ofst);                                     \
+       typeof(val) (_v) = (val);                                       \
+       if (_i != CMDQ_SUBSYS_INVALID)                                  \
+               cmdq_pkt_poll(&_c->pkt, _i, _b + _o, _v);               \
+       else /* POLL not support SPR, so use cmdq_pkt_poll_addr() */    \
+               cmdq_pkt_poll_addr(&_c->pkt, _b + _o, _v, 0xffffffff);  \
+} while (0)
 
 enum mtk_mdp_comp_id {
        MDP_COMP_NONE = -1,     /* Invalid engine */
-- 
2.43.0

Reply via email to