/include/acpi/processor.h

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C Header · 355 lines · 290 code · 44 blank · 21 comment · 1 complexity · 3283e04a5204c132ead8b666651bb546 MD5 · raw file 

    

  1. #ifndef __ACPI_PROCESSOR_H
    2. 

  2. #define __ACPI_PROCESSOR_H
    3. 

  3. 

  4. #include <linux/kernel.h>
    5. 

  5. #include <linux/cpu.h>
    6. 

  6. #include <linux/cpuidle.h>
    7. 

  7. #include <linux/thermal.h>
    8. 

  8. #include <asm/acpi.h>
    9. 

  9. 

  10. #define ACPI_PROCESSOR_BUSY_METRIC	10
    11. 

  11. 

  12. #define ACPI_PROCESSOR_MAX_POWER	8
    13. 

  13. #define ACPI_PROCESSOR_MAX_C2_LATENCY	100
    14. 

  14. #define ACPI_PROCESSOR_MAX_C3_LATENCY	1000
    15. 

  15. 

  16. #define ACPI_PROCESSOR_MAX_THROTTLING	16
    17. 

  17. #define ACPI_PROCESSOR_MAX_THROTTLE	250	/* 25% */
    18. 

  18. #define ACPI_PROCESSOR_MAX_DUTY_WIDTH	4
    19. 

  19. 

  20. #define ACPI_PDC_REVISION_ID		0x1
    21. 

  21. 

  22. #define ACPI_PSD_REV0_REVISION		0	/* Support for _PSD as in ACPI 3.0 */
    23. 

  23. #define ACPI_PSD_REV0_ENTRIES		5
    24. 

  24. 

  25. #define ACPI_TSD_REV0_REVISION		0	/* Support for _PSD as in ACPI 3.0 */
    26. 

  26. #define ACPI_TSD_REV0_ENTRIES		5
    27. 

  27. /*
    28. 

  28.  * Types of coordination defined in ACPI 3.0. Same macros can be used across
    29. 

  29.  * P, C and T states
    30. 

  30.  */
    31. 

  31. #define DOMAIN_COORD_TYPE_SW_ALL	0xfc
    32. 

  32. #define DOMAIN_COORD_TYPE_SW_ANY	0xfd
    33. 

  33. #define DOMAIN_COORD_TYPE_HW_ALL	0xfe
    34. 

  34. 

  35. #define ACPI_CSTATE_SYSTEMIO	0
    36. 

  36. #define ACPI_CSTATE_FFH		1
    37. 

  37. #define ACPI_CSTATE_HALT	2
    38. 

  38. 

  39. #define ACPI_CX_DESC_LEN	32
    40. 

  40. 

  41. /* Power Management */
    42. 

  42. 

  43. struct acpi_processor_cx;
    44. 

  44. 

  45. struct acpi_power_register {
    46. 

  46. 	u8 descriptor;
    47. 

  47. 	u16 length;
    48. 

  48. 	u8 space_id;
    49. 

  49. 	u8 bit_width;
    50. 

  50. 	u8 bit_offset;
    51. 

  51. 	u8 access_size;
    52. 

  52. 	u64 address;
    53. 

  53. } __attribute__ ((packed));
    54. 

  54. 

  55. struct acpi_processor_cx {
    56. 

  56. 	u8 valid;
    57. 

  57. 	u8 type;
    58. 

  58. 	u32 address;
    59. 

  59. 	u8 entry_method;
    60. 

  60. 	u8 index;
    61. 

  61. 	u32 latency;
    62. 

  62. 	u32 latency_ticks;
    63. 

  63. 	u32 power;
    64. 

  64. 	u32 usage;
    65. 

  65. 	u64 time;
    66. 

  66. 	u8 bm_sts_skip;
    67. 

  67. 	char desc[ACPI_CX_DESC_LEN];
    68. 

  68. };
    69. 

  69. 

  70. struct acpi_processor_power {
    71. 

  71. 	struct cpuidle_device dev;
    72. 

  72. 	struct acpi_processor_cx *state;
    73. 

  73. 	unsigned long bm_check_timestamp;
    74. 

  74. 	u32 default_state;
    75. 

  75. 	int count;
    76. 

  76. 	struct acpi_processor_cx states[ACPI_PROCESSOR_MAX_POWER];
    77. 

  77. 	int timer_broadcast_on_state;
    78. 

  78. };
    79. 

  79. 

  80. /* Performance Management */
    81. 

  81. 

  82. struct acpi_psd_package {
    83. 

  83. 	u64 num_entries;
    84. 

  84. 	u64 revision;
    85. 

  85. 	u64 domain;
    86. 

  86. 	u64 coord_type;
    87. 

  87. 	u64 num_processors;
    88. 

  88. } __attribute__ ((packed));
    89. 

  89. 

  90. struct acpi_pct_register {
    91. 

  91. 	u8 descriptor;
    92. 

  92. 	u16 length;
    93. 

  93. 	u8 space_id;
    94. 

  94. 	u8 bit_width;
    95. 

  95. 	u8 bit_offset;
    96. 

  96. 	u8 reserved;
    97. 

  97. 	u64 address;
    98. 

  98. } __attribute__ ((packed));
    99. 

  99. 

  100. struct acpi_processor_px {
    101. 

  101. 	u64 core_frequency;	/* megahertz */
    102. 

  102. 	u64 power;	/* milliWatts */
    103. 

  103. 	u64 transition_latency;	/* microseconds */
    104. 

  104. 	u64 bus_master_latency;	/* microseconds */
    105. 

  105. 	u64 control;	/* control value */
    106. 

  106. 	u64 status;	/* success indicator */
    107. 

  107. };
    108. 

  108. 

  109. struct acpi_processor_performance {
    110. 

  110. 	unsigned int state;
    111. 

  111. 	unsigned int platform_limit;
    112. 

  112. 	struct acpi_pct_register control_register;
    113. 

  113. 	struct acpi_pct_register status_register;
    114. 

  114. 	unsigned int state_count;
    115. 

  115. 	struct acpi_processor_px *states;
    116. 

  116. 	struct acpi_psd_package domain_info;
    117. 

  117. 	cpumask_var_t shared_cpu_map;
    118. 

  118. 	unsigned int shared_type;
    119. 

  119. };
    120. 

  120. 

  121. /* Throttling Control */
    122. 

  122. 

  123. struct acpi_tsd_package {
    124. 

  124. 	u64 num_entries;
    125. 

  125. 	u64 revision;
    126. 

  126. 	u64 domain;
    127. 

  127. 	u64 coord_type;
    128. 

  128. 	u64 num_processors;
    129. 

  129. } __attribute__ ((packed));
    130. 

  130. 

  131. struct acpi_ptc_register {
    132. 

  132. 	u8 descriptor;
    133. 

  133. 	u16 length;
    134. 

  134. 	u8 space_id;
    135. 

  135. 	u8 bit_width;
    136. 

  136. 	u8 bit_offset;
    137. 

  137. 	u8 reserved;
    138. 

  138. 	u64 address;
    139. 

  139. } __attribute__ ((packed));
    140. 

  140. 

  141. struct acpi_processor_tx_tss {
    142. 

  142. 	u64 freqpercentage;	/* */
    143. 

  143. 	u64 power;	/* milliWatts */
    144. 

  144. 	u64 transition_latency;	/* microseconds */
    145. 

  145. 	u64 control;	/* control value */
    146. 

  146. 	u64 status;	/* success indicator */
    147. 

  147. };
    148. 

  148. struct acpi_processor_tx {
    149. 

  149. 	u16 power;
    150. 

  150. 	u16 performance;
    151. 

  151. };
    152. 

  152. 

  153. struct acpi_processor;
    154. 

  154. struct acpi_processor_throttling {
    155. 

  155. 	unsigned int state;
    156. 

  156. 	unsigned int platform_limit;
    157. 

  157. 	struct acpi_pct_register control_register;
    158. 

  158. 	struct acpi_pct_register status_register;
    159. 

  159. 	unsigned int state_count;
    160. 

  160. 	struct acpi_processor_tx_tss *states_tss;
    161. 

  161. 	struct acpi_tsd_package domain_info;
    162. 

  162. 	cpumask_var_t shared_cpu_map;
    163. 

  163. 	int (*acpi_processor_get_throttling) (struct acpi_processor * pr);
    164. 

  164. 	int (*acpi_processor_set_throttling) (struct acpi_processor * pr,
    165. 

  165. 					      int state, bool force);
    166. 

  166. 

  167. 	u32 address;
    168. 

  168. 	u8 duty_offset;
    169. 

  169. 	u8 duty_width;
    170. 

  170. 	u8 tsd_valid_flag;
    171. 

  171. 	unsigned int shared_type;
    172. 

  172. 	struct acpi_processor_tx states[ACPI_PROCESSOR_MAX_THROTTLING];
    173. 

  173. };
    174. 

  174. 

  175. /* Limit Interface */
    176. 

  176. 

  177. struct acpi_processor_lx {
    178. 

  178. 	int px;			/* performance state */
    179. 

  179. 	int tx;			/* throttle level */
    180. 

  180. };
    181. 

  181. 

  182. struct acpi_processor_limit {
    183. 

  183. 	struct acpi_processor_lx state;	/* current limit */
    184. 

  184. 	struct acpi_processor_lx thermal;	/* thermal limit */
    185. 

  185. 	struct acpi_processor_lx user;	/* user limit */
    186. 

  186. };
    187. 

  187. 

  188. struct acpi_processor_flags {
    189. 

  189. 	u8 power:1;
    190. 

  190. 	u8 performance:1;
    191. 

  191. 	u8 throttling:1;
    192. 

  192. 	u8 limit:1;
    193. 

  193. 	u8 bm_control:1;
    194. 

  194. 	u8 bm_check:1;
    195. 

  195. 	u8 has_cst:1;
    196. 

  196. 	u8 power_setup_done:1;
    197. 

  197. 	u8 bm_rld_set:1;
    198. 

  198. };
    199. 

  199. 

  200. struct acpi_processor {
    201. 

  201. 	acpi_handle handle;
    202. 

  202. 	u32 acpi_id;
    203. 

  203. 	u32 id;
    204. 

  204. 	u32 pblk;
    205. 

  205. 	int performance_platform_limit;
    206. 

  206. 	int throttling_platform_limit;
    207. 

  207. 	/* 0 - states 0..n-th state available */
    208. 

  208. 

  209. 	struct acpi_processor_flags flags;
    210. 

  210. 	struct acpi_processor_power power;
    211. 

  211. 	struct acpi_processor_performance *performance;
    212. 

  212. 	struct acpi_processor_throttling throttling;
    213. 

  213. 	struct acpi_processor_limit limit;
    214. 

  214. 	struct thermal_cooling_device *cdev;
    215. 

  215. };
    216. 

  216. 

  217. struct acpi_processor_errata {
    218. 

  218. 	u8 smp;
    219. 

  219. 	struct {
    220. 

  220. 		u8 throttle:1;
    221. 

  221. 		u8 fdma:1;
    222. 

  222. 		u8 reserved:6;
    223. 

  223. 		u32 bmisx;
    224. 

  224. 	} piix4;
    225. 

  225. };
    226. 

  226. 

  227. extern int acpi_processor_preregister_performance(struct
    228. 

  228. 						  acpi_processor_performance
    229. 

  229. 						  __percpu *performance);
    230. 

  230. 

  231. extern int acpi_processor_register_performance(struct acpi_processor_performance
    232. 

  232. 					       *performance, unsigned int cpu);
    233. 

  233. extern void acpi_processor_unregister_performance(struct
    234. 

  234. 						  acpi_processor_performance
    235. 

  235. 						  *performance,
    236. 

  236. 						  unsigned int cpu);
    237. 

  237. 

  238. /* note: this locks both the calling module and the processor module
    239. 

  239.          if a _PPC object exists, rmmod is disallowed then */
    240. 

  240. int acpi_processor_notify_smm(struct module *calling_module);
    241. 

  241. 

  242. /* for communication between multiple parts of the processor kernel module */
    243. 

  243. DECLARE_PER_CPU(struct acpi_processor *, processors);
    244. 

  244. extern struct acpi_processor_errata errata;
    245. 

  245. 

  246. #ifdef ARCH_HAS_POWER_INIT
    247. 

  247. void acpi_processor_power_init_bm_check(struct acpi_processor_flags *flags,
    248. 

  248. 					unsigned int cpu);
    249. 

  249. int acpi_processor_ffh_cstate_probe(unsigned int cpu,
    250. 

  250. 				    struct acpi_processor_cx *cx,
    251. 

  251. 				    struct acpi_power_register *reg);
    252. 

  252. void acpi_processor_ffh_cstate_enter(struct acpi_processor_cx *cstate);
    253. 

  253. #else
    254. 

  254. static inline void acpi_processor_power_init_bm_check(struct
    255. 

  255. 						      acpi_processor_flags
    256. 

  256. 						      *flags, unsigned int cpu)
    257. 

  257. {
    258. 

  258. 	flags->bm_check = 1;
    259. 

  259. 	return;
    260. 

  260. }
    261. 

  261. static inline int acpi_processor_ffh_cstate_probe(unsigned int cpu,
    262. 

  262. 						  struct acpi_processor_cx *cx,
    263. 

  263. 						  struct acpi_power_register
    264. 

  264. 						  *reg)
    265. 

  265. {
    266. 

  266. 	return -1;
    267. 

  267. }
    268. 

  268. static inline void acpi_processor_ffh_cstate_enter(struct acpi_processor_cx
    269. 

  269. 						   *cstate)
    270. 

  270. {
    271. 

  271. 	return;
    272. 

  272. }
    273. 

  273. #endif
    274. 

  274. 

  275. /* in processor_perflib.c */
    276. 

  276. 

  277. #ifdef CONFIG_CPU_FREQ
    278. 

  278. void acpi_processor_ppc_init(void);
    279. 

  279. void acpi_processor_ppc_exit(void);
    280. 

  280. int acpi_processor_ppc_has_changed(struct acpi_processor *pr, int event_flag);
    281. 

  281. extern int acpi_processor_get_bios_limit(int cpu, unsigned int *limit);
    282. 

  282. #else
    283. 

  283. static inline void acpi_processor_ppc_init(void)
    284. 

  284. {
    285. 

  285. 	return;
    286. 

  286. }
    287. 

  287. static inline void acpi_processor_ppc_exit(void)
    288. 

  288. {
    289. 

  289. 	return;
    290. 

  290. }
    291. 

  291. static inline int acpi_processor_ppc_has_changed(struct acpi_processor *pr,
    292. 

  292. 								int event_flag)
    293. 

  293. {
    294. 

  294. 	static unsigned int printout = 1;
    295. 

  295. 	if (printout) {
    296. 

  296. 		printk(KERN_WARNING
    297. 

  297. 		       "Warning: Processor Platform Limit event detected, but not handled.\n");
    298. 

  298. 		printk(KERN_WARNING
    299. 

  299. 		       "Consider compiling CPUfreq support into your kernel.\n");
    300. 

  300. 		printout = 0;
    301. 

  301. 	}
    302. 

  302. 	return 0;
    303. 

  303. }
    304. 

  304. static inline int acpi_processor_get_bios_limit(int cpu, unsigned int *limit)
    305. 

  305. {
    306. 

  306. 	return -ENODEV;
    307. 

  307. }
    308. 

  308. 

  309. #endif				/* CONFIG_CPU_FREQ */
    310. 

  310. 

  311. /* in processor_core.c */
    312. 

  312. void acpi_processor_set_pdc(acpi_handle handle);
    313. 

  313. int acpi_get_cpuid(acpi_handle, int type, u32 acpi_id);
    314. 

  314. 

  315. /* in processor_throttling.c */
    316. 

  316. int acpi_processor_tstate_has_changed(struct acpi_processor *pr);
    317. 

  317. int acpi_processor_get_throttling_info(struct acpi_processor *pr);
    318. 

  318. extern int acpi_processor_set_throttling(struct acpi_processor *pr,
    319. 

  319. 					 int state, bool force);
    320. 

  320. /*
    321. 

  321.  * Reevaluate whether the T-state is invalid after one cpu is
    322. 

  322.  * onlined/offlined. In such case the flags.throttling will be updated.
    323. 

  323.  */
    324. 

  324. extern void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
    325. 

  325. 			unsigned long action);
    326. 

  326. extern const struct file_operations acpi_processor_throttling_fops;
    327. 

  327. extern void acpi_processor_throttling_init(void);
    328. 

  328. /* in processor_idle.c */
    329. 

  329. int acpi_processor_power_init(struct acpi_processor *pr,
    330. 

  330. 			      struct acpi_device *device);
    331. 

  331. int acpi_processor_cst_has_changed(struct acpi_processor *pr);
    332. 

  332. int acpi_processor_power_exit(struct acpi_processor *pr,
    333. 

  333. 			      struct acpi_device *device);
    334. 

  334. int acpi_processor_suspend(struct acpi_device * device, pm_message_t state);
    335. 

  335. int acpi_processor_resume(struct acpi_device * device);
    336. 

  336. extern struct cpuidle_driver acpi_idle_driver;
    337. 

  337. 

  338. /* in processor_thermal.c */
    339. 

  339. int acpi_processor_get_limit_info(struct acpi_processor *pr);
    340. 

  340. extern const struct thermal_cooling_device_ops processor_cooling_ops;
    341. 

  341. #ifdef CONFIG_CPU_FREQ
    342. 

  342. void acpi_thermal_cpufreq_init(void);
    343. 

  343. void acpi_thermal_cpufreq_exit(void);
    344. 

  344. #else
    345. 

  345. static inline void acpi_thermal_cpufreq_init(void)
    346. 

  346. {
    347. 

  347. 	return;
    348. 

  348. }
    349. 

  349. static inline void acpi_thermal_cpufreq_exit(void)
    350. 

  350. {
    351. 

  351. 	return;
    352. 

  352. }
    353. 

  353. #endif
    354. 

  354. 

  355. #endif
    356.