Pull power management fix from Rafael Wysocki: "Fix a sparse warning triggered by the TPMI interface recently added to the Intel RAPL power capping driver (Zhang Rui)" * tag 'pm-6.5-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: powercap: intel_rapl: Fix a sparse warning in TPMI interface
Unified · Split
| @@ -818,7 +818,7 @@ static int rapl_read_data_raw(struct rapl_domain *rd, · 817 unmodified lines | |||
| 818 | return -EINVAL; | 818 | return -EINVAL; |
| 819 | 819 | ||
| 820 | ra.reg = rd->regs[rpi->id]; | 820 | ra.reg = rd->regs[rpi->id]; |
| 821 | if (!ra.reg) | 821 | if (!ra.reg.val) |
| 822 | return -EINVAL; | 822 | return -EINVAL; |
| 823 | 823 | ||
| 824 | /* non-hardware data are collected by the polling thread */ | 824 | /* non-hardware data are collected by the polling thread */ |
| @@ -830,7 +830,7 @@ static int rapl_read_data_raw(struct rapl_domain *rd, · 5 unmodified lines | |||
| 830 | ra.mask = rpi->mask; | 830 | ra.mask = rpi->mask; |
| 831 | 831 | ||
| 832 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { | 832 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 833 | pr_debug("failed to read reg 0x%llx for %s:%s\n", ra.reg, rd->rp->name, rd->name); | 833 | pr_debug("failed to read reg 0x%llx for %s:%s\n", ra.reg.val, rd->rp->name, rd->name); |
| 834 | return -EIO; | 834 | return -EIO; |
| 835 | } | 835 | } |
| 836 | 836 | ||
| @@ -920,7 +920,7 @@ static int rapl_check_unit_core(struct rapl_domain *rd) · 83 unmodified lines | |||
| 920 | ra.mask = ~0; | 920 | ra.mask = ~0; |
| 921 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { | 921 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 922 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", | 922 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", |
| 923 | ra.reg, rd->rp->name, rd->name); | 923 | ra.reg.val, rd->rp->name, rd->name); |
| 924 | return -ENODEV; | 924 | return -ENODEV; |
| 925 | } | 925 | } |
| 926 | 926 | ||
| @@ -948,7 +948,7 @@ static int rapl_check_unit_atom(struct rapl_domain *rd) · 21 unmodified lines | |||
| 948 | ra.mask = ~0; | 948 | ra.mask = ~0; |
| 949 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { | 949 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 950 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", | 950 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", |
| 951 | ra.reg, rd->rp->name, rd->name); | 951 | ra.reg.val, rd->rp->name, rd->name); |
| 952 | return -ENODEV; | 952 | return -ENODEV; |
| 953 | } | 953 | } |
| 954 | 954 | ||
| @@ -1135,7 +1135,7 @@ static int rapl_check_unit_tpmi(struct rapl_domain *rd) · 180 unmodified lines | |||
| 1135 | ra.mask = ~0; | 1135 | ra.mask = ~0; |
| 1136 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { | 1136 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 1137 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", | 1137 | pr_err("Failed to read power unit REG 0x%llx on %s:%s, exit.\n", |
| 1138 | ra.reg, rd->rp->name, rd->name); | 1138 | ra.reg.val, rd->rp->name, rd->name); |
| 1139 | return -ENODEV; | 1139 | return -ENODEV; |
| 1140 | } | 1140 | } |
| 1141 | 1141 | ||
| @@ -1411,8 +1411,8 @@ static int rapl_get_domain_unit(struct rapl_domain *rd) · 269 unmodified lines | |||
| 1411 | struct rapl_defaults *defaults = get_defaults(rd->rp); | 1411 | struct rapl_defaults *defaults = get_defaults(rd->rp); |
| 1412 | int ret; | 1412 | int ret; |
| 1413 | 1413 | ||
| 1414 | if (!rd->regs[RAPL_DOMAIN_REG_UNIT]) { | 1414 | if (!rd->regs[RAPL_DOMAIN_REG_UNIT].val) { |
| 1415 | if (!rd->rp->priv->reg_unit) { | 1415 | if (!rd->rp->priv->reg_unit.val) { |
| 1416 | pr_err("No valid Unit register found\n"); | 1416 | pr_err("No valid Unit register found\n"); |
| 1417 | return -ENODEV; | 1417 | return -ENODEV; |
| 1418 | } | 1418 | } |
| @@ -34,28 +34,32 @@ static struct rapl_if_priv *rapl_msr_priv; · 33 unmodified lines | |||
| 34 | 34 | ||
| 35 | static struct rapl_if_priv rapl_msr_priv_intel = { | 35 | static struct rapl_if_priv rapl_msr_priv_intel = { |
| 36 | .type = RAPL_IF_MSR, | 36 | .type = RAPL_IF_MSR, |
| 37 | .reg_unit = MSR_RAPL_POWER_UNIT, | 37 | .reg_unit.msr = MSR_RAPL_POWER_UNIT, |
| 38 | .regs[RAPL_DOMAIN_PACKAGE] = { | 38 | .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PKG_POWER_LIMIT, |
| 39 | MSR_PKG_POWER_LIMIT, MSR_PKG_ENERGY_STATUS, MSR_PKG_PERF_STATUS, 0, MSR_PKG_POWER_INFO }, | 39 | .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_STATUS].msr = MSR_PKG_ENERGY_STATUS, |
| 40 | .regs[RAPL_DOMAIN_PP0] = { | 40 | .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_PERF].msr = MSR_PKG_PERF_STATUS, |
| 41 | MSR_PP0_POWER_LIMIT, MSR_PP0_ENERGY_STATUS, 0, MSR_PP0_POLICY, 0 }, | 41 | .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_INFO].msr = MSR_PKG_POWER_INFO, |
| 42 | .regs[RAPL_DOMAIN_PP1] = { | 42 | .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PP0_POWER_LIMIT, |
| 43 | MSR_PP1_POWER_LIMIT, MSR_PP1_ENERGY_STATUS, 0, MSR_PP1_POLICY, 0 }, | 43 | .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_STATUS].msr = MSR_PP0_ENERGY_STATUS, |
| 44 | .regs[RAPL_DOMAIN_DRAM] = { | 44 | .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_POLICY].msr = MSR_PP0_POLICY, |
| 45 | MSR_DRAM_POWER_LIMIT, MSR_DRAM_ENERGY_STATUS, MSR_DRAM_PERF_STATUS, 0, MSR_DRAM_POWER_INFO }, | 45 | .regs[RAPL_DOMAIN_PP1][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PP1_POWER_LIMIT, |
| 46 | .regs[RAPL_DOMAIN_PLATFORM] = { | 46 | .regs[RAPL_DOMAIN_PP1][RAPL_DOMAIN_REG_STATUS].msr = MSR_PP1_ENERGY_STATUS, |
| 47 | MSR_PLATFORM_POWER_LIMIT, MSR_PLATFORM_ENERGY_STATUS, 0, 0, 0}, | 47 | .regs[RAPL_DOMAIN_PP1][RAPL_DOMAIN_REG_POLICY].msr = MSR_PP1_POLICY, |
| 48 | .regs[RAPL_DOMAIN_DRAM][RAPL_DOMAIN_REG_LIMIT].msr = MSR_DRAM_POWER_LIMIT, | ||
| 49 | .regs[RAPL_DOMAIN_DRAM][RAPL_DOMAIN_REG_STATUS].msr = MSR_DRAM_ENERGY_STATUS, | ||
| 50 | .regs[RAPL_DOMAIN_DRAM][RAPL_DOMAIN_REG_PERF].msr = MSR_DRAM_PERF_STATUS, | ||
| 51 | .regs[RAPL_DOMAIN_DRAM][RAPL_DOMAIN_REG_INFO].msr = MSR_DRAM_POWER_INFO, | ||
| 52 | .regs[RAPL_DOMAIN_PLATFORM][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PLATFORM_POWER_LIMIT, | ||
| 53 | .regs[RAPL_DOMAIN_PLATFORM][RAPL_DOMAIN_REG_STATUS].msr = MSR_PLATFORM_ENERGY_STATUS, | ||
| 48 | .limits[RAPL_DOMAIN_PACKAGE] = BIT(POWER_LIMIT2), | 54 | .limits[RAPL_DOMAIN_PACKAGE] = BIT(POWER_LIMIT2), |
| 49 | .limits[RAPL_DOMAIN_PLATFORM] = BIT(POWER_LIMIT2), | 55 | .limits[RAPL_DOMAIN_PLATFORM] = BIT(POWER_LIMIT2), |
| 50 | }; | 56 | }; |
| 51 | 57 | ||
| 52 | static struct rapl_if_priv rapl_msr_priv_amd = { | 58 | static struct rapl_if_priv rapl_msr_priv_amd = { |
| 53 | .type = RAPL_IF_MSR, | 59 | .type = RAPL_IF_MSR, |
| 54 | .reg_unit = MSR_AMD_RAPL_POWER_UNIT, | 60 | .reg_unit.msr = MSR_AMD_RAPL_POWER_UNIT, |
| 55 | .regs[RAPL_DOMAIN_PACKAGE] = { | 61 | .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_STATUS].msr = MSR_AMD_PKG_ENERGY_STATUS, |
| 56 | 0, MSR_AMD_PKG_ENERGY_STATUS, 0, 0, 0 }, | 62 | .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_STATUS].msr = MSR_AMD_CORE_ENERGY_STATUS, |
| 57 | .regs[RAPL_DOMAIN_PP0] = { | ||
| 58 | 0, MSR_AMD_CORE_ENERGY_STATUS, 0, 0, 0 }, | ||
| 59 | }; | 63 | }; |
| 60 | 64 | ||
| 61 | /* Handles CPU hotplug on multi-socket systems. | 65 | /* Handles CPU hotplug on multi-socket systems. |
| @@ -99,10 +103,8 @@ static int rapl_cpu_down_prep(unsigned int cpu) · 37 unmodified lines | |||
| 99 | 103 | ||
| 100 | static int rapl_msr_read_raw(int cpu, struct reg_action *ra) | 104 | static int rapl_msr_read_raw(int cpu, struct reg_action *ra) |
| 101 | { | 105 | { |
| 102 | u32 msr = (u32)ra->reg; | 106 | if (rdmsrl_safe_on_cpu(cpu, ra->reg.msr, &ra->value)) { |
| 103 | 107 | pr_debug("failed to read msr 0x%x on cpu %d\n", ra->reg.msr, cpu); | |
| 104 | if (rdmsrl_safe_on_cpu(cpu, msr, &ra->value)) { | ||
| 105 | pr_debug("failed to read msr 0x%x on cpu %d\n", msr, cpu); | ||
| 106 | return -EIO; | 108 | return -EIO; |
| 107 | } | 109 | } |
| 108 | ra->value &= ra->mask; | 110 | ra->value &= ra->mask; |
| @@ -112,17 +114,16 @@ static int rapl_msr_read_raw(int cpu, struct reg_action *ra) · 3 unmodified lines | |||
| 112 | static void rapl_msr_update_func(void *info) | 114 | static void rapl_msr_update_func(void *info) |
| 113 | { | 115 | { |
| 114 | struct reg_action *ra = info; | 116 | struct reg_action *ra = info; |
| 115 | u32 msr = (u32)ra->reg; | ||
| 116 | u64 val; | 117 | u64 val; |
| 117 | 118 | ||
| 118 | ra->err = rdmsrl_safe(msr, &val); | 119 | ra->err = rdmsrl_safe(ra->reg.msr, &val); |
| 119 | if (ra->err) | 120 | if (ra->err) |
| 120 | return; | 121 | return; |
| 121 | 122 | ||
| 122 | val &= ~ra->mask; | 123 | val &= ~ra->mask; |
| 123 | val |= ra->value; | 124 | val |= ra->value; |
| 124 | 125 | ||
| 125 | ra->err = wrmsrl_safe(msr, val); | 126 | ra->err = wrmsrl_safe(ra->reg.msr, val); |
| 126 | } | 127 | } |
| 127 | 128 | ||
| 128 | static int rapl_msr_write_raw(int cpu, struct reg_action *ra) | 129 | static int rapl_msr_write_raw(int cpu, struct reg_action *ra) |
| @@ -171,7 +172,7 @@ static int rapl_msr_probe(struct platform_device *pdev) · 42 unmodified lines | |||
| 171 | 172 | ||
| 172 | if (id) { | 173 | if (id) { |
| 173 | rapl_msr_priv->limits[RAPL_DOMAIN_PACKAGE] |= BIT(POWER_LIMIT4); | 174 | rapl_msr_priv->limits[RAPL_DOMAIN_PACKAGE] |= BIT(POWER_LIMIT4); |
| 174 | rapl_msr_priv->regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_PL4] = | 175 | rapl_msr_priv->regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_PL4].msr = |
| 175 | MSR_VR_CURRENT_CONFIG; | 176 | MSR_VR_CURRENT_CONFIG; |
| 176 | pr_info("PL4 support detected.\n"); | 177 | pr_info("PL4 support detected.\n"); |
| 177 | } | 178 | } |
| @@ -59,10 +59,10 @@ static struct powercap_control_type *tpmi_control_type; · 58 unmodified lines | |||
| 59 | 59 | ||
| 60 | static int tpmi_rapl_read_raw(int id, struct reg_action *ra) | 60 | static int tpmi_rapl_read_raw(int id, struct reg_action *ra) |
| 61 | { | 61 | { |
| 62 | if (!ra->reg) | 62 | if (!ra->reg.mmio) |
| 63 | return -EINVAL; | 63 | return -EINVAL; |
| 64 | 64 | ||
| 65 | ra->value = readq((void __iomem *)ra->reg); | 65 | ra->value = readq(ra->reg.mmio); |
| 66 | 66 | ||
| 67 | ra->value &= ra->mask; | 67 | ra->value &= ra->mask; |
| 68 | return 0; | 68 | return 0; |
| @@ -72,15 +72,15 @@ static int tpmi_rapl_write_raw(int id, struct reg_action *ra) · 3 unmodified lines | |||
| 72 | { | 72 | { |
| 73 | u64 val; | 73 | u64 val; |
| 74 | 74 | ||
| 75 | if (!ra->reg) | 75 | if (!ra->reg.mmio) |
| 76 | return -EINVAL; | 76 | return -EINVAL; |
| 77 | 77 | ||
| 78 | val = readq((void __iomem *)ra->reg); | 78 | val = readq(ra->reg.mmio); |
| 79 | 79 | ||
| 80 | val &= ~ra->mask; | 80 | val &= ~ra->mask; |
| 81 | val |= ra->value; | 81 | val |= ra->value; |
| 82 | 82 | ||
| 83 | writeq(val, (void __iomem *)ra->reg); | 83 | writeq(val, ra->reg.mmio); |
| 84 | return 0; | 84 | return 0; |
| 85 | } | 85 | } |
| 86 | 86 | ||
| @@ -138,8 +138,7 @@ static int parse_one_domain(struct tpmi_rapl_package *trp, u32 offset) · 51 unmodified lines | |||
| 138 | enum tpmi_rapl_register reg_index; | 138 | enum tpmi_rapl_register reg_index; |
| 139 | enum rapl_domain_reg_id reg_id; | 139 | enum rapl_domain_reg_id reg_id; |
| 140 | int tpmi_domain_size, tpmi_domain_flags; | 140 | int tpmi_domain_size, tpmi_domain_flags; |
| 141 | u64 *tpmi_rapl_regs = trp->base + offset; | 141 | u64 tpmi_domain_header = readq(trp->base + offset); |
| 142 | u64 tpmi_domain_header = readq((void __iomem *)tpmi_rapl_regs); | ||
| 143 | 142 | ||
| 144 | /* Domain Parent bits are ignored for now */ | 143 | /* Domain Parent bits are ignored for now */ |
| 145 | tpmi_domain_version = tpmi_domain_header & 0xff; | 144 | tpmi_domain_version = tpmi_domain_header & 0xff; |
| @@ -180,7 +179,7 @@ static int parse_one_domain(struct tpmi_rapl_package *trp, u32 offset) · 34 unmodified lines | |||
| 180 | return -EINVAL; | 179 | return -EINVAL; |
| 181 | } | 180 | } |
| 182 | 181 | ||
| 183 | if (trp->priv.regs[domain_type][RAPL_DOMAIN_REG_UNIT]) { | 182 | if (trp->priv.regs[domain_type][RAPL_DOMAIN_REG_UNIT].mmio) { |
| 184 | pr_warn(FW_BUG "Duplicate Domain type %d\n", tpmi_domain_type); | 183 | pr_warn(FW_BUG "Duplicate Domain type %d\n", tpmi_domain_type); |
| 185 | return -EINVAL; | 184 | return -EINVAL; |
| 186 | } | 185 | } |
| @@ -218,7 +217,7 @@ static int parse_one_domain(struct tpmi_rapl_package *trp, u32 offset) · 31 unmodified lines | |||
| 218 | default: | 217 | default: |
| 219 | continue; | 218 | continue; |
| 220 | } | 219 | } |
| 221 | trp->priv.regs[domain_type][reg_id] = (u64)&tpmi_rapl_regs[reg_index]; | 220 | trp->priv.regs[domain_type][reg_id].mmio = trp->base + offset + reg_index * 8; |
| 222 | } | 221 | } |
| 223 | 222 | ||
| 224 | return 0; | 223 | return 0; |
| @@ -57,10 +57,10 @@ static int rapl_mmio_cpu_down_prep(unsigned int cpu) · 56 unmodified lines | |||
| 57 | 57 | ||
| 58 | static int rapl_mmio_read_raw(int cpu, struct reg_action *ra) | 58 | static int rapl_mmio_read_raw(int cpu, struct reg_action *ra) |
| 59 | { | 59 | { |
| 60 | if (!ra->reg) | 60 | if (!ra->reg.mmio) |
| 61 | return -EINVAL; | 61 | return -EINVAL; |
| 62 | 62 | ||
| 63 | ra->value = readq((void __iomem *)ra->reg); | 63 | ra->value = readq(ra->reg.mmio); |
| 64 | ra->value &= ra->mask; | 64 | ra->value &= ra->mask; |
| 65 | return 0; | 65 | return 0; |
| 66 | } | 66 | } |
| @@ -69,13 +69,13 @@ static int rapl_mmio_write_raw(int cpu, struct reg_action *ra) · 2 unmodified lines | |||
| 69 | { | 69 | { |
| 70 | u64 val; | 70 | u64 val; |
| 71 | 71 | ||
| 72 | if (!ra->reg) | 72 | if (!ra->reg.mmio) |
| 73 | return -EINVAL; | 73 | return -EINVAL; |
| 74 | 74 | ||
| 75 | val = readq((void __iomem *)ra->reg); | 75 | val = readq(ra->reg.mmio); |
| 76 | val &= ~ra->mask; | 76 | val &= ~ra->mask; |
| 77 | val |= ra->value; | 77 | val |= ra->value; |
| 78 | writeq(val, (void __iomem *)ra->reg); | 78 | writeq(val, ra->reg.mmio); |
| 79 | return 0; | 79 | return 0; |
| 80 | } | 80 | } |
| 81 | 81 | ||
| @@ -92,13 +92,13 @@ int proc_thermal_rapl_add(struct pci_dev *pdev, struct proc_thermal_device *proc · 10 unmodified lines | |||
| 92 | for (domain = RAPL_DOMAIN_PACKAGE; domain < RAPL_DOMAIN_MAX; domain++) { | 92 | for (domain = RAPL_DOMAIN_PACKAGE; domain < RAPL_DOMAIN_MAX; domain++) { |
| 93 | for (reg = RAPL_DOMAIN_REG_LIMIT; reg < RAPL_DOMAIN_REG_MAX; reg++) | 93 | for (reg = RAPL_DOMAIN_REG_LIMIT; reg < RAPL_DOMAIN_REG_MAX; reg++) |
| 94 | if (rapl_regs->regs[domain][reg]) | 94 | if (rapl_regs->regs[domain][reg]) |
| 95 | rapl_mmio_priv.regs[domain][reg] = | 95 | rapl_mmio_priv.regs[domain][reg].mmio = |
| 96 | (u64)proc_priv->mmio_base + | 96 | proc_priv->mmio_base + |
| 97 | rapl_regs->regs[domain][reg]; | 97 | rapl_regs->regs[domain][reg]; |
| 98 | rapl_mmio_priv.limits[domain] = rapl_regs->limits[domain]; | 98 | rapl_mmio_priv.limits[domain] = rapl_regs->limits[domain]; |
| 99 | } | 99 | } |
| 100 | rapl_mmio_priv.type = RAPL_IF_MMIO; | 100 | rapl_mmio_priv.type = RAPL_IF_MMIO; |
| 101 | rapl_mmio_priv.reg_unit = (u64)proc_priv->mmio_base + rapl_regs->reg_unit; | 101 | rapl_mmio_priv.reg_unit.mmio = proc_priv->mmio_base + rapl_regs->reg_unit; |
| 102 | 102 | ||
| 103 | rapl_mmio_priv.read_raw = rapl_mmio_read_raw; | 103 | rapl_mmio_priv.read_raw = rapl_mmio_read_raw; |
| 104 | rapl_mmio_priv.write_raw = rapl_mmio_write_raw; | 104 | rapl_mmio_priv.write_raw = rapl_mmio_write_raw; |
| @@ -100,10 +100,16 @@ struct rapl_package; · 99 unmodified lines | |||
| 100 | 100 | ||
| 101 | #define RAPL_DOMAIN_NAME_LENGTH 16 | 101 | #define RAPL_DOMAIN_NAME_LENGTH 16 |
| 102 | 102 | ||
| 103 | union rapl_reg { | ||
| 104 | void __iomem *mmio; | ||
| 105 | u32 msr; | ||
| 106 | u64 val; | ||
| 107 | }; | ||
| 108 | |||
| 103 | struct rapl_domain { | 109 | struct rapl_domain { |
| 104 | char name[RAPL_DOMAIN_NAME_LENGTH]; | 110 | char name[RAPL_DOMAIN_NAME_LENGTH]; |
| 105 | enum rapl_domain_type id; | 111 | enum rapl_domain_type id; |
| 106 | u64 regs[RAPL_DOMAIN_REG_MAX]; | 112 | union rapl_reg regs[RAPL_DOMAIN_REG_MAX]; |
| 107 | struct powercap_zone power_zone; | 113 | struct powercap_zone power_zone; |
| 108 | struct rapl_domain_data rdd; | 114 | struct rapl_domain_data rdd; |
| 109 | struct rapl_power_limit rpl[NR_POWER_LIMITS]; | 115 | struct rapl_power_limit rpl[NR_POWER_LIMITS]; |
| @@ -116,7 +122,7 @@ struct rapl_domain { · 6 unmodified lines | |||
| 116 | }; | 122 | }; |
| 117 | 123 | ||
| 118 | struct reg_action { | 124 | struct reg_action { |
| 119 | u64 reg; | 125 | union rapl_reg reg; |
| 120 | u64 mask; | 126 | u64 mask; |
| 121 | u64 value; | 127 | u64 value; |
| 122 | int err; | 128 | int err; |
| @@ -143,8 +149,8 @@ struct rapl_if_priv { · 20 unmodified lines | |||
| 143 | enum rapl_if_type type; | 149 | enum rapl_if_type type; |
| 144 | struct powercap_control_type *control_type; | 150 | struct powercap_control_type *control_type; |
| 145 | enum cpuhp_state pcap_rapl_online; | 151 | enum cpuhp_state pcap_rapl_online; |
| 146 | u64 reg_unit; | 152 | union rapl_reg reg_unit; |
| 147 | u64 regs[RAPL_DOMAIN_MAX][RAPL_DOMAIN_REG_MAX]; | 153 | union rapl_reg regs[RAPL_DOMAIN_MAX][RAPL_DOMAIN_REG_MAX]; |
| 148 | int limits[RAPL_DOMAIN_MAX]; | 154 | int limits[RAPL_DOMAIN_MAX]; |
| 149 | int (*read_raw)(int id, struct reg_action *ra); | 155 | int (*read_raw)(int id, struct reg_action *ra); |
| 150 | int (*write_raw)(int id, struct reg_action *ra); | 156 | int (*write_raw)(int id, struct reg_action *ra); |