src/soc/mediatek/mt8195/apusys_devapc.c

   1 /* SPDX-License-Identifier: GPL-2.0-only OR MIT */
   2
   3 #include <console/console.h>
   4 #include <soc/apusys_devapc.h>
   5 #include <soc/devapc.h>
   6
   7 static const enum domain_id domain_map[] = {
   8         DOMAIN_0, DOMAIN_1, DOMAIN_2,  DOMAIN_3,  DOMAIN_4,  DOMAIN_5,  DOMAIN_6,  DOMAIN_7,
   9         DOMAIN_8, DOMAIN_9, DOMAIN_10, DOMAIN_11, DOMAIN_12, DOMAIN_13, DOMAIN_14, DOMAIN_15,
  10 };
  11
  12 #define DAPC_APU_AO_SYS0_ATTR(...)                                                             \
  13         {                                                                                      \
  14                 {                                                                              \
  15                         DAPC_PERM_ATTR_16(__VA_ARGS__)                                         \
  16                 }                                                                              \
  17         }
  18 #define DAPC_APU_NOC_AO_SYS0_ATTR(...)                                                         \
  19         {                                                                                      \
  20                 {                                                                              \
  21                         DAPC_PERM_ATTR_16(__VA_ARGS__)                                         \
  22                 }                                                                              \
  23         }
  24
  25 /* NOC DAPC */
  26 static const struct apc_apu_dom_16 apusys_noc_dapc[] = {
  27         /* 0 */
  28         DAPC_APU_NOC_AO_SYS0_ATTR("slv00-0", NO_PROTECTION, FORBIDDEN15),
  29         DAPC_APU_NOC_AO_SYS0_ATTR("slv00-1", NO_PROTECTION, FORBIDDEN15),
  30         DAPC_APU_NOC_AO_SYS0_ATTR("slv00-2", NO_PROTECTION, FORBIDDEN15),
  31         DAPC_APU_NOC_AO_SYS0_ATTR("slv01-0", NO_PROTECTION, FORBIDDEN15),
  32         DAPC_APU_NOC_AO_SYS0_ATTR("slv01-1", NO_PROTECTION, FORBIDDEN15),
  33         DAPC_APU_NOC_AO_SYS0_ATTR("slv01-2", NO_PROTECTION, FORBIDDEN15),
  34         DAPC_APU_NOC_AO_SYS0_ATTR("slv03-0", NO_PROTECTION, FORBIDDEN15),
  35         DAPC_APU_NOC_AO_SYS0_ATTR("slv03-1", NO_PROTECTION, FORBIDDEN15),
  36         DAPC_APU_NOC_AO_SYS0_ATTR("slv03-2", NO_PROTECTION, FORBIDDEN15),
  37         DAPC_APU_NOC_AO_SYS0_ATTR("slv03-3", NO_PROTECTION, FORBIDDEN15),
  38
  39         /* 10 */
  40         DAPC_APU_NOC_AO_SYS0_ATTR("slv03-4", NO_PROTECTION, FORBIDDEN15),
  41         DAPC_APU_NOC_AO_SYS0_ATTR("slv04_05_06_07-0", NO_PROTECTION, FORBIDDEN15),
  42         DAPC_APU_NOC_AO_SYS0_ATTR("slv04_05_06_07-1", NO_PROTECTION, FORBIDDEN15),
  43         DAPC_APU_NOC_AO_SYS0_ATTR("slv04_05_06_07-2", NO_PROTECTION, FORBIDDEN15),
  44         DAPC_APU_NOC_AO_SYS0_ATTR("slv04_05_06_07-3", NO_PROTECTION, FORBIDDEN15),
  45 };
  46 _Static_assert(ARRAY_SIZE(apusys_noc_dapc) == APUSYS_NOC_DAPC_AO_SLAVE_NUM,
  47                "Wrong size on apusys_noc_dapc");
  48
  49 /* AO DAPC */
  50 static const struct apc_apu_dom_16 apusys_ao_apc[] = {
  51         /* 0 */
  52         DAPC_APU_AO_SYS0_ATTR("apusys_ao-0", NO_PROTECTION, FORBIDDEN15),
  53         DAPC_APU_AO_SYS0_ATTR("apusys_ao-1", NO_PROTECTION, FORBIDDEN15),
  54         DAPC_APU_AO_SYS0_ATTR("apusys_ao-2", SEC_RW_ONLY, FORBIDDEN15),
  55         DAPC_APU_AO_SYS0_ATTR("apusys_ao-3", NO_PROTECTION, FORBIDDEN15),
  56         DAPC_APU_AO_SYS0_ATTR("apusys_ao-4", NO_PROTECTION, FORBIDDEN15),
  57         DAPC_APU_AO_SYS0_ATTR("apusys_ao-5", NO_PROTECTION, FORBIDDEN15),
  58         DAPC_APU_AO_SYS0_ATTR("apusys_ao-6", NO_PROTECTION, FORBIDDEN15),
  59         DAPC_APU_AO_SYS0_ATTR("apusys_ao-8", SEC_RW_ONLY, FORBIDDEN15),
  60         DAPC_APU_AO_SYS0_ATTR("apusys_ao-9", SEC_RW_ONLY, FORBIDDEN15),
  61         DAPC_APU_AO_SYS0_ATTR("md32_apb_s-0", NO_PROTECTION, FORBIDDEN15),
  62
  63         /* 10 */
  64         DAPC_APU_AO_SYS0_ATTR("md32_apb_s-1", NO_PROTECTION, FORBIDDEN15),
  65         DAPC_APU_AO_SYS0_ATTR("md32_apb_s-2", NO_PROTECTION, FORBIDDEN15),
  66         DAPC_APU_AO_SYS0_ATTR("md32_debug_apb", NO_PROTECTION, FORBIDDEN15),
  67         DAPC_APU_AO_SYS0_ATTR("apu_con2_config", NO_PROTECTION, FORBIDDEN15),
  68         DAPC_APU_AO_SYS0_ATTR("apu_con1_config", NO_PROTECTION, FORBIDDEN15),
  69         DAPC_APU_AO_SYS0_ATTR("apu_sctrl_reviscer", SEC_RW_ONLY, FORBIDDEN15),
  70         DAPC_APU_AO_SYS0_ATTR("apu_sema_stimer", NO_PROTECTION, FORBIDDEN15),
  71         DAPC_APU_AO_SYS0_ATTR("apu_emi_config", NO_PROTECTION, FORBIDDEN15),
  72         DAPC_APU_AO_SYS0_ATTR("apu_edma0", NO_PROTECTION, FORBIDDEN15),
  73         DAPC_APU_AO_SYS0_ATTR("apu_edma1", NO_PROTECTION, FORBIDDEN15),
  74
  75         /* 20 */
  76         DAPC_APU_AO_SYS0_ATTR("apu_cpe_sensor", NO_PROTECTION, FORBIDDEN15),
  77         DAPC_APU_AO_SYS0_ATTR("apu_cpe_coef", NO_PROTECTION, FORBIDDEN15),
  78         DAPC_APU_AO_SYS0_ATTR("apu_cpe_ctrl", NO_PROTECTION, FORBIDDEN15),
  79         DAPC_APU_AO_SYS0_ATTR("apu_sensor_wrp_dla_0", NO_PROTECTION, FORBIDDEN15),
  80         DAPC_APU_AO_SYS0_ATTR("apu_sensor_wrp_dla_1", NO_PROTECTION, FORBIDDEN15),
  81         DAPC_APU_AO_SYS0_ATTR("apu_dapc_ao", NO_PROTECTION, FORBIDDEN15),
  82         DAPC_APU_AO_SYS0_ATTR("apu_dapc", NO_PROTECTION, FORBIDDEN15),
  83         DAPC_APU_AO_SYS0_ATTR("infra_bcrm", NO_PROTECTION, FORBIDDEN15),
  84         DAPC_APU_AO_SYS0_ATTR("infra_ao_bcrm", NO_PROTECTION, FORBIDDEN15),
  85         DAPC_APU_AO_SYS0_ATTR("noc_dapc", NO_PROTECTION, FORBIDDEN15),
  86
  87         /* 30 */
  88         DAPC_APU_AO_SYS0_ATTR("apu_noc_bcrm", NO_PROTECTION, FORBIDDEN15),
  89         DAPC_APU_AO_SYS0_ATTR("apu_noc_config_0", NO_PROTECTION, FORBIDDEN, FORBIDDEN,
  90                               NO_PROTECTION, FORBIDDEN12),
  91         DAPC_APU_AO_SYS0_ATTR("apu_noc_config_1", NO_PROTECTION, FORBIDDEN, FORBIDDEN,
  92                               NO_PROTECTION, FORBIDDEN12),
  93         DAPC_APU_AO_SYS0_ATTR("apu_noc_config_2", NO_PROTECTION, FORBIDDEN, FORBIDDEN,
  94                               NO_PROTECTION, FORBIDDEN12),
  95         DAPC_APU_AO_SYS0_ATTR("vpu_core0_config-0", NO_PROTECTION, FORBIDDEN, FORBIDDEN3,
  96                               NO_PROTECTION, FORBIDDEN3, FORBIDDEN7),
  97         DAPC_APU_AO_SYS0_ATTR("vpu_core0_config-1", NO_PROTECTION, FORBIDDEN, FORBIDDEN3,
  98                               NO_PROTECTION, FORBIDDEN3, FORBIDDEN7),
  99         DAPC_APU_AO_SYS0_ATTR("vpu_core1_config-0", NO_PROTECTION, FORBIDDEN, FORBIDDEN3,
 100                               NO_PROTECTION, FORBIDDEN3, FORBIDDEN7),
 101         DAPC_APU_AO_SYS0_ATTR("vpu_core1_config-1", NO_PROTECTION, FORBIDDEN, FORBIDDEN3,
 102                               NO_PROTECTION, FORBIDDEN3, FORBIDDEN7),
 103         DAPC_APU_AO_SYS0_ATTR("mdla0_apb-0", NO_PROTECTION, FORBIDDEN15),
 104         DAPC_APU_AO_SYS0_ATTR("mdla0_apb-1", NO_PROTECTION, FORBIDDEN15),
 105
 106         /* 40 */
 107         DAPC_APU_AO_SYS0_ATTR("mdla0_apb-2", NO_PROTECTION, FORBIDDEN15),
 108         DAPC_APU_AO_SYS0_ATTR("mdla0_apb-3", NO_PROTECTION, FORBIDDEN15),
 109         DAPC_APU_AO_SYS0_ATTR("mdla1_apb-0", NO_PROTECTION, FORBIDDEN15),
 110         DAPC_APU_AO_SYS0_ATTR("mdla1_apb-1", NO_PROTECTION, FORBIDDEN15),
 111         DAPC_APU_AO_SYS0_ATTR("mdla1_apb-2", NO_PROTECTION, FORBIDDEN15),
 112         DAPC_APU_AO_SYS0_ATTR("mdla1_apb-3", NO_PROTECTION, FORBIDDEN15),
 113         DAPC_APU_AO_SYS0_ATTR("apu_iommu0_r0", NO_PROTECTION, FORBIDDEN15),
 114         DAPC_APU_AO_SYS0_ATTR("apu_iommu0_r1", SEC_RW_ONLY, FORBIDDEN15),
 115         DAPC_APU_AO_SYS0_ATTR("apu_iommu0_r2", SEC_RW_ONLY, FORBIDDEN15),
 116         DAPC_APU_AO_SYS0_ATTR("apu_iommu0_r3", SEC_RW_ONLY, FORBIDDEN15),
 117
 118         /* 50 */
 119         DAPC_APU_AO_SYS0_ATTR("apu_iommu0_r4", SEC_RW_ONLY, FORBIDDEN15),
 120         DAPC_APU_AO_SYS0_ATTR("apu_iommu1_r0", NO_PROTECTION, FORBIDDEN15),
 121         DAPC_APU_AO_SYS0_ATTR("apu_iommu1_r1", SEC_RW_ONLY, FORBIDDEN15),
 122         DAPC_APU_AO_SYS0_ATTR("apu_iommu1_r2", SEC_RW_ONLY, FORBIDDEN15),
 123         DAPC_APU_AO_SYS0_ATTR("apu_iommu1_r3", SEC_RW_ONLY, FORBIDDEN15),
 124         DAPC_APU_AO_SYS0_ATTR("apu_iommu1_r4", SEC_RW_ONLY, FORBIDDEN15),
 125         DAPC_APU_AO_SYS0_ATTR("apu_rsi2_config", NO_PROTECTION, FORBIDDEN15),
 126         DAPC_APU_AO_SYS0_ATTR("apu_s0_ssc_config", NO_PROTECTION, FORBIDDEN15),
 127         DAPC_APU_AO_SYS0_ATTR("apu_n0_ssc_config", NO_PROTECTION, FORBIDDEN15),
 128         DAPC_APU_AO_SYS0_ATTR("apu_acp_ssc_config", NO_PROTECTION, FORBIDDEN15),
 129
 130         /* 60 */
 131         DAPC_APU_AO_SYS0_ATTR("apu_s1_ssc_config", NO_PROTECTION, FORBIDDEN15),
 132         DAPC_APU_AO_SYS0_ATTR("apu_n1_ssc_config", NO_PROTECTION, FORBIDDEN15),
 133         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-0", NO_PROTECTION, FORBIDDEN15),
 134         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-1", NO_PROTECTION, FORBIDDEN15),
 135         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-2", NO_PROTECTION, FORBIDDEN15),
 136         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-3", NO_PROTECTION, FORBIDDEN15),
 137         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-4", NO_PROTECTION, FORBIDDEN15),
 138         DAPC_APU_AO_SYS0_ATTR("apu_ao_dbgapb-5", NO_PROTECTION, FORBIDDEN15),
 139         DAPC_APU_AO_SYS0_ATTR("vpu_core0_debug_apb", NO_PROTECTION, FORBIDDEN15),
 140         DAPC_APU_AO_SYS0_ATTR("vpu_core1_debug_apb", NO_PROTECTION, FORBIDDEN15),
 141
 142         /* 70 */
 143         DAPC_APU_AO_SYS0_ATTR("apb_infra_dbg_ctl", NO_PROTECTION, FORBIDDEN15),
 144 };
 145 _Static_assert(ARRAY_SIZE(apusys_ao_apc) == APUSYS_APC_SYS0_AO_SLAVE_NUM,
 146                "Wrong size on apusys_ao_apc");
 147
 148 static int set_slave_noc_dapc(u32 slave, enum domain_id domain_id, enum devapc_perm_type perm)
 149 {
 150         u32 apc_register_index;
 151         u32 apc_set_index;
 152         u32 *base;
 153
 154         if (perm >= PERM_NUM || perm < NO_PROTECTION) {
 155                 printk(BIOS_ERR, "[NOC_DAPC] permission type:%#x is not supported!\n", perm);
 156                 return APUSYS_APC_ERR_PERMISSION_NOT_SUPPORTED;
 157         }
 158
 159         if (slave >= APUSYS_NOC_DAPC_AO_SLAVE_NUM || domain_id >= APUSYS_NOC_DAPC_AO_DOM_NUM) {
 160                 printk(BIOS_ERR, "[NOC_DAPC] %s: %s, %s:%#x, %s:%#x\n", __func__,
 161                        "out of boundary", "slave", slave, "domain_id", domain_id);
 162                 return APUSYS_APC_ERR_OUT_OF_BOUNDARY;
 163         }
 164
 165         apc_register_index = slave / APUSYS_NOC_DAPC_AO_SLAVE_NUM_IN_1_DOM;
 166         apc_set_index = slave % APUSYS_NOC_DAPC_AO_SLAVE_NUM_IN_1_DOM;
 167         base = (void *)((size_t)APUSYS_NOC_DAPC_AO_BASE + domain_id * 0x40 +
 168                         apc_register_index * 4);
 169         clrsetbits32(base, 0x3U << (apc_set_index * 2), perm << (apc_set_index * 2));
 170
 171         return APUSYS_APC_OK;
 172 }
 173
 174 static void dump_apusys_noc_dapc(void)
 175 {
 176         u32 reg_num;
 177         size_t d, i;
 178
 179         reg_num = DIV_ROUND_UP(ARRAY_SIZE(apusys_noc_dapc),
 180                                APUSYS_NOC_DAPC_AO_SLAVE_NUM_IN_1_DOM);
 181         for (d = 0U; d < APUSYS_NOC_DAPC_AO_DOM_NUM; d++) {
 182                 for (i = 0U; i < reg_num; i++)
 183                         printk(BIOS_DEBUG, "[NOCDAPC] D%ld_APC_%ld: %#x\n", d, i,
 184                                read32((void *)(APUSYS_NOC_DAPC_AO_BASE + d * 0x40 + i * 4)));
 185         }
 186         printk(BIOS_DEBUG, "[NOCDAPC] APC_CON: %#x\n", read32(APUSYS_NOC_DAPC_CON));
 187 }
 188
 189 static int set_slave_apc(u32 slave, enum domain_id domain_id, enum devapc_perm_type perm)
 190 {
 191         u32 apc_register_index;
 192         u32 apc_set_index;
 193         u32 *base;
 194
 195         if (perm >= PERM_NUM || perm < NO_PROTECTION) {
 196                 printk(BIOS_ERR, "[APUAPC] perm type:%#x is not supported!\n", perm);
 197                 return APUSYS_APC_ERR_PERMISSION_NOT_SUPPORTED;
 198         }
 199
 200         if (slave >= APUSYS_APC_SYS0_AO_SLAVE_NUM || domain_id >= APUSYS_APC_SYS0_AO_DOM_NUM) {
 201                 printk(BIOS_ERR, "[APUAPC] %s: %s, %s:%#x, %s:%#x\n", __func__,
 202                        "out of boundary", "slave", slave, "domain_id", domain_id);
 203                 return APUSYS_APC_ERR_OUT_OF_BOUNDARY;
 204         }
 205
 206         apc_register_index = slave / APUSYS_APC_SYS0_AO_SLAVE_NUM_IN_1_DOM;
 207         apc_set_index = slave % APUSYS_APC_SYS0_AO_SLAVE_NUM_IN_1_DOM;
 208         base = (void *)((size_t)APUSYS_APC_AO_BASE + domain_id * 0x40 + apc_register_index * 4);
 209
 210         clrsetbits32(base, 0x3U << (apc_set_index * 2), perm << (apc_set_index * 2));
 211
 212         return APUSYS_APC_OK;
 213 }
 214
 215 static void dump_apusys_ao_apc(void)
 216 {
 217         u32 reg_num;
 218         size_t d, i;
 219
 220         reg_num =
 221                 DIV_ROUND_UP(ARRAY_SIZE(apusys_ao_apc), APUSYS_APC_SYS0_AO_SLAVE_NUM_IN_1_DOM);
 222         for (d = 0U; d < APUSYS_APC_SYS0_AO_DOM_NUM; d++) {
 223                 for (i = 0U; i < reg_num; i++)
 224                         printk(BIOS_DEBUG, "[APUAPC] D%ld_APC_%ld: %#x\n", d, i,
 225                                read32((void *)(APUSYS_APC_AO_BASE + d * 0x40 + i * 4)));
 226         }
 227         printk(BIOS_DEBUG, "[APUAPC] APC_CON: %#x\n", read32(APUSYS_APC_CON));
 228 }
 229
 230 static int set_apusys_noc_dapc(void)
 231 {
 232         int ret = APUSYS_APC_OK;
 233         size_t i, j;
 234
 235         for (i = 0; i < ARRAY_SIZE(apusys_noc_dapc); i++) {
 236                 for (j = 0; j < ARRAY_SIZE(apusys_noc_dapc[i].d_permission); j++) {
 237                         ret = set_slave_noc_dapc(i, j, apusys_noc_dapc[i].d_permission[j]);
 238                         if (ret)
 239                                 printk(BIOS_ERR, "[APUAPC] fail (%ld, %ld)(%d)!\n", i, j, ret);
 240                 }
 241         }
 242
 243         return ret;
 244 }
 245
 246 static int32_t set_apusys_ao_apc(void)
 247 {
 248         int ret = APUSYS_APC_OK;
 249         size_t i, j;
 250
 251         for (i = 0; i < ARRAY_SIZE(apusys_ao_apc); i++) {
 252                 for (j = 0; j < ARRAY_SIZE(apusys_ao_apc[j].d_permission); j++) {
 253                         ret = set_slave_apc(i, domain_map[j], apusys_ao_apc[i].d_permission[j]);
 254                         if (ret)
 255                                 printk(BIOS_ERR, "[APUAPC] fail (%ld, %ld)(%d)!\n", i, j, ret);
 256                 }
 257         }
 258
 259         return ret;
 260 }
 261
 262 void start_apusys_devapc(void)
 263 {
 264         int ret = APUSYS_APC_OK;
 265
 266         /* Check violation status */
 267         printk(BIOS_DEBUG, "[APUAPC] vio %d\n", read32(APUSYS_APC_CON) & 0x80000000);
 268
 269         /* Initial Permission */
 270         ret = set_apusys_ao_apc();
 271         printk(BIOS_DEBUG, "[APUAPC] %s - %s!\n", "set_apusys_ao_apc",
 272                ret ? "FAILED" : "SUCCESS");
 273
 274         /* Lock */
 275         write32(APUSYS_SYS0_APC_LOCK_0, APU_SCTRL_REVISER | DEVAPC_AO_WRAPPER);
 276
 277         /* Initial NoC Permission */
 278         ret = set_apusys_noc_dapc();
 279         printk(BIOS_DEBUG, "[APUAPC] %s - %s!\n", "set_apusys_noc_dapc",
 280                ret ? "FAILED" : "SUCCESS");
 281
 282         dump_apusys_ao_apc();
 283         dump_apusys_noc_dapc();
 284
 285         printk(BIOS_DEBUG, "[APUAPC] %s done\n", __func__);
 286 }