target/ppc/power8-pmu-regs.c.inc

   1 /*
   2  * PMU register read/write functions for TCG IBM POWER chips
   3  *
   4  * Copyright IBM Corp. 2021
   5  *
   6  * Authors:
   7  *  Daniel Henrique Barboza      <danielhb413@gmail.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #if defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY)
  14
  15 /*
  16  * Checks whether the Group A SPR (MMCR0, MMCR2, MMCRA, and the
  17  * PMCs) has problem state read access.
  18  *
  19  * Read acccess is granted for all PMCC values but 0b01, where a
  20  * Facility Unavailable Interrupt will occur.
  21  */
  22 static bool spr_groupA_read_allowed(DisasContext *ctx)
  23 {
  24     if (!ctx->mmcr0_pmcc0 && ctx->mmcr0_pmcc1) {
  25         gen_hvpriv_exception(ctx, POWERPC_EXCP_FU);
  26         return false;
  27     }
  28
  29     return true;
  30 }
  31
  32 /*
  33  * Checks whether the Group A SPR (MMCR0, MMCR2, MMCRA, and the
  34  * PMCs) has problem state write access.
  35  *
  36  * Write acccess is granted for PMCC values 0b10 and 0b11. Userspace
  37  * writing with PMCC 0b00 will generate a Hypervisor Emulation
  38  * Assistance Interrupt. Userspace writing with PMCC 0b01 will
  39  * generate a Facility Unavailable Interrupt.
  40  */
  41 static bool spr_groupA_write_allowed(DisasContext *ctx)
  42 {
  43     if (ctx->mmcr0_pmcc0) {
  44         return true;
  45     }
  46
  47     if (ctx->mmcr0_pmcc1) {
  48         /* PMCC = 0b01 */
  49         gen_hvpriv_exception(ctx, POWERPC_EXCP_FU);
  50     } else {
  51         /* PMCC = 0b00 */
  52         gen_hvpriv_exception(ctx, POWERPC_EXCP_INVAL_SPR);
  53     }
  54
  55     return false;
  56 }
  57
  58 /*
  59  * Helper function to avoid code repetition between MMCR0 and
  60  * MMCR2 problem state write functions.
  61  *
  62  * 'ret' must be tcg_temp_freed() by the caller.
  63  */
  64 static TCGv masked_gprn_for_spr_write(int gprn, int sprn,
  65                                       uint64_t spr_mask)
  66 {
  67     TCGv ret = tcg_temp_new();
  68     TCGv t0 = tcg_temp_new();
  69
  70     /* 'ret' starts with all mask bits cleared */
  71     gen_load_spr(ret, sprn);
  72     tcg_gen_andi_tl(ret, ret, ~(spr_mask));
  73
  74     /* Apply the mask into 'gprn' in a temp var */
  75     tcg_gen_andi_tl(t0, cpu_gpr[gprn], spr_mask);
  76
  77     /* Add the masked gprn bits into 'ret' */
  78     tcg_gen_or_tl(ret, ret, t0);
  79
  80     tcg_temp_free(t0);
  81
  82     return ret;
  83 }
  84
  85 void spr_read_MMCR0_ureg(DisasContext *ctx, int gprn, int sprn)
  86 {
  87     TCGv t0;
  88
  89     if (!spr_groupA_read_allowed(ctx)) {
  90         return;
  91     }
  92
  93     t0 = tcg_temp_new();
  94
  95     /*
  96      * Filter out all bits but FC, PMAO, and PMAE, according
  97      * to ISA v3.1, in 10.4.4 Monitor Mode Control Register 0,
  98      * fourth paragraph.
  99      */
 100     gen_load_spr(t0, SPR_POWER_MMCR0);
 101     tcg_gen_andi_tl(t0, t0, MMCR0_UREG_MASK);
 102     tcg_gen_mov_tl(cpu_gpr[gprn], t0);
 103
 104     tcg_temp_free(t0);
 105 }
 106
 107 static void write_MMCR0_common(DisasContext *ctx, TCGv val)
 108 {
 109     /*
 110      * helper_store_mmcr0 will make clock based operations that
 111      * will cause 'bad icount read' errors if we do not execute
 112      * gen_icount_io_start() beforehand.
 113      */
 114     gen_icount_io_start(ctx);
 115     gen_helper_store_mmcr0(cpu_env, val);
 116 }
 117
 118 void spr_write_MMCR0_ureg(DisasContext *ctx, int sprn, int gprn)
 119 {
 120     TCGv masked_gprn;
 121
 122     if (!spr_groupA_write_allowed(ctx)) {
 123         return;
 124     }
 125
 126     /*
 127      * Filter out all bits but FC, PMAO, and PMAE, according
 128      * to ISA v3.1, in 10.4.4 Monitor Mode Control Register 0,
 129      * fourth paragraph.
 130      */
 131     masked_gprn = masked_gprn_for_spr_write(gprn, SPR_POWER_MMCR0,
 132                                             MMCR0_UREG_MASK);
 133     write_MMCR0_common(ctx, masked_gprn);
 134
 135     tcg_temp_free(masked_gprn);
 136 }
 137
 138 void spr_read_MMCR2_ureg(DisasContext *ctx, int gprn, int sprn)
 139 {
 140     TCGv t0;
 141
 142     if (!spr_groupA_read_allowed(ctx)) {
 143         return;
 144     }
 145
 146     t0 = tcg_temp_new();
 147
 148     /*
 149      * On read, filter out all bits that are not FCnP0 bits.
 150      * When MMCR0[PMCC] is set to 0b10 or 0b11, providing
 151      * problem state programs read/write access to MMCR2,
 152      * only the FCnP0 bits can be accessed. All other bits are
 153      * not changed when mtspr is executed in problem state, and
 154      * all other bits return 0s when mfspr is executed in problem
 155      * state, according to ISA v3.1, section 10.4.6 Monitor Mode
 156      * Control Register 2, p. 1316, third paragraph.
 157      */
 158     gen_load_spr(t0, SPR_POWER_MMCR2);
 159     tcg_gen_andi_tl(t0, t0, MMCR2_UREG_MASK);
 160     tcg_gen_mov_tl(cpu_gpr[gprn], t0);
 161
 162     tcg_temp_free(t0);
 163 }
 164
 165 void spr_write_MMCR2_ureg(DisasContext *ctx, int sprn, int gprn)
 166 {
 167     TCGv masked_gprn;
 168
 169     if (!spr_groupA_write_allowed(ctx)) {
 170         return;
 171     }
 172
 173     /*
 174      * Filter the bits that can be written using MMCR2_UREG_MASK,
 175      * similar to what is done in spr_write_MMCR0_ureg().
 176      */
 177     masked_gprn = masked_gprn_for_spr_write(gprn, SPR_POWER_MMCR2,
 178                                             MMCR2_UREG_MASK);
 179     gen_store_spr(SPR_POWER_MMCR2, masked_gprn);
 180
 181     tcg_temp_free(masked_gprn);
 182 }
 183
 184 void spr_read_PMC(DisasContext *ctx, int gprn, int sprn)
 185 {
 186     TCGv_i32 t_sprn = tcg_const_i32(sprn);
 187
 188     gen_icount_io_start(ctx);
 189     gen_helper_read_pmc(cpu_gpr[gprn], cpu_env, t_sprn);
 190
 191     tcg_temp_free_i32(t_sprn);
 192 }
 193
 194 void spr_read_PMC14_ureg(DisasContext *ctx, int gprn, int sprn)
 195 {
 196     if (!spr_groupA_read_allowed(ctx)) {
 197         return;
 198     }
 199
 200     spr_read_PMC(ctx, gprn, sprn + 0x10);
 201 }
 202
 203 void spr_read_PMC56_ureg(DisasContext *ctx, int gprn, int sprn)
 204 {
 205     /*
 206      * If PMCC = 0b11, PMC5 and PMC6 aren't included in the Performance
 207      * Monitor, and a read attempt results in a Facility Unavailable
 208      * Interrupt.
 209      */
 210     if (ctx->mmcr0_pmcc0 && ctx->mmcr0_pmcc1) {
 211         gen_hvpriv_exception(ctx, POWERPC_EXCP_FU);
 212         return;
 213     }
 214
 215     /* The remaining steps are similar to PMCs 1-4 userspace read */
 216     spr_read_PMC14_ureg(ctx, gprn, sprn);
 217 }
 218
 219 void spr_write_PMC(DisasContext *ctx, int sprn, int gprn)
 220 {
 221     TCGv_i32 t_sprn = tcg_const_i32(sprn);
 222
 223     gen_icount_io_start(ctx);
 224     gen_helper_store_pmc(cpu_env, t_sprn, cpu_gpr[gprn]);
 225
 226     tcg_temp_free_i32(t_sprn);
 227 }
 228
 229 void spr_write_PMC14_ureg(DisasContext *ctx, int sprn, int gprn)
 230 {
 231     if (!spr_groupA_write_allowed(ctx)) {
 232         return;
 233     }
 234
 235     spr_write_PMC(ctx, sprn + 0x10, gprn);
 236 }
 237
 238 void spr_write_PMC56_ureg(DisasContext *ctx, int sprn, int gprn)
 239 {
 240     /*
 241      * If PMCC = 0b11, PMC5 and PMC6 aren't included in the Performance
 242      * Monitor, and a write attempt results in a Facility Unavailable
 243      * Interrupt.
 244      */
 245     if (ctx->mmcr0_pmcc0 && ctx->mmcr0_pmcc1) {
 246         gen_hvpriv_exception(ctx, POWERPC_EXCP_FU);
 247         return;
 248     }
 249
 250     /* The remaining steps are similar to PMCs 1-4 userspace write */
 251     spr_write_PMC14_ureg(ctx, sprn, gprn);
 252 }
 253
 254 void spr_write_MMCR0(DisasContext *ctx, int sprn, int gprn)
 255 {
 256     write_MMCR0_common(ctx, cpu_gpr[gprn]);
 257 }
 258
 259 void spr_write_MMCR1(DisasContext *ctx, int sprn, int gprn)
 260 {
 261     gen_icount_io_start(ctx);
 262     gen_helper_store_mmcr1(cpu_env, cpu_gpr[gprn]);
 263 }
 264 #else
 265 void spr_read_MMCR0_ureg(DisasContext *ctx, int gprn, int sprn)
 266 {
 267     spr_read_ureg(ctx, gprn, sprn);
 268 }
 269
 270 void spr_write_MMCR0_ureg(DisasContext *ctx, int sprn, int gprn)
 271 {
 272     spr_noaccess(ctx, gprn, sprn);
 273 }
 274
 275 void spr_read_MMCR2_ureg(DisasContext *ctx, int gprn, int sprn)
 276 {
 277     spr_read_ureg(ctx, gprn, sprn);
 278 }
 279
 280 void spr_write_MMCR2_ureg(DisasContext *ctx, int sprn, int gprn)
 281 {
 282     spr_noaccess(ctx, gprn, sprn);
 283 }
 284
 285 void spr_read_PMC14_ureg(DisasContext *ctx, int gprn, int sprn)
 286 {
 287     spr_read_ureg(ctx, gprn, sprn);
 288 }
 289
 290 void spr_read_PMC56_ureg(DisasContext *ctx, int gprn, int sprn)
 291 {
 292     spr_read_ureg(ctx, gprn, sprn);
 293 }
 294
 295 void spr_write_PMC14_ureg(DisasContext *ctx, int sprn, int gprn)
 296 {
 297     spr_noaccess(ctx, gprn, sprn);
 298 }
 299
 300 void spr_write_PMC56_ureg(DisasContext *ctx, int sprn, int gprn)
 301 {
 302     spr_noaccess(ctx, gprn, sprn);
 303 }
 304
 305 void spr_write_MMCR0(DisasContext *ctx, int sprn, int gprn)
 306 {
 307     spr_write_generic(ctx, sprn, gprn);
 308 }
 309
 310 void spr_write_MMCR1(DisasContext *ctx, int sprn, int gprn)
 311 {
 312     spr_write_generic(ctx, sprn, gprn);
 313 }
 314
 315 void spr_write_PMC(DisasContext *ctx, int sprn, int gprn)
 316 {
 317     spr_write_generic(ctx, sprn, gprn);
 318 }
 319 #endif /* defined(TARGET_PPC64) && !defined(CONFIG_USER_ONLY) */