Commit | Line | Data |
---|---|---|
efd4e418 AD |
1 | /* |
2 | * Copyright 2012 Advanced Micro Devices, Inc. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice shall be included in | |
12 | * all copies or substantial portions of the Software. | |
13 | * | |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
20 | * OTHER DEALINGS IN THE SOFTWARE. | |
21 | * | |
22 | */ | |
23 | ||
d7a2952f AM |
24 | #include <linux/pci.h> |
25 | #include <linux/acpi.h> | |
26 | #include <linux/slab.h> | |
c4917074 | 27 | #include <linux/power_supply.h> |
d7a2952f AM |
28 | #include <acpi/acpi_drivers.h> |
29 | #include <acpi/acpi_bus.h> | |
fda4b25c | 30 | #include <acpi/video.h> |
d7a2952f | 31 | |
760285e7 DH |
32 | #include <drm/drmP.h> |
33 | #include <drm/drm_crtc_helper.h> | |
d7a2952f | 34 | #include "radeon.h" |
9e05b2f4 | 35 | #include "radeon_acpi.h" |
fda4b25c | 36 | #include "atom.h" |
d7a2952f AM |
37 | |
38 | #include <linux/vga_switcheroo.h> | |
39 | ||
c4917074 AD |
40 | #define ACPI_AC_CLASS "ac_adapter" |
41 | ||
42 | extern void radeon_pm_acpi_event_handler(struct radeon_device *rdev); | |
43 | ||
fd64ca8a LT |
44 | struct atif_verify_interface { |
45 | u16 size; /* structure size in bytes (includes size field) */ | |
46 | u16 version; /* version */ | |
47 | u32 notification_mask; /* supported notifications mask */ | |
48 | u32 function_bits; /* supported functions bit vector */ | |
49 | } __packed; | |
50 | ||
ce3cf821 | 51 | struct atif_system_params { |
fda4b25c LT |
52 | u16 size; /* structure size in bytes (includes size field) */ |
53 | u32 valid_mask; /* valid flags mask */ | |
54 | u32 flags; /* flags */ | |
55 | u8 command_code; /* notify command code */ | |
56 | } __packed; | |
57 | ||
58 | struct atif_sbios_requests { | |
59 | u16 size; /* structure size in bytes (includes size field) */ | |
60 | u32 pending; /* pending sbios requests */ | |
61 | u8 panel_exp_mode; /* panel expansion mode */ | |
62 | u8 thermal_gfx; /* thermal state: target gfx controller */ | |
63 | u8 thermal_state; /* thermal state: state id (0: exit state, non-0: state) */ | |
64 | u8 forced_power_gfx; /* forced power state: target gfx controller */ | |
65 | u8 forced_power_state; /* forced power state: state id */ | |
66 | u8 system_power_src; /* system power source */ | |
67 | u8 backlight_level; /* panel backlight level (0-255) */ | |
ce3cf821 LT |
68 | } __packed; |
69 | ||
70 | #define ATIF_NOTIFY_MASK 0x3 | |
71 | #define ATIF_NOTIFY_NONE 0 | |
72 | #define ATIF_NOTIFY_81 1 | |
73 | #define ATIF_NOTIFY_N 2 | |
74 | ||
e3a15920 AD |
75 | struct atcs_verify_interface { |
76 | u16 size; /* structure size in bytes (includes size field) */ | |
77 | u16 version; /* version */ | |
78 | u32 function_bits; /* supported functions bit vector */ | |
79 | } __packed; | |
80 | ||
d7a2952f | 81 | /* Call the ATIF method |
d7a2952f | 82 | */ |
c3c65160 AD |
83 | /** |
84 | * radeon_atif_call - call an ATIF method | |
d7a2952f | 85 | * |
c3c65160 AD |
86 | * @handle: acpi handle |
87 | * @function: the ATIF function to execute | |
88 | * @params: ATIF function params | |
89 | * | |
90 | * Executes the requested ATIF function (all asics). | |
91 | * Returns a pointer to the acpi output buffer. | |
d7a2952f | 92 | */ |
86504672 LT |
93 | static union acpi_object *radeon_atif_call(acpi_handle handle, int function, |
94 | struct acpi_buffer *params) | |
d7a2952f AM |
95 | { |
96 | acpi_status status; | |
97 | union acpi_object atif_arg_elements[2]; | |
98 | struct acpi_object_list atif_arg; | |
86504672 | 99 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
d7a2952f AM |
100 | |
101 | atif_arg.count = 2; | |
102 | atif_arg.pointer = &atif_arg_elements[0]; | |
103 | ||
104 | atif_arg_elements[0].type = ACPI_TYPE_INTEGER; | |
86504672 LT |
105 | atif_arg_elements[0].integer.value = function; |
106 | ||
107 | if (params) { | |
108 | atif_arg_elements[1].type = ACPI_TYPE_BUFFER; | |
109 | atif_arg_elements[1].buffer.length = params->length; | |
110 | atif_arg_elements[1].buffer.pointer = params->pointer; | |
111 | } else { | |
112 | /* We need a second fake parameter */ | |
113 | atif_arg_elements[1].type = ACPI_TYPE_INTEGER; | |
114 | atif_arg_elements[1].integer.value = 0; | |
115 | } | |
d7a2952f AM |
116 | |
117 | status = acpi_evaluate_object(handle, "ATIF", &atif_arg, &buffer); | |
118 | ||
119 | /* Fail only if calling the method fails and ATIF is supported */ | |
120 | if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { | |
bc96f942 JD |
121 | DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n", |
122 | acpi_format_exception(status)); | |
d7a2952f | 123 | kfree(buffer.pointer); |
86504672 | 124 | return NULL; |
d7a2952f AM |
125 | } |
126 | ||
86504672 | 127 | return buffer.pointer; |
d7a2952f AM |
128 | } |
129 | ||
c3c65160 AD |
130 | /** |
131 | * radeon_atif_parse_notification - parse supported notifications | |
132 | * | |
133 | * @n: supported notifications struct | |
134 | * @mask: supported notifications mask from ATIF | |
135 | * | |
136 | * Use the supported notifications mask from ATIF function | |
137 | * ATIF_FUNCTION_VERIFY_INTERFACE to determine what notifications | |
138 | * are supported (all asics). | |
139 | */ | |
fd64ca8a LT |
140 | static void radeon_atif_parse_notification(struct radeon_atif_notifications *n, u32 mask) |
141 | { | |
142 | n->display_switch = mask & ATIF_DISPLAY_SWITCH_REQUEST_SUPPORTED; | |
143 | n->expansion_mode_change = mask & ATIF_EXPANSION_MODE_CHANGE_REQUEST_SUPPORTED; | |
144 | n->thermal_state = mask & ATIF_THERMAL_STATE_CHANGE_REQUEST_SUPPORTED; | |
145 | n->forced_power_state = mask & ATIF_FORCED_POWER_STATE_CHANGE_REQUEST_SUPPORTED; | |
146 | n->system_power_state = mask & ATIF_SYSTEM_POWER_SOURCE_CHANGE_REQUEST_SUPPORTED; | |
147 | n->display_conf_change = mask & ATIF_DISPLAY_CONF_CHANGE_REQUEST_SUPPORTED; | |
148 | n->px_gfx_switch = mask & ATIF_PX_GFX_SWITCH_REQUEST_SUPPORTED; | |
149 | n->brightness_change = mask & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST_SUPPORTED; | |
150 | n->dgpu_display_event = mask & ATIF_DGPU_DISPLAY_EVENT_SUPPORTED; | |
151 | } | |
152 | ||
c3c65160 AD |
153 | /** |
154 | * radeon_atif_parse_functions - parse supported functions | |
155 | * | |
156 | * @f: supported functions struct | |
157 | * @mask: supported functions mask from ATIF | |
158 | * | |
159 | * Use the supported functions mask from ATIF function | |
160 | * ATIF_FUNCTION_VERIFY_INTERFACE to determine what functions | |
161 | * are supported (all asics). | |
162 | */ | |
fd64ca8a LT |
163 | static void radeon_atif_parse_functions(struct radeon_atif_functions *f, u32 mask) |
164 | { | |
165 | f->system_params = mask & ATIF_GET_SYSTEM_PARAMETERS_SUPPORTED; | |
166 | f->sbios_requests = mask & ATIF_GET_SYSTEM_BIOS_REQUESTS_SUPPORTED; | |
167 | f->select_active_disp = mask & ATIF_SELECT_ACTIVE_DISPLAYS_SUPPORTED; | |
168 | f->lid_state = mask & ATIF_GET_LID_STATE_SUPPORTED; | |
169 | f->get_tv_standard = mask & ATIF_GET_TV_STANDARD_FROM_CMOS_SUPPORTED; | |
170 | f->set_tv_standard = mask & ATIF_SET_TV_STANDARD_IN_CMOS_SUPPORTED; | |
171 | f->get_panel_expansion_mode = mask & ATIF_GET_PANEL_EXPANSION_MODE_FROM_CMOS_SUPPORTED; | |
172 | f->set_panel_expansion_mode = mask & ATIF_SET_PANEL_EXPANSION_MODE_IN_CMOS_SUPPORTED; | |
173 | f->temperature_change = mask & ATIF_TEMPERATURE_CHANGE_NOTIFICATION_SUPPORTED; | |
174 | f->graphics_device_types = mask & ATIF_GET_GRAPHICS_DEVICE_TYPES_SUPPORTED; | |
175 | } | |
176 | ||
c3c65160 AD |
177 | /** |
178 | * radeon_atif_verify_interface - verify ATIF | |
179 | * | |
180 | * @handle: acpi handle | |
181 | * @atif: radeon atif struct | |
182 | * | |
183 | * Execute the ATIF_FUNCTION_VERIFY_INTERFACE ATIF function | |
184 | * to initialize ATIF and determine what features are supported | |
185 | * (all asics). | |
186 | * returns 0 on success, error on failure. | |
187 | */ | |
fd64ca8a LT |
188 | static int radeon_atif_verify_interface(acpi_handle handle, |
189 | struct radeon_atif *atif) | |
190 | { | |
191 | union acpi_object *info; | |
192 | struct atif_verify_interface output; | |
193 | size_t size; | |
194 | int err = 0; | |
195 | ||
196 | info = radeon_atif_call(handle, ATIF_FUNCTION_VERIFY_INTERFACE, NULL); | |
197 | if (!info) | |
198 | return -EIO; | |
199 | ||
200 | memset(&output, 0, sizeof(output)); | |
201 | ||
202 | size = *(u16 *) info->buffer.pointer; | |
203 | if (size < 12) { | |
a1871936 | 204 | DRM_INFO("ATIF buffer is too small: %zu\n", size); |
fd64ca8a LT |
205 | err = -EINVAL; |
206 | goto out; | |
207 | } | |
208 | size = min(sizeof(output), size); | |
209 | ||
210 | memcpy(&output, info->buffer.pointer, size); | |
211 | ||
212 | /* TODO: check version? */ | |
213 | DRM_DEBUG_DRIVER("ATIF version %u\n", output.version); | |
214 | ||
215 | radeon_atif_parse_notification(&atif->notifications, output.notification_mask); | |
216 | radeon_atif_parse_functions(&atif->functions, output.function_bits); | |
217 | ||
218 | out: | |
219 | kfree(info); | |
220 | return err; | |
221 | } | |
222 | ||
c3c65160 AD |
223 | /** |
224 | * radeon_atif_get_notification_params - determine notify configuration | |
225 | * | |
226 | * @handle: acpi handle | |
227 | * @n: atif notification configuration struct | |
228 | * | |
229 | * Execute the ATIF_FUNCTION_GET_SYSTEM_PARAMETERS ATIF function | |
230 | * to determine if a notifier is used and if so which one | |
231 | * (all asics). This is either Notify(VGA, 0x81) or Notify(VGA, n) | |
232 | * where n is specified in the result if a notifier is used. | |
233 | * Returns 0 on success, error on failure. | |
234 | */ | |
ce3cf821 LT |
235 | static int radeon_atif_get_notification_params(acpi_handle handle, |
236 | struct radeon_atif_notification_cfg *n) | |
237 | { | |
238 | union acpi_object *info; | |
239 | struct atif_system_params params; | |
240 | size_t size; | |
241 | int err = 0; | |
242 | ||
243 | info = radeon_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_PARAMETERS, NULL); | |
244 | if (!info) { | |
245 | err = -EIO; | |
246 | goto out; | |
247 | } | |
248 | ||
249 | size = *(u16 *) info->buffer.pointer; | |
250 | if (size < 10) { | |
251 | err = -EINVAL; | |
252 | goto out; | |
253 | } | |
254 | ||
255 | memset(¶ms, 0, sizeof(params)); | |
256 | size = min(sizeof(params), size); | |
257 | memcpy(¶ms, info->buffer.pointer, size); | |
258 | ||
fda4b25c LT |
259 | DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n", |
260 | params.flags, params.valid_mask); | |
ce3cf821 LT |
261 | params.flags = params.flags & params.valid_mask; |
262 | ||
263 | if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_NONE) { | |
264 | n->enabled = false; | |
265 | n->command_code = 0; | |
266 | } else if ((params.flags & ATIF_NOTIFY_MASK) == ATIF_NOTIFY_81) { | |
267 | n->enabled = true; | |
268 | n->command_code = 0x81; | |
269 | } else { | |
270 | if (size < 11) { | |
271 | err = -EINVAL; | |
272 | goto out; | |
273 | } | |
274 | n->enabled = true; | |
275 | n->command_code = params.command_code; | |
276 | } | |
277 | ||
278 | out: | |
fda4b25c LT |
279 | DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n", |
280 | (n->enabled ? "enabled" : "disabled"), | |
281 | n->command_code); | |
ce3cf821 LT |
282 | kfree(info); |
283 | return err; | |
284 | } | |
285 | ||
c3c65160 AD |
286 | /** |
287 | * radeon_atif_get_sbios_requests - get requested sbios event | |
288 | * | |
289 | * @handle: acpi handle | |
290 | * @req: atif sbios request struct | |
291 | * | |
292 | * Execute the ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS ATIF function | |
293 | * to determine what requests the sbios is making to the driver | |
294 | * (all asics). | |
295 | * Returns 0 on success, error on failure. | |
296 | */ | |
fda4b25c LT |
297 | static int radeon_atif_get_sbios_requests(acpi_handle handle, |
298 | struct atif_sbios_requests *req) | |
299 | { | |
300 | union acpi_object *info; | |
301 | size_t size; | |
302 | int count = 0; | |
303 | ||
304 | info = radeon_atif_call(handle, ATIF_FUNCTION_GET_SYSTEM_BIOS_REQUESTS, NULL); | |
305 | if (!info) | |
306 | return -EIO; | |
307 | ||
308 | size = *(u16 *)info->buffer.pointer; | |
309 | if (size < 0xd) { | |
310 | count = -EINVAL; | |
311 | goto out; | |
312 | } | |
313 | memset(req, 0, sizeof(*req)); | |
314 | ||
315 | size = min(sizeof(*req), size); | |
316 | memcpy(req, info->buffer.pointer, size); | |
317 | DRM_DEBUG_DRIVER("SBIOS pending requests: %#x\n", req->pending); | |
318 | ||
319 | count = hweight32(req->pending); | |
320 | ||
321 | out: | |
322 | kfree(info); | |
323 | return count; | |
324 | } | |
325 | ||
c3c65160 AD |
326 | /** |
327 | * radeon_atif_handler - handle ATIF notify requests | |
328 | * | |
329 | * @rdev: radeon_device pointer | |
330 | * @event: atif sbios request struct | |
331 | * | |
332 | * Checks the acpi event and if it matches an atif event, | |
333 | * handles it. | |
334 | * Returns NOTIFY code | |
335 | */ | |
fda4b25c LT |
336 | int radeon_atif_handler(struct radeon_device *rdev, |
337 | struct acpi_bus_event *event) | |
338 | { | |
339 | struct radeon_atif *atif = &rdev->atif; | |
340 | struct atif_sbios_requests req; | |
341 | acpi_handle handle; | |
342 | int count; | |
343 | ||
344 | DRM_DEBUG_DRIVER("event, device_class = %s, type = %#x\n", | |
345 | event->device_class, event->type); | |
346 | ||
347 | if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0) | |
348 | return NOTIFY_DONE; | |
349 | ||
350 | if (!atif->notification_cfg.enabled || | |
351 | event->type != atif->notification_cfg.command_code) | |
352 | /* Not our event */ | |
353 | return NOTIFY_DONE; | |
354 | ||
355 | /* Check pending SBIOS requests */ | |
356 | handle = DEVICE_ACPI_HANDLE(&rdev->pdev->dev); | |
357 | count = radeon_atif_get_sbios_requests(handle, &req); | |
358 | ||
359 | if (count <= 0) | |
360 | return NOTIFY_DONE; | |
361 | ||
362 | DRM_DEBUG_DRIVER("ATIF: %d pending SBIOS requests\n", count); | |
363 | ||
364 | if (req.pending & ATIF_PANEL_BRIGHTNESS_CHANGE_REQUEST) { | |
37e9b6a6 | 365 | struct radeon_encoder *enc = atif->encoder_for_bl; |
fda4b25c LT |
366 | |
367 | if (enc) { | |
fda4b25c LT |
368 | DRM_DEBUG_DRIVER("Changing brightness to %d\n", |
369 | req.backlight_level); | |
370 | ||
37e9b6a6 | 371 | radeon_set_backlight_level(rdev, enc, req.backlight_level); |
fda4b25c | 372 | |
cd23492a | 373 | #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE) |
37e9b6a6 AD |
374 | if (rdev->is_atom_bios) { |
375 | struct radeon_encoder_atom_dig *dig = enc->enc_priv; | |
376 | backlight_force_update(dig->bl_dev, | |
377 | BACKLIGHT_UPDATE_HOTKEY); | |
378 | } else { | |
379 | struct radeon_encoder_lvds *dig = enc->enc_priv; | |
380 | backlight_force_update(dig->bl_dev, | |
381 | BACKLIGHT_UPDATE_HOTKEY); | |
382 | } | |
cd23492a | 383 | #endif |
fda4b25c LT |
384 | } |
385 | } | |
386 | /* TODO: check other events */ | |
387 | ||
92fdf89a LT |
388 | /* We've handled the event, stop the notifier chain. The ACPI interface |
389 | * overloads ACPI_VIDEO_NOTIFY_PROBE, we don't want to send that to | |
390 | * userspace if the event was generated only to signal a SBIOS | |
391 | * request. | |
392 | */ | |
393 | return NOTIFY_BAD; | |
fda4b25c LT |
394 | } |
395 | ||
e3a15920 AD |
396 | /* Call the ATCS method |
397 | */ | |
398 | /** | |
399 | * radeon_atcs_call - call an ATCS method | |
400 | * | |
401 | * @handle: acpi handle | |
402 | * @function: the ATCS function to execute | |
403 | * @params: ATCS function params | |
404 | * | |
405 | * Executes the requested ATCS function (all asics). | |
406 | * Returns a pointer to the acpi output buffer. | |
407 | */ | |
408 | static union acpi_object *radeon_atcs_call(acpi_handle handle, int function, | |
409 | struct acpi_buffer *params) | |
410 | { | |
411 | acpi_status status; | |
412 | union acpi_object atcs_arg_elements[2]; | |
413 | struct acpi_object_list atcs_arg; | |
414 | struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; | |
415 | ||
416 | atcs_arg.count = 2; | |
417 | atcs_arg.pointer = &atcs_arg_elements[0]; | |
418 | ||
419 | atcs_arg_elements[0].type = ACPI_TYPE_INTEGER; | |
420 | atcs_arg_elements[0].integer.value = function; | |
421 | ||
422 | if (params) { | |
423 | atcs_arg_elements[1].type = ACPI_TYPE_BUFFER; | |
424 | atcs_arg_elements[1].buffer.length = params->length; | |
425 | atcs_arg_elements[1].buffer.pointer = params->pointer; | |
426 | } else { | |
427 | /* We need a second fake parameter */ | |
428 | atcs_arg_elements[1].type = ACPI_TYPE_INTEGER; | |
429 | atcs_arg_elements[1].integer.value = 0; | |
430 | } | |
431 | ||
432 | status = acpi_evaluate_object(handle, "ATCS", &atcs_arg, &buffer); | |
433 | ||
434 | /* Fail only if calling the method fails and ATIF is supported */ | |
435 | if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { | |
436 | DRM_DEBUG_DRIVER("failed to evaluate ATCS got %s\n", | |
437 | acpi_format_exception(status)); | |
438 | kfree(buffer.pointer); | |
439 | return NULL; | |
440 | } | |
441 | ||
442 | return buffer.pointer; | |
443 | } | |
444 | ||
445 | /** | |
446 | * radeon_atcs_parse_functions - parse supported functions | |
447 | * | |
448 | * @f: supported functions struct | |
449 | * @mask: supported functions mask from ATCS | |
450 | * | |
451 | * Use the supported functions mask from ATCS function | |
452 | * ATCS_FUNCTION_VERIFY_INTERFACE to determine what functions | |
453 | * are supported (all asics). | |
454 | */ | |
455 | static void radeon_atcs_parse_functions(struct radeon_atcs_functions *f, u32 mask) | |
456 | { | |
457 | f->get_ext_state = mask & ATCS_GET_EXTERNAL_STATE_SUPPORTED; | |
458 | f->pcie_perf_req = mask & ATCS_PCIE_PERFORMANCE_REQUEST_SUPPORTED; | |
459 | f->pcie_dev_rdy = mask & ATCS_PCIE_DEVICE_READY_NOTIFICATION_SUPPORTED; | |
460 | f->pcie_bus_width = mask & ATCS_SET_PCIE_BUS_WIDTH_SUPPORTED; | |
461 | } | |
462 | ||
463 | /** | |
464 | * radeon_atcs_verify_interface - verify ATCS | |
465 | * | |
466 | * @handle: acpi handle | |
467 | * @atcs: radeon atcs struct | |
468 | * | |
469 | * Execute the ATCS_FUNCTION_VERIFY_INTERFACE ATCS function | |
470 | * to initialize ATCS and determine what features are supported | |
471 | * (all asics). | |
472 | * returns 0 on success, error on failure. | |
473 | */ | |
474 | static int radeon_atcs_verify_interface(acpi_handle handle, | |
475 | struct radeon_atcs *atcs) | |
476 | { | |
477 | union acpi_object *info; | |
478 | struct atcs_verify_interface output; | |
479 | size_t size; | |
480 | int err = 0; | |
481 | ||
482 | info = radeon_atcs_call(handle, ATCS_FUNCTION_VERIFY_INTERFACE, NULL); | |
483 | if (!info) | |
484 | return -EIO; | |
485 | ||
486 | memset(&output, 0, sizeof(output)); | |
487 | ||
488 | size = *(u16 *) info->buffer.pointer; | |
489 | if (size < 8) { | |
a1871936 | 490 | DRM_INFO("ATCS buffer is too small: %zu\n", size); |
e3a15920 AD |
491 | err = -EINVAL; |
492 | goto out; | |
493 | } | |
494 | size = min(sizeof(output), size); | |
495 | ||
496 | memcpy(&output, info->buffer.pointer, size); | |
497 | ||
498 | /* TODO: check version? */ | |
499 | DRM_DEBUG_DRIVER("ATCS version %u\n", output.version); | |
500 | ||
501 | radeon_atcs_parse_functions(&atcs->functions, output.function_bits); | |
502 | ||
503 | out: | |
504 | kfree(info); | |
505 | return err; | |
506 | } | |
507 | ||
c3c65160 AD |
508 | /** |
509 | * radeon_acpi_event - handle notify events | |
510 | * | |
511 | * @nb: notifier block | |
512 | * @val: val | |
513 | * @data: acpi event | |
514 | * | |
515 | * Calls relevant radeon functions in response to various | |
516 | * acpi events. | |
517 | * Returns NOTIFY code | |
518 | */ | |
c4917074 AD |
519 | static int radeon_acpi_event(struct notifier_block *nb, |
520 | unsigned long val, | |
521 | void *data) | |
522 | { | |
523 | struct radeon_device *rdev = container_of(nb, struct radeon_device, acpi_nb); | |
524 | struct acpi_bus_event *entry = (struct acpi_bus_event *)data; | |
525 | ||
526 | if (strcmp(entry->device_class, ACPI_AC_CLASS) == 0) { | |
527 | if (power_supply_is_system_supplied() > 0) | |
528 | DRM_DEBUG_DRIVER("pm: AC\n"); | |
529 | else | |
530 | DRM_DEBUG_DRIVER("pm: DC\n"); | |
531 | ||
532 | radeon_pm_acpi_event_handler(rdev); | |
533 | } | |
534 | ||
535 | /* Check for pending SBIOS requests */ | |
536 | return radeon_atif_handler(rdev, entry); | |
d7a2952f AM |
537 | } |
538 | ||
539 | /* Call all ACPI methods here */ | |
c3c65160 AD |
540 | /** |
541 | * radeon_acpi_init - init driver acpi support | |
542 | * | |
543 | * @rdev: radeon_device pointer | |
544 | * | |
545 | * Verifies the AMD ACPI interfaces and registers with the acpi | |
546 | * notifier chain (all asics). | |
547 | * Returns 0 on success, error on failure. | |
548 | */ | |
d7a2952f AM |
549 | int radeon_acpi_init(struct radeon_device *rdev) |
550 | { | |
551 | acpi_handle handle; | |
ce3cf821 | 552 | struct radeon_atif *atif = &rdev->atif; |
e3a15920 | 553 | struct radeon_atcs *atcs = &rdev->atcs; |
d7a2952f AM |
554 | int ret; |
555 | ||
d7a2952f AM |
556 | /* Get the device handle */ |
557 | handle = DEVICE_ACPI_HANDLE(&rdev->pdev->dev); | |
558 | ||
48cc9b2c JD |
559 | /* No need to proceed if we're sure that ATIF is not supported */ |
560 | if (!ASIC_IS_AVIVO(rdev) || !rdev->bios || !handle) | |
561 | return 0; | |
562 | ||
e3a15920 AD |
563 | /* Call the ATCS method */ |
564 | ret = radeon_atcs_verify_interface(handle, atcs); | |
565 | if (ret) { | |
566 | DRM_DEBUG_DRIVER("Call to ATCS verify_interface failed: %d\n", ret); | |
567 | } | |
568 | ||
d7a2952f | 569 | /* Call the ATIF method */ |
ce3cf821 LT |
570 | ret = radeon_atif_verify_interface(handle, atif); |
571 | if (ret) { | |
e3a15920 | 572 | DRM_DEBUG_DRIVER("Call to ATIF verify_interface failed: %d\n", ret); |
ce3cf821 LT |
573 | goto out; |
574 | } | |
575 | ||
fda4b25c LT |
576 | if (atif->notifications.brightness_change) { |
577 | struct drm_encoder *tmp; | |
578 | struct radeon_encoder *target = NULL; | |
579 | ||
580 | /* Find the encoder controlling the brightness */ | |
581 | list_for_each_entry(tmp, &rdev->ddev->mode_config.encoder_list, | |
582 | head) { | |
583 | struct radeon_encoder *enc = to_radeon_encoder(tmp); | |
fda4b25c LT |
584 | |
585 | if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) && | |
37e9b6a6 AD |
586 | enc->enc_priv) { |
587 | if (rdev->is_atom_bios) { | |
588 | struct radeon_encoder_atom_dig *dig = enc->enc_priv; | |
589 | if (dig->bl_dev) { | |
590 | target = enc; | |
591 | break; | |
592 | } | |
593 | } else { | |
594 | struct radeon_encoder_lvds *dig = enc->enc_priv; | |
595 | if (dig->bl_dev) { | |
596 | target = enc; | |
597 | break; | |
598 | } | |
599 | } | |
fda4b25c LT |
600 | } |
601 | } | |
602 | ||
37e9b6a6 | 603 | atif->encoder_for_bl = target; |
fda4b25c LT |
604 | if (!target) { |
605 | /* Brightness change notification is enabled, but we | |
606 | * didn't find a backlight controller, this should | |
607 | * never happen. | |
608 | */ | |
609 | DRM_ERROR("Cannot find a backlight controller\n"); | |
610 | } | |
611 | } | |
d7a2952f | 612 | |
ce3cf821 LT |
613 | if (atif->functions.sbios_requests && !atif->functions.system_params) { |
614 | /* XXX check this workraround, if sbios request function is | |
615 | * present we have to see how it's configured in the system | |
616 | * params | |
617 | */ | |
618 | atif->functions.system_params = true; | |
619 | } | |
620 | ||
621 | if (atif->functions.system_params) { | |
622 | ret = radeon_atif_get_notification_params(handle, | |
623 | &atif->notification_cfg); | |
624 | if (ret) { | |
625 | DRM_DEBUG_DRIVER("Call to GET_SYSTEM_PARAMS failed: %d\n", | |
626 | ret); | |
627 | /* Disable notification */ | |
628 | atif->notification_cfg.enabled = false; | |
629 | } | |
630 | } | |
d7a2952f | 631 | |
ce3cf821 | 632 | out: |
c4917074 AD |
633 | rdev->acpi_nb.notifier_call = radeon_acpi_event; |
634 | register_acpi_notifier(&rdev->acpi_nb); | |
635 | ||
86504672 | 636 | return ret; |
d7a2952f AM |
637 | } |
638 | ||
c3c65160 AD |
639 | /** |
640 | * radeon_acpi_fini - tear down driver acpi support | |
641 | * | |
642 | * @rdev: radeon_device pointer | |
643 | * | |
644 | * Unregisters with the acpi notifier chain (all asics). | |
645 | */ | |
c4917074 AD |
646 | void radeon_acpi_fini(struct radeon_device *rdev) |
647 | { | |
648 | unregister_acpi_notifier(&rdev->acpi_nb); | |
649 | } |