]>
Commit | Line | Data |
---|---|---|
fef98671 RW |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Architecture-specific ACPI-based support for suspend-to-idle. | |
4 | * | |
5 | * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> | |
6 | * Author: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com> | |
7 | * Author: Shyam Sundar S K <Shyam-sundar.S-k@amd.com> | |
8 | * | |
9 | * On platforms supporting the Low Power S0 Idle interface there is an ACPI | |
10 | * device object with the PNP0D80 compatible device ID (System Power Management | |
11 | * Controller) and a specific _DSM method under it. That method, if present, | |
12 | * can be used to indicate to the platform that the OS is transitioning into a | |
13 | * low-power state in which certain types of activity are not desirable or that | |
14 | * it is leaving such a state, which allows the platform to adjust its operation | |
15 | * mode accordingly. | |
16 | */ | |
17 | ||
18 | #include <linux/acpi.h> | |
19 | #include <linux/device.h> | |
20 | #include <linux/suspend.h> | |
21 | ||
22 | #include "../sleep.h" | |
23 | ||
24 | #ifdef CONFIG_SUSPEND | |
25 | ||
26 | static bool sleep_no_lps0 __read_mostly; | |
27 | module_param(sleep_no_lps0, bool, 0644); | |
28 | MODULE_PARM_DESC(sleep_no_lps0, "Do not use the special LPS0 device interface"); | |
29 | ||
30 | static const struct acpi_device_id lps0_device_ids[] = { | |
31 | {"PNP0D80", }, | |
32 | {"", }, | |
33 | }; | |
34 | ||
5dbf5099 PV |
35 | /* Microsoft platform agnostic UUID */ |
36 | #define ACPI_LPS0_DSM_UUID_MICROSOFT "11e00d56-ce64-47ce-837b-1f898f9aa461" | |
37 | ||
fef98671 RW |
38 | #define ACPI_LPS0_DSM_UUID "c4eb40a0-6cd2-11e2-bcfd-0800200c9a66" |
39 | ||
40 | #define ACPI_LPS0_GET_DEVICE_CONSTRAINTS 1 | |
41 | #define ACPI_LPS0_SCREEN_OFF 3 | |
42 | #define ACPI_LPS0_SCREEN_ON 4 | |
43 | #define ACPI_LPS0_ENTRY 5 | |
44 | #define ACPI_LPS0_EXIT 6 | |
5dbf5099 PV |
45 | #define ACPI_LPS0_MS_ENTRY 7 |
46 | #define ACPI_LPS0_MS_EXIT 8 | |
fef98671 RW |
47 | |
48 | /* AMD */ | |
49 | #define ACPI_LPS0_DSM_UUID_AMD "e3f32452-febc-43ce-9039-932122d37721" | |
f59a905b AD |
50 | #define ACPI_LPS0_ENTRY_AMD 2 |
51 | #define ACPI_LPS0_EXIT_AMD 3 | |
fef98671 RW |
52 | #define ACPI_LPS0_SCREEN_OFF_AMD 4 |
53 | #define ACPI_LPS0_SCREEN_ON_AMD 5 | |
54 | ||
55 | static acpi_handle lps0_device_handle; | |
56 | static guid_t lps0_dsm_guid; | |
4a012dc8 | 57 | static int lps0_dsm_func_mask; |
fef98671 | 58 | |
5dbf5099 PV |
59 | static guid_t lps0_dsm_guid_microsoft; |
60 | static int lps0_dsm_func_mask_microsoft; | |
61 | ||
fef98671 RW |
62 | /* Device constraint entry structure */ |
63 | struct lpi_device_info { | |
64 | char *name; | |
65 | int enabled; | |
66 | union acpi_object *package; | |
67 | }; | |
68 | ||
69 | /* Constraint package structure */ | |
70 | struct lpi_device_constraint { | |
71 | int uid; | |
72 | int min_dstate; | |
73 | int function_states; | |
74 | }; | |
75 | ||
76 | struct lpi_constraints { | |
77 | acpi_handle handle; | |
78 | int min_dstate; | |
79 | }; | |
80 | ||
4a012dc8 | 81 | /* AMD Constraint package structure */ |
fef98671 RW |
82 | struct lpi_device_constraint_amd { |
83 | char *name; | |
84 | int enabled; | |
85 | int function_states; | |
86 | int min_dstate; | |
87 | }; | |
88 | ||
89 | static struct lpi_constraints *lpi_constraints_table; | |
90 | static int lpi_constraints_table_size; | |
91 | static int rev_id; | |
92 | ||
93 | static void lpi_device_get_constraints_amd(void) | |
94 | { | |
95 | union acpi_object *out_obj; | |
96 | int i, j, k; | |
97 | ||
98 | out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid, | |
904d4a6c | 99 | rev_id, ACPI_LPS0_GET_DEVICE_CONSTRAINTS, |
fef98671 RW |
100 | NULL, ACPI_TYPE_PACKAGE); |
101 | ||
fef98671 RW |
102 | acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n", |
103 | out_obj ? "successful" : "failed"); | |
104 | ||
4a012dc8 PV |
105 | if (!out_obj) |
106 | return; | |
107 | ||
fef98671 RW |
108 | for (i = 0; i < out_obj->package.count; i++) { |
109 | union acpi_object *package = &out_obj->package.elements[i]; | |
aa7a1bb0 RW |
110 | |
111 | if (package->type == ACPI_TYPE_PACKAGE) { | |
fef98671 RW |
112 | lpi_constraints_table = kcalloc(package->package.count, |
113 | sizeof(*lpi_constraints_table), | |
114 | GFP_KERNEL); | |
115 | ||
116 | if (!lpi_constraints_table) | |
117 | goto free_acpi_buffer; | |
118 | ||
119 | acpi_handle_debug(lps0_device_handle, | |
120 | "LPI: constraints list begin:\n"); | |
121 | ||
122 | for (j = 0; j < package->package.count; ++j) { | |
123 | union acpi_object *info_obj = &package->package.elements[j]; | |
124 | struct lpi_device_constraint_amd dev_info = {}; | |
125 | struct lpi_constraints *list; | |
126 | acpi_status status; | |
127 | ||
128 | for (k = 0; k < info_obj->package.count; ++k) { | |
129 | union acpi_object *obj = &info_obj->package.elements[k]; | |
fef98671 RW |
130 | |
131 | list = &lpi_constraints_table[lpi_constraints_table_size]; | |
132 | list->min_dstate = -1; | |
133 | ||
fef98671 RW |
134 | switch (k) { |
135 | case 0: | |
136 | dev_info.enabled = obj->integer.value; | |
137 | break; | |
138 | case 1: | |
139 | dev_info.name = obj->string.pointer; | |
140 | break; | |
141 | case 2: | |
142 | dev_info.function_states = obj->integer.value; | |
143 | break; | |
144 | case 3: | |
145 | dev_info.min_dstate = obj->integer.value; | |
146 | break; | |
147 | } | |
148 | ||
149 | if (!dev_info.enabled || !dev_info.name || | |
150 | !dev_info.min_dstate) | |
151 | continue; | |
152 | ||
153 | status = acpi_get_handle(NULL, dev_info.name, | |
154 | &list->handle); | |
155 | if (ACPI_FAILURE(status)) | |
156 | continue; | |
157 | ||
158 | acpi_handle_debug(lps0_device_handle, | |
159 | "Name:%s\n", dev_info.name); | |
160 | ||
161 | list->min_dstate = dev_info.min_dstate; | |
162 | ||
163 | if (list->min_dstate < 0) { | |
164 | acpi_handle_debug(lps0_device_handle, | |
165 | "Incomplete constraint defined\n"); | |
166 | continue; | |
167 | } | |
168 | } | |
169 | lpi_constraints_table_size++; | |
170 | } | |
171 | } | |
172 | } | |
173 | ||
174 | acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n"); | |
175 | ||
176 | free_acpi_buffer: | |
177 | ACPI_FREE(out_obj); | |
178 | } | |
179 | ||
180 | static void lpi_device_get_constraints(void) | |
181 | { | |
182 | union acpi_object *out_obj; | |
183 | int i; | |
184 | ||
185 | out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid, | |
186 | 1, ACPI_LPS0_GET_DEVICE_CONSTRAINTS, | |
187 | NULL, ACPI_TYPE_PACKAGE); | |
188 | ||
189 | acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n", | |
190 | out_obj ? "successful" : "failed"); | |
191 | ||
192 | if (!out_obj) | |
193 | return; | |
194 | ||
195 | lpi_constraints_table = kcalloc(out_obj->package.count, | |
196 | sizeof(*lpi_constraints_table), | |
197 | GFP_KERNEL); | |
198 | if (!lpi_constraints_table) | |
199 | goto free_acpi_buffer; | |
200 | ||
201 | acpi_handle_debug(lps0_device_handle, "LPI: constraints list begin:\n"); | |
202 | ||
203 | for (i = 0; i < out_obj->package.count; i++) { | |
204 | struct lpi_constraints *constraint; | |
205 | acpi_status status; | |
206 | union acpi_object *package = &out_obj->package.elements[i]; | |
207 | struct lpi_device_info info = { }; | |
208 | int package_count = 0, j; | |
209 | ||
210 | if (!package) | |
211 | continue; | |
212 | ||
213 | for (j = 0; j < package->package.count; ++j) { | |
214 | union acpi_object *element = | |
215 | &(package->package.elements[j]); | |
216 | ||
217 | switch (element->type) { | |
218 | case ACPI_TYPE_INTEGER: | |
219 | info.enabled = element->integer.value; | |
220 | break; | |
221 | case ACPI_TYPE_STRING: | |
222 | info.name = element->string.pointer; | |
223 | break; | |
224 | case ACPI_TYPE_PACKAGE: | |
225 | package_count = element->package.count; | |
226 | info.package = element->package.elements; | |
227 | break; | |
228 | } | |
229 | } | |
230 | ||
231 | if (!info.enabled || !info.package || !info.name) | |
232 | continue; | |
233 | ||
234 | constraint = &lpi_constraints_table[lpi_constraints_table_size]; | |
235 | ||
236 | status = acpi_get_handle(NULL, info.name, &constraint->handle); | |
237 | if (ACPI_FAILURE(status)) | |
238 | continue; | |
239 | ||
240 | acpi_handle_debug(lps0_device_handle, | |
241 | "index:%d Name:%s\n", i, info.name); | |
242 | ||
243 | constraint->min_dstate = -1; | |
244 | ||
245 | for (j = 0; j < package_count; ++j) { | |
246 | union acpi_object *info_obj = &info.package[j]; | |
247 | union acpi_object *cnstr_pkg; | |
248 | union acpi_object *obj; | |
249 | struct lpi_device_constraint dev_info; | |
250 | ||
251 | switch (info_obj->type) { | |
252 | case ACPI_TYPE_INTEGER: | |
253 | /* version */ | |
254 | break; | |
255 | case ACPI_TYPE_PACKAGE: | |
256 | if (info_obj->package.count < 2) | |
257 | break; | |
258 | ||
259 | cnstr_pkg = info_obj->package.elements; | |
260 | obj = &cnstr_pkg[0]; | |
261 | dev_info.uid = obj->integer.value; | |
262 | obj = &cnstr_pkg[1]; | |
263 | dev_info.min_dstate = obj->integer.value; | |
264 | ||
265 | acpi_handle_debug(lps0_device_handle, | |
266 | "uid:%d min_dstate:%s\n", | |
267 | dev_info.uid, | |
268 | acpi_power_state_string(dev_info.min_dstate)); | |
269 | ||
270 | constraint->min_dstate = dev_info.min_dstate; | |
271 | break; | |
272 | } | |
273 | } | |
274 | ||
275 | if (constraint->min_dstate < 0) { | |
276 | acpi_handle_debug(lps0_device_handle, | |
277 | "Incomplete constraint defined\n"); | |
278 | continue; | |
279 | } | |
280 | ||
281 | lpi_constraints_table_size++; | |
282 | } | |
283 | ||
284 | acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n"); | |
285 | ||
286 | free_acpi_buffer: | |
287 | ACPI_FREE(out_obj); | |
288 | } | |
289 | ||
290 | static void lpi_check_constraints(void) | |
291 | { | |
292 | int i; | |
293 | ||
294 | for (i = 0; i < lpi_constraints_table_size; ++i) { | |
295 | acpi_handle handle = lpi_constraints_table[i].handle; | |
296 | struct acpi_device *adev; | |
297 | ||
298 | if (!handle || acpi_bus_get_device(handle, &adev)) | |
299 | continue; | |
300 | ||
301 | acpi_handle_debug(handle, | |
302 | "LPI: required min power state:%s current power state:%s\n", | |
303 | acpi_power_state_string(lpi_constraints_table[i].min_dstate), | |
304 | acpi_power_state_string(adev->power.state)); | |
305 | ||
306 | if (!adev->flags.power_manageable) { | |
307 | acpi_handle_info(handle, "LPI: Device not power manageable\n"); | |
308 | lpi_constraints_table[i].handle = NULL; | |
309 | continue; | |
310 | } | |
311 | ||
312 | if (adev->power.state < lpi_constraints_table[i].min_dstate) | |
313 | acpi_handle_info(handle, | |
314 | "LPI: Constraint not met; min power state:%s current power state:%s\n", | |
315 | acpi_power_state_string(lpi_constraints_table[i].min_dstate), | |
316 | acpi_power_state_string(adev->power.state)); | |
317 | } | |
318 | } | |
319 | ||
3f4b116c | 320 | static void acpi_sleep_run_lps0_dsm(unsigned int func, unsigned int func_mask, guid_t dsm_guid) |
fef98671 RW |
321 | { |
322 | union acpi_object *out_obj; | |
323 | ||
3f4b116c | 324 | if (!(func_mask & (1 << func))) |
fef98671 RW |
325 | return; |
326 | ||
3f4b116c PV |
327 | out_obj = acpi_evaluate_dsm(lps0_device_handle, &dsm_guid, |
328 | rev_id, func, NULL); | |
fef98671 RW |
329 | ACPI_FREE(out_obj); |
330 | ||
331 | acpi_handle_debug(lps0_device_handle, "_DSM function %u evaluation %s\n", | |
332 | func, out_obj ? "successful" : "failed"); | |
333 | } | |
334 | ||
335 | static bool acpi_s2idle_vendor_amd(void) | |
336 | { | |
337 | return boot_cpu_data.x86_vendor == X86_VENDOR_AMD; | |
338 | } | |
339 | ||
4a012dc8 PV |
340 | static int validate_dsm(acpi_handle handle, const char *uuid, int rev, guid_t *dsm_guid) |
341 | { | |
342 | union acpi_object *obj; | |
343 | int ret = -EINVAL; | |
344 | ||
345 | guid_parse(uuid, dsm_guid); | |
346 | obj = acpi_evaluate_dsm(handle, dsm_guid, rev, 0, NULL); | |
347 | ||
348 | /* Check if the _DSM is present and as expected. */ | |
349 | if (!obj || obj->type != ACPI_TYPE_BUFFER || obj->buffer.length == 0 || | |
350 | obj->buffer.length > sizeof(u32)) { | |
351 | acpi_handle_debug(handle, | |
352 | "_DSM UUID %s rev %d function 0 evaluation failed\n", uuid, rev); | |
353 | goto out; | |
354 | } | |
355 | ||
356 | ret = *(int *)obj->buffer.pointer; | |
357 | acpi_handle_debug(handle, "_DSM UUID %s rev %d function mask: 0x%x\n", uuid, rev, ret); | |
358 | ||
359 | out: | |
360 | ACPI_FREE(obj); | |
361 | return ret; | |
362 | } | |
363 | ||
fef98671 RW |
364 | static int lps0_device_attach(struct acpi_device *adev, |
365 | const struct acpi_device_id *not_used) | |
366 | { | |
fef98671 RW |
367 | if (lps0_device_handle) |
368 | return 0; | |
369 | ||
370 | if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0)) | |
371 | return 0; | |
372 | ||
373 | if (acpi_s2idle_vendor_amd()) { | |
1ea1dbf1 | 374 | /* AMD0004, AMD0005, AMDI0005: |
8fbd6c15 ML |
375 | * - Should use rev_id 0x0 |
376 | * - function mask > 0x3: Should use AMD method, but has off by one bug | |
377 | * - function mask = 0x3: Should use Microsoft method | |
378 | * AMDI0006: | |
379 | * - should use rev_id 0x0 | |
380 | * - function mask = 0x3: Should use Microsoft method | |
f0c62255 ML |
381 | * AMDI0007: |
382 | * - Should use rev_id 0x2 | |
383 | * - Should only use AMD method | |
8fbd6c15 ML |
384 | */ |
385 | const char *hid = acpi_device_hid(adev); | |
f0c62255 | 386 | rev_id = strcmp(hid, "AMDI0007") ? 0 : 2; |
4a012dc8 PV |
387 | lps0_dsm_func_mask = validate_dsm(adev->handle, |
388 | ACPI_LPS0_DSM_UUID_AMD, rev_id, &lps0_dsm_guid); | |
5dbf5099 | 389 | lps0_dsm_func_mask_microsoft = validate_dsm(adev->handle, |
f0c62255 | 390 | ACPI_LPS0_DSM_UUID_MICROSOFT, 0, |
5dbf5099 | 391 | &lps0_dsm_guid_microsoft); |
8fbd6c15 | 392 | if (lps0_dsm_func_mask > 0x3 && (!strcmp(hid, "AMD0004") || |
1ea1dbf1 | 393 | !strcmp(hid, "AMD0005") || |
8fbd6c15 ML |
394 | !strcmp(hid, "AMDI0005"))) { |
395 | lps0_dsm_func_mask = (lps0_dsm_func_mask << 1) | 0x1; | |
396 | acpi_handle_debug(adev->handle, "_DSM UUID %s: Adjusted function mask: 0x%x\n", | |
397 | ACPI_LPS0_DSM_UUID_AMD, lps0_dsm_func_mask); | |
f0c62255 ML |
398 | } else if (lps0_dsm_func_mask_microsoft > 0 && !strcmp(hid, "AMDI0007")) { |
399 | lps0_dsm_func_mask_microsoft = -EINVAL; | |
400 | acpi_handle_debug(adev->handle, "_DSM Using AMD method\n"); | |
8fbd6c15 | 401 | } |
fef98671 | 402 | } else { |
fef98671 | 403 | rev_id = 1; |
4a012dc8 PV |
404 | lps0_dsm_func_mask = validate_dsm(adev->handle, |
405 | ACPI_LPS0_DSM_UUID, rev_id, &lps0_dsm_guid); | |
5dbf5099 | 406 | lps0_dsm_func_mask_microsoft = -EINVAL; |
fef98671 RW |
407 | } |
408 | ||
5dbf5099 PV |
409 | if (lps0_dsm_func_mask < 0 && lps0_dsm_func_mask_microsoft < 0) |
410 | return 0; //function evaluation failed | |
fef98671 RW |
411 | |
412 | lps0_device_handle = adev->handle; | |
413 | ||
414 | if (acpi_s2idle_vendor_amd()) | |
415 | lpi_device_get_constraints_amd(); | |
416 | else | |
417 | lpi_device_get_constraints(); | |
418 | ||
419 | /* | |
420 | * Use suspend-to-idle by default if the default suspend mode was not | |
421 | * set from the command line. | |
422 | */ | |
423 | if (mem_sleep_default > PM_SUSPEND_MEM && !acpi_sleep_default_s3) | |
424 | mem_sleep_current = PM_SUSPEND_TO_IDLE; | |
425 | ||
426 | /* | |
7b167c4c ML |
427 | * Some Intel based LPS0 systems, like ASUS Zenbook UX430UNR/i7-8550U don't |
428 | * use intel-hid or intel-vbtn but require the EC GPE to be enabled while | |
429 | * suspended for certain wakeup devices to work, so mark it as wakeup-capable. | |
430 | * | |
431 | * Only enable on !AMD as enabling this universally causes problems for a number | |
432 | * of AMD based systems. | |
fef98671 | 433 | */ |
7b167c4c ML |
434 | if (!acpi_s2idle_vendor_amd()) |
435 | acpi_ec_mark_gpe_for_wake(); | |
fef98671 RW |
436 | |
437 | return 0; | |
438 | } | |
439 | ||
440 | static struct acpi_scan_handler lps0_handler = { | |
441 | .ids = lps0_device_ids, | |
442 | .attach = lps0_device_attach, | |
443 | }; | |
444 | ||
445 | int acpi_s2idle_prepare_late(void) | |
446 | { | |
447 | if (!lps0_device_handle || sleep_no_lps0) | |
448 | return 0; | |
449 | ||
450 | if (pm_debug_messages_on) | |
451 | lpi_check_constraints(); | |
452 | ||
fa209644 ML |
453 | /* Screen off */ |
454 | if (lps0_dsm_func_mask > 0) | |
455 | acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ? | |
456 | ACPI_LPS0_SCREEN_OFF_AMD : | |
457 | ACPI_LPS0_SCREEN_OFF, | |
458 | lps0_dsm_func_mask, lps0_dsm_guid); | |
459 | ||
460 | if (lps0_dsm_func_mask_microsoft > 0) | |
5dbf5099 PV |
461 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_OFF, |
462 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); | |
fa209644 ML |
463 | |
464 | /* LPS0 entry */ | |
465 | if (lps0_dsm_func_mask > 0) | |
466 | acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ? | |
467 | ACPI_LPS0_ENTRY_AMD : | |
468 | ACPI_LPS0_ENTRY, | |
469 | lps0_dsm_func_mask, lps0_dsm_guid); | |
470 | if (lps0_dsm_func_mask_microsoft > 0) { | |
5dbf5099 PV |
471 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_ENTRY, |
472 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); | |
fa209644 ML |
473 | /* modern standby entry */ |
474 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_ENTRY, | |
475 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); | |
fef98671 | 476 | } |
fef98671 RW |
477 | return 0; |
478 | } | |
479 | ||
480 | void acpi_s2idle_restore_early(void) | |
481 | { | |
482 | if (!lps0_device_handle || sleep_no_lps0) | |
483 | return; | |
484 | ||
fa209644 ML |
485 | /* Modern standby exit */ |
486 | if (lps0_dsm_func_mask_microsoft > 0) | |
4753b46e | 487 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_MS_EXIT, |
5dbf5099 | 488 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); |
fa209644 ML |
489 | |
490 | /* LPS0 exit */ | |
491 | if (lps0_dsm_func_mask > 0) | |
492 | acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ? | |
493 | ACPI_LPS0_EXIT_AMD : | |
494 | ACPI_LPS0_EXIT, | |
495 | lps0_dsm_func_mask, lps0_dsm_guid); | |
496 | if (lps0_dsm_func_mask_microsoft > 0) | |
3f4b116c | 497 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_EXIT, |
fa209644 ML |
498 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); |
499 | ||
500 | /* Screen on */ | |
501 | if (lps0_dsm_func_mask_microsoft > 0) | |
3f4b116c | 502 | acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_ON, |
fa209644 ML |
503 | lps0_dsm_func_mask_microsoft, lps0_dsm_guid_microsoft); |
504 | if (lps0_dsm_func_mask > 0) | |
505 | acpi_sleep_run_lps0_dsm(acpi_s2idle_vendor_amd() ? | |
506 | ACPI_LPS0_SCREEN_ON_AMD : | |
507 | ACPI_LPS0_SCREEN_ON, | |
508 | lps0_dsm_func_mask, lps0_dsm_guid); | |
fef98671 RW |
509 | } |
510 | ||
511 | static const struct platform_s2idle_ops acpi_s2idle_ops_lps0 = { | |
512 | .begin = acpi_s2idle_begin, | |
513 | .prepare = acpi_s2idle_prepare, | |
514 | .prepare_late = acpi_s2idle_prepare_late, | |
515 | .wake = acpi_s2idle_wake, | |
516 | .restore_early = acpi_s2idle_restore_early, | |
517 | .restore = acpi_s2idle_restore, | |
518 | .end = acpi_s2idle_end, | |
519 | }; | |
520 | ||
521 | void acpi_s2idle_setup(void) | |
522 | { | |
523 | acpi_scan_add_handler(&lps0_handler); | |
524 | s2idle_set_ops(&acpi_s2idle_ops_lps0); | |
525 | } | |
526 | ||
527 | #endif /* CONFIG_SUSPEND */ |