1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/pci.h>
25#include <linux/acpi.h>
26#include <linux/slab.h>
27#include <linux/power_supply.h>
28#include <acpi/acpi_drivers.h>
29#include <acpi/acpi_bus.h>
30#include <acpi/video.h>
31
32#include <drm/drmP.h>
33#include <drm/drm_crtc_helper.h>
34#include "radeon.h"
35#include "radeon_acpi.h"
36#include "atom.h"
37
38#include <linux/vga_switcheroo.h>
39
40#define ACPI_AC_CLASS "ac_adapter"
41
42extern void radeon_pm_acpi_event_handler(struct radeon_device *rdev);
43
44struct atif_verify_interface {
45 u16 size;
46 u16 version;
47 u32 notification_mask;
48 u32 function_bits;
49} __packed;
50
51struct atif_system_params {
52 u16 size;
53 u32 valid_mask;
54 u32 flags;
55 u8 command_code;
56} __packed;
57
58struct atif_sbios_requests {
59 u16 size;
60 u32 pending;
61 u8 panel_exp_mode;
62 u8 thermal_gfx;
63 u8 thermal_state;
64 u8 forced_power_gfx;
65 u8 forced_power_state;
66 u8 system_power_src;
67 u8 backlight_level;
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
75struct atcs_verify_interface {
76 u16 size;
77 u16 version;
78 u32 function_bits;
79} __packed;
80
81
82
83
84
85
86
87
88
89
90
91
92
93static union acpi_object *radeon_atif_call(acpi_handle handle, int function,
94 struct acpi_buffer *params)
95{
96 acpi_status status;
97 union acpi_object atif_arg_elements[2];
98 struct acpi_object_list atif_arg;
99 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
100
101 atif_arg.count = 2;
102 atif_arg.pointer = &atif_arg_elements[0];
103
104 atif_arg_elements[0].type = ACPI_TYPE_INTEGER;
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
113 atif_arg_elements[1].type = ACPI_TYPE_INTEGER;
114 atif_arg_elements[1].integer.value = 0;
115 }
116
117 status = acpi_evaluate_object(handle, "ATIF", &atif_arg, &buffer);
118
119
120 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
121 DRM_DEBUG_DRIVER("failed to evaluate ATIF got %s\n",
122 acpi_format_exception(status));
123 kfree(buffer.pointer);
124 return NULL;
125 }
126
127 return buffer.pointer;
128}
129
130
131
132
133
134
135
136
137
138
139
140static 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
153
154
155
156
157
158
159
160
161
162
163static 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
177
178
179
180
181
182
183
184
185
186
187
188static 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) {
204 DRM_INFO("ATIF buffer is too small: %zu\n", size);
205 err = -EINVAL;
206 goto out;
207 }
208 size = min(sizeof(output), size);
209
210 memcpy(&output, info->buffer.pointer, size);
211
212
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
218out:
219 kfree(info);
220 return err;
221}
222
223
224
225
226
227
228
229
230
231
232
233
234
235static 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
259 DRM_DEBUG_DRIVER("SYSTEM_PARAMS: mask = %#x, flags = %#x\n",
260 params.flags, params.valid_mask);
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
278out:
279 DRM_DEBUG_DRIVER("Notification %s, command code = %#x\n",
280 (n->enabled ? "enabled" : "disabled"),
281 n->command_code);
282 kfree(info);
283 return err;
284}
285
286
287
288
289
290
291
292
293
294
295
296
297static 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
321out:
322 kfree(info);
323 return count;
324}
325
326
327
328
329
330
331
332
333
334
335
336int 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
353 return NOTIFY_DONE;
354
355
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) {
365 struct radeon_encoder *enc = atif->encoder_for_bl;
366
367 if (enc) {
368 DRM_DEBUG_DRIVER("Changing brightness to %d\n",
369 req.backlight_level);
370
371 radeon_set_backlight_level(rdev, enc, req.backlight_level);
372
373#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) || defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE)
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 }
383#endif
384 }
385 }
386
387
388
389
390
391
392
393 return NOTIFY_BAD;
394}
395
396
397
398
399
400
401
402
403
404
405
406
407
408static 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
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
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
447
448
449
450
451
452
453
454
455static 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
465
466
467
468
469
470
471
472
473
474static 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) {
490 DRM_INFO("ATCS buffer is too small: %zu\n", size);
491 err = -EINVAL;
492 goto out;
493 }
494 size = min(sizeof(output), size);
495
496 memcpy(&output, info->buffer.pointer, size);
497
498
499 DRM_DEBUG_DRIVER("ATCS version %u\n", output.version);
500
501 radeon_atcs_parse_functions(&atcs->functions, output.function_bits);
502
503out:
504 kfree(info);
505 return err;
506}
507
508
509
510
511
512
513
514
515
516
517
518
519static 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
536 return radeon_atif_handler(rdev, entry);
537}
538
539
540
541
542
543
544
545
546
547
548
549int radeon_acpi_init(struct radeon_device *rdev)
550{
551 acpi_handle handle;
552 struct radeon_atif *atif = &rdev->atif;
553 struct radeon_atcs *atcs = &rdev->atcs;
554 int ret;
555
556
557 handle = DEVICE_ACPI_HANDLE(&rdev->pdev->dev);
558
559
560 if (!ASIC_IS_AVIVO(rdev) || !rdev->bios || !handle)
561 return 0;
562
563
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
569
570 ret = radeon_atif_verify_interface(handle, atif);
571 if (ret) {
572 DRM_DEBUG_DRIVER("Call to ATIF verify_interface failed: %d\n", ret);
573 goto out;
574 }
575
576 if (atif->notifications.brightness_change) {
577 struct drm_encoder *tmp;
578 struct radeon_encoder *target = NULL;
579
580
581 list_for_each_entry(tmp, &rdev->ddev->mode_config.encoder_list,
582 head) {
583 struct radeon_encoder *enc = to_radeon_encoder(tmp);
584
585 if ((enc->devices & (ATOM_DEVICE_LCD_SUPPORT)) &&
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 }
600 }
601 }
602
603 atif->encoder_for_bl = target;
604 if (!target) {
605
606
607
608
609 DRM_ERROR("Cannot find a backlight controller\n");
610 }
611 }
612
613 if (atif->functions.sbios_requests && !atif->functions.system_params) {
614
615
616
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
628 atif->notification_cfg.enabled = false;
629 }
630 }
631
632out:
633 rdev->acpi_nb.notifier_call = radeon_acpi_event;
634 register_acpi_notifier(&rdev->acpi_nb);
635
636 return ret;
637}
638
639
640
641
642
643
644
645
646void radeon_acpi_fini(struct radeon_device *rdev)
647{
648 unregister_acpi_notifier(&rdev->acpi_nb);
649}
650