include/acpi/processor.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __ACPI_PROCESSOR_H
   3 #define __ACPI_PROCESSOR_H
   4
   5 #include <linux/cpu.h>
   6 #include <linux/cpufreq.h>
   7 #include <linux/pm_qos.h>
   8 #include <linux/printk.h>
   9 #include <linux/sched.h>
  10 #include <linux/smp.h>
  11 #include <linux/thermal.h>
  12 #include <linux/types.h>
  13 #include <linux/workqueue.h>
  14
  15 #include <asm/acpi.h>
  16
  17 #define ACPI_PROCESSOR_CLASS            "processor"
  18 #define ACPI_PROCESSOR_DEVICE_NAME      "Processor"
  19 #define ACPI_PROCESSOR_DEVICE_HID       "ACPI0007"
  20 #define ACPI_PROCESSOR_CONTAINER_HID    "ACPI0010"
  21
  22 #define ACPI_PROCESSOR_BUSY_METRIC      10
  23
  24 #define ACPI_PROCESSOR_MAX_POWER        8
  25 #define ACPI_PROCESSOR_MAX_C2_LATENCY   100
  26 #define ACPI_PROCESSOR_MAX_C3_LATENCY   1000
  27
  28 #define ACPI_PROCESSOR_MAX_THROTTLING   16
  29 #define ACPI_PROCESSOR_MAX_THROTTLE     250     /* 25% */
  30 #define ACPI_PROCESSOR_MAX_DUTY_WIDTH   4
  31
  32 #define ACPI_PDC_REVISION_ID            0x1
  33
  34 #define ACPI_PSD_REV0_REVISION          0       /* Support for _PSD as in ACPI 3.0 */
  35 #define ACPI_PSD_REV0_ENTRIES           5
  36
  37 #define ACPI_TSD_REV0_REVISION          0       /* Support for _PSD as in ACPI 3.0 */
  38 #define ACPI_TSD_REV0_ENTRIES           5
  39 /*
  40  * Types of coordination defined in ACPI 3.0. Same macros can be used across
  41  * P, C and T states
  42  */
  43 #define DOMAIN_COORD_TYPE_SW_ALL        0xfc
  44 #define DOMAIN_COORD_TYPE_SW_ANY        0xfd
  45 #define DOMAIN_COORD_TYPE_HW_ALL        0xfe
  46
  47 #define ACPI_CSTATE_SYSTEMIO    0
  48 #define ACPI_CSTATE_FFH         1
  49 #define ACPI_CSTATE_HALT        2
  50 #define ACPI_CSTATE_INTEGER     3
  51
  52 #define ACPI_CX_DESC_LEN        32
  53
  54 /* Power Management */
  55
  56 struct acpi_processor_cx;
  57
  58 struct acpi_power_register {
  59         u8 descriptor;
  60         u16 length;
  61         u8 space_id;
  62         u8 bit_width;
  63         u8 bit_offset;
  64         u8 access_size;
  65         u64 address;
  66 } __packed;
  67
  68 struct acpi_processor_cx {
  69         u8 valid;
  70         u8 type;
  71         u32 address;
  72         u8 entry_method;
  73         u8 index;
  74         u32 latency;
  75         u8 bm_sts_skip;
  76         char desc[ACPI_CX_DESC_LEN];
  77 };
  78
  79 struct acpi_lpi_state {
  80         u32 min_residency;
  81         u32 wake_latency; /* worst case */
  82         u32 flags;
  83         u32 arch_flags;
  84         u32 res_cnt_freq;
  85         u32 enable_parent_state;
  86         u64 address;
  87         u8 index;
  88         u8 entry_method;
  89         char desc[ACPI_CX_DESC_LEN];
  90 };
  91
  92 struct acpi_processor_power {
  93         int count;
  94         union {
  95                 struct acpi_processor_cx states[ACPI_PROCESSOR_MAX_POWER];
  96                 struct acpi_lpi_state lpi_states[ACPI_PROCESSOR_MAX_POWER];
  97         };
  98         int timer_broadcast_on_state;
  99 };
 100
 101 /* Performance Management */
 102
 103 struct acpi_psd_package {
 104         u64 num_entries;
 105         u64 revision;
 106         u64 domain;
 107         u64 coord_type;
 108         u64 num_processors;
 109 } __packed;
 110
 111 struct acpi_pct_register {
 112         u8 descriptor;
 113         u16 length;
 114         u8 space_id;
 115         u8 bit_width;
 116         u8 bit_offset;
 117         u8 reserved;
 118         u64 address;
 119 } __packed;
 120
 121 struct acpi_processor_px {
 122         u64 core_frequency;     /* megahertz */
 123         u64 power;      /* milliWatts */
 124         u64 transition_latency; /* microseconds */
 125         u64 bus_master_latency; /* microseconds */
 126         u64 control;    /* control value */
 127         u64 status;     /* success indicator */
 128 };
 129
 130 struct acpi_processor_performance {
 131         unsigned int state;
 132         unsigned int platform_limit;
 133         struct acpi_pct_register control_register;
 134         struct acpi_pct_register status_register;
 135         unsigned int state_count;
 136         struct acpi_processor_px *states;
 137         struct acpi_psd_package domain_info;
 138         cpumask_var_t shared_cpu_map;
 139         unsigned int shared_type;
 140 };
 141
 142 /* Throttling Control */
 143
 144 struct acpi_tsd_package {
 145         u64 num_entries;
 146         u64 revision;
 147         u64 domain;
 148         u64 coord_type;
 149         u64 num_processors;
 150 } __packed;
 151
 152 struct acpi_ptc_register {
 153         u8 descriptor;
 154         u16 length;
 155         u8 space_id;
 156         u8 bit_width;
 157         u8 bit_offset;
 158         u8 reserved;
 159         u64 address;
 160 } __packed;
 161
 162 struct acpi_processor_tx_tss {
 163         u64 freqpercentage;     /* */
 164         u64 power;      /* milliWatts */
 165         u64 transition_latency; /* microseconds */
 166         u64 control;    /* control value */
 167         u64 status;     /* success indicator */
 168 };
 169 struct acpi_processor_tx {
 170         u16 power;
 171         u16 performance;
 172 };
 173
 174 struct acpi_processor;
 175 struct acpi_processor_throttling {
 176         unsigned int state;
 177         unsigned int platform_limit;
 178         struct acpi_pct_register control_register;
 179         struct acpi_pct_register status_register;
 180         unsigned int state_count;
 181         struct acpi_processor_tx_tss *states_tss;
 182         struct acpi_tsd_package domain_info;
 183         cpumask_var_t shared_cpu_map;
 184         int (*acpi_processor_get_throttling) (struct acpi_processor * pr);
 185         int (*acpi_processor_set_throttling) (struct acpi_processor * pr,
 186                                               int state, bool force);
 187
 188         u32 address;
 189         u8 duty_offset;
 190         u8 duty_width;
 191         u8 tsd_valid_flag;
 192         unsigned int shared_type;
 193         struct acpi_processor_tx states[ACPI_PROCESSOR_MAX_THROTTLING];
 194 };
 195
 196 /* Limit Interface */
 197
 198 struct acpi_processor_lx {
 199         int px;                 /* performance state */
 200         int tx;                 /* throttle level */
 201 };
 202
 203 struct acpi_processor_limit {
 204         struct acpi_processor_lx state; /* current limit */
 205         struct acpi_processor_lx thermal;       /* thermal limit */
 206         struct acpi_processor_lx user;  /* user limit */
 207 };
 208
 209 struct acpi_processor_flags {
 210         u8 power:1;
 211         u8 performance:1;
 212         u8 throttling:1;
 213         u8 limit:1;
 214         u8 bm_control:1;
 215         u8 bm_check:1;
 216         u8 has_cst:1;
 217         u8 has_lpi:1;
 218         u8 power_setup_done:1;
 219         u8 bm_rld_set:1;
 220         u8 previously_online:1;
 221 };
 222
 223 struct acpi_processor {
 224         acpi_handle handle;
 225         u32 acpi_id;
 226         phys_cpuid_t phys_id;   /* CPU hardware ID such as APIC ID for x86 */
 227         u32 id;         /* CPU logical ID allocated by OS */
 228         u32 pblk;
 229         int performance_platform_limit;
 230         int throttling_platform_limit;
 231         /* 0 - states 0..n-th state available */
 232
 233         struct acpi_processor_flags flags;
 234         struct acpi_processor_power power;
 235         struct acpi_processor_performance *performance;
 236         struct acpi_processor_throttling throttling;
 237         struct acpi_processor_limit limit;
 238         struct thermal_cooling_device *cdev;
 239         struct device *dev; /* Processor device. */
 240         struct freq_qos_request perflib_req;
 241         struct freq_qos_request thermal_req;
 242 };
 243
 244 struct acpi_processor_errata {
 245         u8 smp;
 246         struct {
 247                 u8 throttle:1;
 248                 u8 fdma:1;
 249                 u8 reserved:6;
 250                 u32 bmisx;
 251         } piix4;
 252 };
 253
 254 extern int acpi_processor_preregister_performance(struct
 255                                                   acpi_processor_performance
 256                                                   __percpu *performance);
 257
 258 extern int acpi_processor_register_performance(struct acpi_processor_performance
 259                                                *performance, unsigned int cpu);
 260 extern void acpi_processor_unregister_performance(unsigned int cpu);
 261
 262 int acpi_processor_pstate_control(void);
 263 /* note: this locks both the calling module and the processor module
 264          if a _PPC object exists, rmmod is disallowed then */
 265 int acpi_processor_notify_smm(struct module *calling_module);
 266 int acpi_processor_get_psd(acpi_handle handle,
 267                            struct acpi_psd_package *pdomain);
 268
 269 /* parsing the _P* objects. */
 270 extern int acpi_processor_get_performance_info(struct acpi_processor *pr);
 271
 272 /* for communication between multiple parts of the processor kernel module */
 273 DECLARE_PER_CPU(struct acpi_processor *, processors);
 274 extern struct acpi_processor_errata errata;
 275
 276 #if defined(ARCH_HAS_POWER_INIT) && defined(CONFIG_ACPI_PROCESSOR_CSTATE)
 277 void acpi_processor_power_init_bm_check(struct acpi_processor_flags *flags,
 278                                         unsigned int cpu);
 279 int acpi_processor_ffh_cstate_probe(unsigned int cpu,
 280                                     struct acpi_processor_cx *cx,
 281                                     struct acpi_power_register *reg);
 282 void acpi_processor_ffh_cstate_enter(struct acpi_processor_cx *cstate);
 283 #else
 284 static inline void acpi_processor_power_init_bm_check(struct
 285                                                       acpi_processor_flags
 286                                                       *flags, unsigned int cpu)
 287 {
 288         flags->bm_check = 1;
 289         return;
 290 }
 291 static inline int acpi_processor_ffh_cstate_probe(unsigned int cpu,
 292                                                   struct acpi_processor_cx *cx,
 293                                                   struct acpi_power_register
 294                                                   *reg)
 295 {
 296         return -1;
 297 }
 298 static inline void acpi_processor_ffh_cstate_enter(struct acpi_processor_cx
 299                                                    *cstate)
 300 {
 301         return;
 302 }
 303 #endif
 304
 305 static inline int call_on_cpu(int cpu, long (*fn)(void *), void *arg,
 306                               bool direct)
 307 {
 308         if (direct || (is_percpu_thread() && cpu == smp_processor_id()))
 309                 return fn(arg);
 310         return work_on_cpu(cpu, fn, arg);
 311 }
 312
 313 /* in processor_perflib.c */
 314
 315 #ifdef CONFIG_CPU_FREQ
 316 extern bool acpi_processor_cpufreq_init;
 317 void acpi_processor_ignore_ppc_init(void);
 318 void acpi_processor_ppc_init(struct cpufreq_policy *policy);
 319 void acpi_processor_ppc_exit(struct cpufreq_policy *policy);
 320 void acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag);
 321 extern int acpi_processor_get_bios_limit(int cpu, unsigned int *limit);
 322 #else
 323 static inline void acpi_processor_ignore_ppc_init(void)
 324 {
 325         return;
 326 }
 327 static inline void acpi_processor_ppc_init(struct cpufreq_policy *policy)
 328 {
 329         return;
 330 }
 331 static inline void acpi_processor_ppc_exit(struct cpufreq_policy *policy)
 332 {
 333         return;
 334 }
 335 static inline void acpi_processor_ppc_has_changed(struct acpi_processor *pr,
 336                                                                 int event_flag)
 337 {
 338         static unsigned int printout = 1;
 339         if (printout) {
 340                 printk(KERN_WARNING
 341                        "Warning: Processor Platform Limit event detected, but not handled.\n");
 342                 printk(KERN_WARNING
 343                        "Consider compiling CPUfreq support into your kernel.\n");
 344                 printout = 0;
 345         }
 346 }
 347 static inline int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
 348 {
 349         return -ENODEV;
 350 }
 351
 352 #endif                          /* CONFIG_CPU_FREQ */
 353
 354 /* in processor_core.c */
 355 phys_cpuid_t acpi_get_phys_id(acpi_handle, int type, u32 acpi_id);
 356 phys_cpuid_t acpi_map_madt_entry(u32 acpi_id);
 357 int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id);
 358 int acpi_get_cpuid(acpi_handle, int type, u32 acpi_id);
 359
 360 #ifdef CONFIG_ACPI_CPPC_LIB
 361 extern int acpi_cppc_processor_probe(struct acpi_processor *pr);
 362 extern void acpi_cppc_processor_exit(struct acpi_processor *pr);
 363 #else
 364 static inline int acpi_cppc_processor_probe(struct acpi_processor *pr)
 365 {
 366         return 0;
 367 }
 368 static inline void acpi_cppc_processor_exit(struct acpi_processor *pr)
 369 {
 370         return;
 371 }
 372 #endif  /* CONFIG_ACPI_CPPC_LIB */
 373
 374 /* in processor_pdc.c */
 375 void acpi_processor_set_pdc(acpi_handle handle);
 376
 377 /* in processor_throttling.c */
 378 #ifdef CONFIG_ACPI_CPU_FREQ_PSS
 379 int acpi_processor_tstate_has_changed(struct acpi_processor *pr);
 380 int acpi_processor_get_throttling_info(struct acpi_processor *pr);
 381 extern int acpi_processor_set_throttling(struct acpi_processor *pr,
 382                                          int state, bool force);
 383 /*
 384  * Reevaluate whether the T-state is invalid after one cpu is
 385  * onlined/offlined. In such case the flags.throttling will be updated.
 386  */
 387 extern void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
 388                         bool is_dead);
 389 extern const struct file_operations acpi_processor_throttling_fops;
 390 extern void acpi_processor_throttling_init(void);
 391 #else
 392 static inline int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
 393 {
 394         return 0;
 395 }
 396
 397 static inline int acpi_processor_get_throttling_info(struct acpi_processor *pr)
 398 {
 399         return -ENODEV;
 400 }
 401
 402 static inline int acpi_processor_set_throttling(struct acpi_processor *pr,
 403                                          int state, bool force)
 404 {
 405         return -ENODEV;
 406 }
 407
 408 static inline void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
 409                         bool is_dead) {}
 410
 411 static inline void acpi_processor_throttling_init(void) {}
 412 #endif  /* CONFIG_ACPI_CPU_FREQ_PSS */
 413
 414 /* in processor_idle.c */
 415 extern struct cpuidle_driver acpi_idle_driver;
 416 #ifdef CONFIG_ACPI_PROCESSOR_IDLE
 417 int acpi_processor_power_init(struct acpi_processor *pr);
 418 int acpi_processor_power_exit(struct acpi_processor *pr);
 419 int acpi_processor_power_state_has_changed(struct acpi_processor *pr);
 420 int acpi_processor_hotplug(struct acpi_processor *pr);
 421 #else
 422 static inline int acpi_processor_power_init(struct acpi_processor *pr)
 423 {
 424         return -ENODEV;
 425 }
 426
 427 static inline int acpi_processor_power_exit(struct acpi_processor *pr)
 428 {
 429         return -ENODEV;
 430 }
 431
 432 static inline int acpi_processor_power_state_has_changed(struct acpi_processor *pr)
 433 {
 434         return -ENODEV;
 435 }
 436
 437 static inline int acpi_processor_hotplug(struct acpi_processor *pr)
 438 {
 439         return -ENODEV;
 440 }
 441 #endif /* CONFIG_ACPI_PROCESSOR_IDLE */
 442
 443 /* in processor_thermal.c */
 444 int acpi_processor_thermal_init(struct acpi_processor *pr,
 445                                 struct acpi_device *device);
 446 void acpi_processor_thermal_exit(struct acpi_processor *pr,
 447                                  struct acpi_device *device);
 448 extern const struct thermal_cooling_device_ops processor_cooling_ops;
 449 #ifdef CONFIG_CPU_FREQ
 450 void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy);
 451 void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy);
 452 #else
 453 static inline void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
 454 {
 455         return;
 456 }
 457 static inline void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy)
 458 {
 459         return;
 460 }
 461 #endif  /* CONFIG_CPU_FREQ */
 462
 463 #ifdef CONFIG_ACPI_PROCESSOR_IDLE
 464 extern int acpi_processor_ffh_lpi_probe(unsigned int cpu);
 465 extern int acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi);
 466 #endif
 467
 468 void acpi_processor_init_invariance_cppc(void);
 469
 470 #endif