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 | 818 | return -EINVAL; |
| 819 | 819 | |
| 820 | 820 | ra.reg = rd->regs[rpi->id]; |
| 821 | − if (!ra.reg) | |
| 821 | + if (!ra.reg.val) | |
| 822 | 822 | return -EINVAL; |
| 823 | 823 | |
| 824 | 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 | 830 | ra.mask = rpi->mask; |
| 831 | 831 | |
| 832 | 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 | 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 | 920 | ra.mask = ~0; |
| 921 | 921 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 922 | 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 | 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 | 948 | ra.mask = ~0; |
| 949 | 949 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 950 | 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 | 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 | 1135 | ra.mask = ~0; |
| 1136 | 1136 | if (rd->rp->priv->read_raw(get_rid(rd->rp), &ra)) { |
| 1137 | 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 | 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 | 1411 | struct rapl_defaults *defaults = get_defaults(rd->rp); |
| 1412 | 1412 | int ret; |
| 1413 | 1413 | |
| 1414 | − if (!rd->regs[RAPL_DOMAIN_REG_UNIT]) { | |
| 1415 | − if (!rd->rp->priv->reg_unit) { | |
| 1414 | + if (!rd->regs[RAPL_DOMAIN_REG_UNIT].val) { | |
| 1415 | + if (!rd->rp->priv->reg_unit.val) { | |
| 1416 | 1416 | pr_err("No valid Unit register found\n"); |
| 1417 | 1417 | return -ENODEV; |
| 1418 | 1418 | } |
| @@ -34,28 +34,32 @@ static struct rapl_if_priv *rapl_msr_priv; · 33 unmodified lines | ||
| 34 | 34 | |
| 35 | 35 | static struct rapl_if_priv rapl_msr_priv_intel = { |
| 36 | 36 | .type = RAPL_IF_MSR, |
| 37 | − .reg_unit = MSR_RAPL_POWER_UNIT, | |
| 38 | − .regs[RAPL_DOMAIN_PACKAGE] = { | |
| 39 | − MSR_PKG_POWER_LIMIT, MSR_PKG_ENERGY_STATUS, MSR_PKG_PERF_STATUS, 0, MSR_PKG_POWER_INFO }, | |
| 40 | − .regs[RAPL_DOMAIN_PP0] = { | |
| 41 | − MSR_PP0_POWER_LIMIT, MSR_PP0_ENERGY_STATUS, 0, MSR_PP0_POLICY, 0 }, | |
| 42 | − .regs[RAPL_DOMAIN_PP1] = { | |
| 43 | − MSR_PP1_POWER_LIMIT, MSR_PP1_ENERGY_STATUS, 0, MSR_PP1_POLICY, 0 }, | |
| 44 | − .regs[RAPL_DOMAIN_DRAM] = { | |
| 45 | − MSR_DRAM_POWER_LIMIT, MSR_DRAM_ENERGY_STATUS, MSR_DRAM_PERF_STATUS, 0, MSR_DRAM_POWER_INFO }, | |
| 46 | − .regs[RAPL_DOMAIN_PLATFORM] = { | |
| 47 | − MSR_PLATFORM_POWER_LIMIT, MSR_PLATFORM_ENERGY_STATUS, 0, 0, 0}, | |
| 37 | + .reg_unit.msr = MSR_RAPL_POWER_UNIT, | |
| 38 | + .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PKG_POWER_LIMIT, | |
| 39 | + .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_STATUS].msr = MSR_PKG_ENERGY_STATUS, | |
| 40 | + .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_PERF].msr = MSR_PKG_PERF_STATUS, | |
| 41 | + .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_INFO].msr = MSR_PKG_POWER_INFO, | |
| 42 | + .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PP0_POWER_LIMIT, | |
| 43 | + .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_STATUS].msr = MSR_PP0_ENERGY_STATUS, | |
| 44 | + .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_POLICY].msr = MSR_PP0_POLICY, | |
| 45 | + .regs[RAPL_DOMAIN_PP1][RAPL_DOMAIN_REG_LIMIT].msr = MSR_PP1_POWER_LIMIT, | |
| 46 | + .regs[RAPL_DOMAIN_PP1][RAPL_DOMAIN_REG_STATUS].msr = MSR_PP1_ENERGY_STATUS, | |
| 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 | 54 | .limits[RAPL_DOMAIN_PACKAGE] = BIT(POWER_LIMIT2), |
| 49 | 55 | .limits[RAPL_DOMAIN_PLATFORM] = BIT(POWER_LIMIT2), |
| 50 | 56 | }; |
| 51 | 57 | |
| 52 | 58 | static struct rapl_if_priv rapl_msr_priv_amd = { |
| 53 | 59 | .type = RAPL_IF_MSR, |
| 54 | − .reg_unit = MSR_AMD_RAPL_POWER_UNIT, | |
| 55 | − .regs[RAPL_DOMAIN_PACKAGE] = { | |
| 56 | − 0, MSR_AMD_PKG_ENERGY_STATUS, 0, 0, 0 }, | |
| 57 | − .regs[RAPL_DOMAIN_PP0] = { | |
| 58 | − 0, MSR_AMD_CORE_ENERGY_STATUS, 0, 0, 0 }, | |
| 60 | + .reg_unit.msr = MSR_AMD_RAPL_POWER_UNIT, | |
| 61 | + .regs[RAPL_DOMAIN_PACKAGE][RAPL_DOMAIN_REG_STATUS].msr = MSR_AMD_PKG_ENERGY_STATUS, | |
| 62 | + .regs[RAPL_DOMAIN_PP0][RAPL_DOMAIN_REG_STATUS].msr = MSR_AMD_CORE_ENERGY_STATUS, | |
| 59 | 63 | }; |
| 60 | 64 | |
| 61 | 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 | 104 | static int rapl_msr_read_raw(int cpu, struct reg_action *ra) |
| 101 | 105 | { |
| 102 | − u32 msr = (u32)ra->reg; | |
| 103 | − | |
| 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 | + if (rdmsrl_safe_on_cpu(cpu, ra->reg.msr, &ra->value)) { | |
| 107 | + pr_debug("failed to read msr 0x%x on cpu %d\n", ra->reg.msr, cpu); | |
| 106 | 108 | return -EIO; |
| 107 | 109 | } |
| 108 | 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 | 114 | static void rapl_msr_update_func(void *info) |
| 113 | 115 | { |
| 114 | 116 | struct reg_action *ra = info; |
| 115 | − u32 msr = (u32)ra->reg; | |
| 116 | 117 | u64 val; |
| 117 | 118 | |
| 118 | − ra->err = rdmsrl_safe(msr, &val); | |
| 119 | + ra->err = rdmsrl_safe(ra->reg.msr, &val); | |
| 119 | 120 | if (ra->err) |
| 120 | 121 | return; |
| 121 | 122 | |
| 122 | 123 | val &= ~ra->mask; |
| 123 | 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 | 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 | 173 | if (id) { |
| 173 | 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 | 176 | MSR_VR_CURRENT_CONFIG; |
| 176 | 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 | 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 | 63 | return -EINVAL; |
| 64 | 64 | |
| 65 | − ra->value = readq((void __iomem *)ra->reg); | |
| 65 | + ra->value = readq(ra->reg.mmio); | |
| 66 | 66 | |
| 67 | 67 | ra->value &= ra->mask; |
| 68 | 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 | 73 | u64 val; |
| 74 | 74 | |
| 75 | − if (!ra->reg) | |
| 75 | + if (!ra->reg.mmio) | |
| 76 | 76 | return -EINVAL; |
| 77 | 77 | |
| 78 | − val = readq((void __iomem *)ra->reg); | |
| 78 | + val = readq(ra->reg.mmio); | |
| 79 | 79 | |
| 80 | 80 | val &= ~ra->mask; |
| 81 | 81 | val |= ra->value; |
| 82 | 82 | |
| 83 | − writeq(val, (void __iomem *)ra->reg); | |
| 83 | + writeq(val, ra->reg.mmio); | |
| 84 | 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 | 138 | enum tpmi_rapl_register reg_index; |
| 139 | 139 | enum rapl_domain_reg_id reg_id; |
| 140 | 140 | int tpmi_domain_size, tpmi_domain_flags; |
| 141 | − u64 *tpmi_rapl_regs = trp->base + offset; | |
| 142 | − u64 tpmi_domain_header = readq((void __iomem *)tpmi_rapl_regs); | |
| 141 | + u64 tpmi_domain_header = readq(trp->base + offset); | |
| 143 | 142 | |
| 144 | 143 | /* Domain Parent bits are ignored for now */ |
| 145 | 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 | 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 | 183 | pr_warn(FW_BUG "Duplicate Domain type %d\n", tpmi_domain_type); |
| 185 | 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 | 217 | default: |
| 219 | 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 | 223 | return 0; |
| @@ -57,10 +57,10 @@ static int rapl_mmio_cpu_down_prep(unsigned int cpu) · 56 unmodified lines | ||
| 57 | 57 | |
| 58 | 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 | 61 | return -EINVAL; |
| 62 | 62 | |
| 63 | − ra->value = readq((void __iomem *)ra->reg); | |
| 63 | + ra->value = readq(ra->reg.mmio); | |
| 64 | 64 | ra->value &= ra->mask; |
| 65 | 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 | 70 | u64 val; |
| 71 | 71 | |
| 72 | − if (!ra->reg) | |
| 72 | + if (!ra->reg.mmio) | |
| 73 | 73 | return -EINVAL; |
| 74 | 74 | |
| 75 | − val = readq((void __iomem *)ra->reg); | |
| 75 | + val = readq(ra->reg.mmio); | |
| 76 | 76 | val &= ~ra->mask; |
| 77 | 77 | val |= ra->value; |
| 78 | − writeq(val, (void __iomem *)ra->reg); | |
| 78 | + writeq(val, ra->reg.mmio); | |
| 79 | 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 | 92 | for (domain = RAPL_DOMAIN_PACKAGE; domain < RAPL_DOMAIN_MAX; domain++) { |
| 93 | 93 | for (reg = RAPL_DOMAIN_REG_LIMIT; reg < RAPL_DOMAIN_REG_MAX; reg++) |
| 94 | 94 | if (rapl_regs->regs[domain][reg]) |
| 95 | − rapl_mmio_priv.regs[domain][reg] = | |
| 96 | − (u64)proc_priv->mmio_base + | |
| 95 | + rapl_mmio_priv.regs[domain][reg].mmio = | |
| 96 | + proc_priv->mmio_base + | |
| 97 | 97 | rapl_regs->regs[domain][reg]; |
| 98 | 98 | rapl_mmio_priv.limits[domain] = rapl_regs->limits[domain]; |
| 99 | 99 | } |
| 100 | 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 | 103 | rapl_mmio_priv.read_raw = rapl_mmio_read_raw; |
| 104 | 104 | rapl_mmio_priv.write_raw = rapl_mmio_write_raw; |
| @@ -100,10 +100,16 @@ struct rapl_package; · 99 unmodified lines | ||
| 100 | 100 | |
| 101 | 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 | 109 | struct rapl_domain { |
| 104 | 110 | char name[RAPL_DOMAIN_NAME_LENGTH]; |
| 105 | 111 | enum rapl_domain_type id; |
| 106 | − u64 regs[RAPL_DOMAIN_REG_MAX]; | |
| 112 | + union rapl_reg regs[RAPL_DOMAIN_REG_MAX]; | |
| 107 | 113 | struct powercap_zone power_zone; |
| 108 | 114 | struct rapl_domain_data rdd; |
| 109 | 115 | struct rapl_power_limit rpl[NR_POWER_LIMITS]; |
| @@ -116,7 +122,7 @@ struct rapl_domain { · 6 unmodified lines | ||
| 116 | 122 | }; |
| 117 | 123 | |
| 118 | 124 | struct reg_action { |
| 119 | − u64 reg; | |
| 125 | + union rapl_reg reg; | |
| 120 | 126 | u64 mask; |
| 121 | 127 | u64 value; |
| 122 | 128 | int err; |
| @@ -143,8 +149,8 @@ struct rapl_if_priv { · 20 unmodified lines | ||
| 143 | 149 | enum rapl_if_type type; |
| 144 | 150 | struct powercap_control_type *control_type; |
| 145 | 151 | enum cpuhp_state pcap_rapl_online; |
| 146 | − u64 reg_unit; | |
| 147 | − u64 regs[RAPL_DOMAIN_MAX][RAPL_DOMAIN_REG_MAX]; | |
| 152 | + union rapl_reg reg_unit; | |
| 153 | + union rapl_reg regs[RAPL_DOMAIN_MAX][RAPL_DOMAIN_REG_MAX]; | |
| 148 | 154 | int limits[RAPL_DOMAIN_MAX]; |
| 149 | 155 | int (*read_raw)(int id, struct reg_action *ra); |
| 150 | 156 | int (*write_raw)(int id, struct reg_action *ra); |