Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
platform/x86/intel/pmc: Move LPM mode attributes to PMC
Move LPM modes attributes from the pmc_dev to the pmc structure. LPM
modes are PMC-specific and should be stored within the pmc structure.
After the change, LPM mode information will be retrieved and stored per
PMC. The substate_requirements attribute in debugfs will display the
requirements for each enabled LPM substate.
Signed-off-by: Xi Pardee <xi.pardee@linux.intel.com>
Link: https://patch.msgid.link/20260108223144.504267-3-xi.pardee@linux.intel.com
Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
authored by
Xi Pardee
and committed by
Ilpo Järvinen
92911c91
65b3a922
+34
-20
+27
-12
drivers/platform/x86/intel/pmc/core.c
+27
-12
drivers/platform/x86/intel/pmc/core.c
···
783
783
784
784
seq_printf(s, "%-10s %-15s\n", "Substate", "Residency");
785
785
786
-
pmc_for_each_mode(mode, pmcdev) {
786
+
pmc_for_each_mode(mode, pmc) {
787
787
seq_printf(s, "%-10s %-15llu\n", pmc_lpm_modes[mode],
788
788
adjust_lpm_residency(pmc, offset + (4 * mode), lpm_adj_x2));
789
789
}
···
838
838
enum header_type type)
839
839
{
840
840
struct pmc_dev *pmcdev = s->private;
841
+
struct pmc *pmc = pmcdev->pmcs[pmc_index];
841
842
u8 mode;
842
843
843
844
seq_printf(s, "%40s |", "Element");
844
-
pmc_for_each_mode(mode, pmcdev)
845
+
pmc_for_each_mode(mode, pmc)
845
846
seq_printf(s, " %9s |", pmc_lpm_modes[mode]);
846
847
847
848
if (type == HEADER_STATUS) {
···
888
887
889
888
counter = pmc_core_reg_read(pmc, offset);
890
889
seq_printf(s, "pmc%u: %34s |", pmc_idx, map->name);
891
-
pmc_for_each_mode(mode, pmcdev) {
890
+
pmc_for_each_mode(mode, pmc) {
892
891
bool required = *lpm_req_regs & BIT(mode);
893
892
894
893
seq_printf(s, " %9s |", required ? "Required" : " ");
···
962
961
* show an element if it's required for at least one of the
963
962
* enabled low power modes
964
963
*/
965
-
pmc_for_each_mode(mode, pmcdev)
964
+
pmc_for_each_mode(mode, pmc)
966
965
req_mask |= lpm_req_regs[mp + (mode * num_maps)];
967
966
968
967
/* Get the last latched status for this map */
···
988
987
seq_printf(s, "pmc%d: %34s |", pmc_idx, map[i].name);
989
988
990
989
/* Loop over the enabled states and display if required */
991
-
pmc_for_each_mode(mode, pmcdev) {
990
+
pmc_for_each_mode(mode, pmc) {
992
991
bool required = lpm_req_regs[mp + (mode * num_maps)] &
993
992
bit_mask;
994
993
seq_printf(s, " %9s |", required ? "Required" : " ");
···
1078
1077
c10 = true;
1079
1078
}
1080
1079
1081
-
pmc_for_each_mode(mode, pmcdev) {
1080
+
pmc_for_each_mode(mode, pmc) {
1082
1081
if ((BIT(mode) & reg) && !c10)
1083
1082
seq_printf(s, " [%s]", pmc_lpm_modes[mode]);
1084
1083
else
···
1118
1117
mode = sysfs_match_string(pmc_lpm_modes, buf);
1119
1118
1120
1119
/* Check string matches enabled mode */
1121
-
pmc_for_each_mode(m, pmcdev)
1120
+
pmc_for_each_mode(m, pmc)
1122
1121
if (mode == m)
1123
1122
break;
1124
1123
···
1214
1213
return true;
1215
1214
}
1216
1215
1217
-
void pmc_core_get_low_power_modes(struct pmc_dev *pmcdev)
1216
+
static void pmc_core_pmc_get_low_power_modes(struct pmc_dev *pmcdev, struct pmc *pmc)
1218
1217
{
1219
-
struct pmc *pmc = pmcdev->pmcs[PMC_IDX_MAIN];
1220
1218
u8 pri_order[LPM_MAX_NUM_MODES] = LPM_DEFAULT_PRI;
1221
1219
u8 mode_order[LPM_MAX_NUM_MODES];
1222
1220
u32 lpm_pri;
···
1233
1233
* Lower byte is enough to cover the number of lpm modes for all
1234
1234
* platforms and hence mask the upper 3 bytes.
1235
1235
*/
1236
-
pmcdev->num_lpm_modes = hweight32(lpm_en & 0xFF);
1236
+
pmc->num_lpm_modes = hweight32(lpm_en & 0xFF);
1237
1237
1238
1238
/* Read 32 bit LPM_PRI register */
1239
1239
lpm_pri = pmc_core_reg_read(pmc, pmc->map->lpm_priority_offset);
···
1262
1262
if (!(BIT(mode) & lpm_en))
1263
1263
continue;
1264
1264
1265
-
pmcdev->lpm_en_modes[i++] = mode;
1265
+
pmc->lpm_en_modes[i++] = mode;
1266
+
}
1267
+
}
1268
+
1269
+
static void pmc_core_get_low_power_modes(struct pmc_dev *pmcdev)
1270
+
{
1271
+
unsigned int pmc_idx;
1272
+
1273
+
for (pmc_idx = 0; pmc_idx < ARRAY_SIZE(pmcdev->pmcs); pmc_idx++) {
1274
+
struct pmc *pmc;
1275
+
1276
+
pmc = pmcdev->pmcs[pmc_idx];
1277
+
if (!pmc)
1278
+
continue;
1279
+
1280
+
pmc_core_pmc_get_low_power_modes(pmcdev, pmc);
1266
1281
}
1267
1282
}
1268
1283
···
1522
1507
return -ENOMEM;
1523
1508
1524
1509
mode_offset = LPM_HEADER_OFFSET + LPM_MODE_OFFSET;
1525
-
pmc_for_each_mode(mode, pmcdev) {
1510
+
pmc_for_each_mode(mode, pmc) {
1526
1511
u32 *req_offset = pmc->lpm_req_regs + (mode * num_maps);
1527
1512
int m;
1528
1513
+7
-8
drivers/platform/x86/intel/pmc/core.h
+7
-8
drivers/platform/x86/intel/pmc/core.h
···
423
423
* specific attributes
424
424
* @lpm_req_regs: List of substate requirements
425
425
* @ltr_ign: Holds LTR ignore data while suspended
426
+
* @num_lpm_modes: Count of enabled modes
427
+
* @lpm_en_modes: Array of enabled modes from lowest to highest priority
426
428
*
427
429
* pmc contains info about one power management controller device.
428
430
*/
···
434
432
const struct pmc_reg_map *map;
435
433
u32 *lpm_req_regs;
436
434
u32 ltr_ign;
435
+
u8 num_lpm_modes;
436
+
u8 lpm_en_modes[LPM_MAX_NUM_MODES];
437
437
};
438
438
439
439
/**
···
450
446
* @pkgc_res_cnt: Array of PKGC residency counters
451
447
* @num_of_pkgc: Number of PKGC
452
448
* @s0ix_counter: S0ix residency (step adjusted)
453
-
* @num_lpm_modes: Count of enabled modes
454
-
* @lpm_en_modes: Array of enabled modes from lowest to highest priority
455
449
* @suspend: Function to perform platform specific suspend
456
450
* @resume: Function to perform platform specific resume
457
451
*
···
464
462
struct mutex lock; /* generic mutex lock for PMC Core */
465
463
466
464
u64 s0ix_counter;
467
-
u8 num_lpm_modes;
468
-
u8 lpm_en_modes[LPM_MAX_NUM_MODES];
469
465
void (*suspend)(struct pmc_dev *pmcdev);
470
466
int (*resume)(struct pmc_dev *pmcdev);
471
467
···
535
535
536
536
int pmc_core_resume_common(struct pmc_dev *pmcdev);
537
537
int get_primary_reg_base(struct pmc *pmc);
538
-
void pmc_core_get_low_power_modes(struct pmc_dev *pmcdev);
539
538
void pmc_core_punit_pmt_init(struct pmc_dev *pmcdev, u32 *guids);
540
539
void pmc_core_set_device_d3(unsigned int device);
541
540
···
562
563
extern const struct file_operations pmc_core_substate_req_regs_fops;
563
564
extern const struct file_operations pmc_core_substate_blk_req_fops;
564
565
565
-
#define pmc_for_each_mode(mode, pmcdev) \
566
+
#define pmc_for_each_mode(mode, pmc) \
566
567
for (unsigned int __i = 0, __cond; \
567
-
__cond = __i < (pmcdev)->num_lpm_modes, \
568
-
__cond && ((mode) = (pmcdev)->lpm_en_modes[__i]), \
568
+
__cond = __i < (pmc)->num_lpm_modes, \
569
+
__cond && ((mode) = (pmc)->lpm_en_modes[__i]), \
569
570
__cond; \
570
571
__i++)
571
572