drm/i915: Sync i915_gem_pwrite_ioctl() with Linux 3.11
[dragonfly.git] / sys / dev / drm / radeon / radeon_atpx_handler.c
CommitLineData
926deccb
FT
1/*
2 * Copyright (c) 2010 Red Hat Inc.
3 * Author : Dave Airlie <airlied@redhat.com>
4 *
5 * Licensed under GPLv2
6 *
7 * ATPX support for both Intel/ATI
8 *
9 * $FreeBSD: head/sys/dev/drm2/radeon/radeon_atpx_handler.c 254885 2013-08-25 19:37:15Z dumbbell $
10 */
11
12#include <sys/param.h>
13#include <sys/systm.h>
14#include <sys/bus.h>
15#include <sys/linker.h>
16
17#include <drm/drmP.h>
18#include <uapi_drm/radeon_drm.h>
19#include "radeon_acpi.h"
20#include "radeon_drv.h"
21
b403bed8
MN
22void radeon_register_atpx_handler(void);
23void radeon_unregister_atpx_handler(void);
24
926deccb
FT
25#ifdef DUMBBELL_WIP
26struct radeon_atpx_functions {
27 bool px_params;
28 bool power_cntl;
29 bool disp_mux_cntl;
30 bool i2c_mux_cntl;
31 bool switch_start;
32 bool switch_end;
33 bool disp_connectors_mapping;
34 bool disp_detetion_ports;
35};
36
37struct radeon_atpx {
38 ACPI_HANDLE handle;
39 struct radeon_atpx_functions functions;
40};
41
42static struct radeon_atpx_priv {
43 bool atpx_detected;
44 /* handle for device - and atpx */
45 ACPI_HANDLE dhandle;
46 struct radeon_atpx atpx;
47} radeon_atpx_priv;
48
49struct atpx_verify_interface {
50 u16 size; /* structure size in bytes (includes size field) */
51 u16 version; /* version */
52 u32 function_bits; /* supported functions bit vector */
53} __packed;
54
b403bed8
MN
55struct atpx_px_params {
56 u16 size; /* structure size in bytes (includes size field) */
57 u32 valid_flags; /* which flags are valid */
58 u32 flags; /* flags */
59} __packed;
60
926deccb
FT
61struct atpx_power_control {
62 u16 size;
63 u8 dgpu_state;
64} __packed;
65
66struct atpx_mux {
67 u16 size;
68 u16 mux;
69} __packed;
70
71/**
72 * radeon_atpx_call - call an ATPX method
73 *
74 * @handle: acpi handle
75 * @function: the ATPX function to execute
76 * @params: ATPX function params
77 *
78 * Executes the requested ATPX function (all asics).
79 * Returns a pointer to the acpi output buffer.
80 */
81static ACPI_OBJECT *radeon_atpx_call(ACPI_HANDLE handle, int function,
82 ACPI_BUFFER *params)
83{
84 ACPI_STATUS status;
85 ACPI_OBJECT atpx_arg_elements[2];
86 ACPI_OBJECT_LIST atpx_arg;
87 ACPI_BUFFER buffer = { ACPI_ALLOCATE_BUFFER, NULL };
88
89 atpx_arg.Count = 2;
90 atpx_arg.Pointer = &atpx_arg_elements[0];
91
92 atpx_arg_elements[0].Type = ACPI_TYPE_INTEGER;
93 atpx_arg_elements[0].Integer.Value = function;
94
95 if (params) {
96 atpx_arg_elements[1].Type = ACPI_TYPE_BUFFER;
97 atpx_arg_elements[1].Buffer.Length = params->Length;
98 atpx_arg_elements[1].Buffer.Pointer = params->Pointer;
99 } else {
100 /* We need a second fake parameter */
101 atpx_arg_elements[1].Type = ACPI_TYPE_INTEGER;
102 atpx_arg_elements[1].Integer.Value = 0;
103 }
104
105 status = AcpiEvaluateObject(handle, NULL, &atpx_arg, &buffer);
106
107 /* Fail only if calling the method fails and ATPX is supported */
108 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
109 DRM_ERROR("failed to evaluate ATPX got %s\n",
110 AcpiFormatException(status));
111 AcpiOsFree(buffer.Pointer);
112 return NULL;
113 }
114
115 return buffer.Pointer;
116}
117
118/**
119 * radeon_atpx_parse_functions - parse supported functions
120 *
121 * @f: supported functions struct
122 * @mask: supported functions mask from ATPX
123 *
124 * Use the supported functions mask from ATPX function
125 * ATPX_FUNCTION_VERIFY_INTERFACE to determine what functions
126 * are supported (all asics).
127 */
128static void radeon_atpx_parse_functions(struct radeon_atpx_functions *f, u32 mask)
129{
130 f->px_params = mask & ATPX_GET_PX_PARAMETERS_SUPPORTED;
131 f->power_cntl = mask & ATPX_POWER_CONTROL_SUPPORTED;
132 f->disp_mux_cntl = mask & ATPX_DISPLAY_MUX_CONTROL_SUPPORTED;
133 f->i2c_mux_cntl = mask & ATPX_I2C_MUX_CONTROL_SUPPORTED;
134 f->switch_start = mask & ATPX_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION_SUPPORTED;
135 f->switch_end = mask & ATPX_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION_SUPPORTED;
136 f->disp_connectors_mapping = mask & ATPX_GET_DISPLAY_CONNECTORS_MAPPING_SUPPORTED;
137 f->disp_detetion_ports = mask & ATPX_GET_DISPLAY_DETECTION_PORTS_SUPPORTED;
138}
139
b403bed8
MN
140/**
141 * radeon_atpx_validate_functions - validate ATPX functions
142 *
143 * @atpx: radeon atpx struct
144 *
145 * Validate that required functions are enabled (all asics).
146 * returns 0 on success, error on failure.
147 */
148static int radeon_atpx_validate(struct radeon_atpx *atpx)
149{
150 /* make sure required functions are enabled */
151 /* dGPU power control is required */
152 atpx->functions.power_cntl = true;
153
154 if (atpx->functions.px_params) {
155 union acpi_object *info;
156 struct atpx_px_params output;
157 size_t size;
158 u32 valid_bits;
159
160 info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_GET_PX_PARAMETERS, NULL);
161 if (!info)
162 return -EIO;
163
164 memset(&output, 0, sizeof(output));
165
166 size = *(u16 *) info->buffer.pointer;
167 if (size < 10) {
168 kprintf("ATPX buffer is too small: %zu\n", size);
169 kfree(info);
170 return -EINVAL;
171 }
172 size = min(sizeof(output), size);
173
174 memcpy(&output, info->buffer.pointer, size);
175
176 valid_bits = output.flags & output.valid_flags;
177 /* if separate mux flag is set, mux controls are required */
178 if (valid_bits & ATPX_SEPARATE_MUX_FOR_I2C) {
179 atpx->functions.i2c_mux_cntl = true;
180 atpx->functions.disp_mux_cntl = true;
181 }
182 /* if any outputs are muxed, mux controls are required */
183 if (valid_bits & (ATPX_CRT1_RGB_SIGNAL_MUXED |
184 ATPX_TV_SIGNAL_MUXED |
185 ATPX_DFP_SIGNAL_MUXED))
186 atpx->functions.disp_mux_cntl = true;
187
188 kfree(info);
189 }
190 return 0;
191}
192
926deccb
FT
193/**
194 * radeon_atpx_verify_interface - verify ATPX
195 *
926deccb
FT
196 * @atpx: radeon atpx struct
197 *
198 * Execute the ATPX_FUNCTION_VERIFY_INTERFACE ATPX function
199 * to initialize ATPX and determine what features are supported
200 * (all asics).
201 * returns 0 on success, error on failure.
202 */
203static int radeon_atpx_verify_interface(struct radeon_atpx *atpx)
204{
205 ACPI_OBJECT *info;
206 struct atpx_verify_interface output;
207 size_t size;
208 int err = 0;
209
210 info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_VERIFY_INTERFACE, NULL);
211 if (!info)
212 return -EIO;
213
214 memset(&output, 0, sizeof(output));
215
216 size = *(u16 *) info->Buffer.Pointer;
217 if (size < 8) {
218 DRM_ERROR("ATPX buffer is too small: %zu\n", size);
219 err = -EINVAL;
220 goto out;
221 }
222 size = min(sizeof(output), size);
223
224 memcpy(&output, info->Buffer.Pointer, size);
225
226 /* TODO: check version? */
227 DRM_INFO("ATPX version %u\n", output.version);
228
229 radeon_atpx_parse_functions(&atpx->functions, output.function_bits);
230
231out:
232 AcpiOsFree(info);
233 return err;
234}
235
236/**
237 * radeon_atpx_set_discrete_state - power up/down discrete GPU
238 *
239 * @atpx: atpx info struct
240 * @state: discrete GPU state (0 = power down, 1 = power up)
241 *
242 * Execute the ATPX_FUNCTION_POWER_CONTROL ATPX function to
243 * power down/up the discrete GPU (all asics).
244 * Returns 0 on success, error on failure.
245 */
246static int radeon_atpx_set_discrete_state(struct radeon_atpx *atpx, u8 state)
247{
248 ACPI_BUFFER params;
249 ACPI_OBJECT *info;
250 struct atpx_power_control input;
251
252 if (atpx->functions.power_cntl) {
253 input.size = 3;
254 input.dgpu_state = state;
255 params.Length = input.size;
256 params.Pointer = &input;
257 info = radeon_atpx_call(atpx->handle,
258 ATPX_FUNCTION_POWER_CONTROL,
259 &params);
260 if (!info)
261 return -EIO;
262 AcpiOsFree(info);
263 }
264 return 0;
265}
266
267/**
268 * radeon_atpx_switch_disp_mux - switch display mux
269 *
270 * @atpx: atpx info struct
271 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
272 *
273 * Execute the ATPX_FUNCTION_DISPLAY_MUX_CONTROL ATPX function to
274 * switch the display mux between the discrete GPU and integrated GPU
275 * (all asics).
276 * Returns 0 on success, error on failure.
277 */
278static int radeon_atpx_switch_disp_mux(struct radeon_atpx *atpx, u16 mux_id)
279{
280 ACPI_BUFFER params;
281 ACPI_OBJECT *info;
282 struct atpx_mux input;
283
284 if (atpx->functions.disp_mux_cntl) {
285 input.size = 4;
286 input.mux = mux_id;
287 params.Length = input.size;
288 params.Pointer = &input;
289 info = radeon_atpx_call(atpx->handle,
290 ATPX_FUNCTION_DISPLAY_MUX_CONTROL,
291 &params);
292 if (!info)
293 return -EIO;
294 AcpiOsFree(info);
295 }
296 return 0;
297}
298
299/**
300 * radeon_atpx_switch_i2c_mux - switch i2c/hpd mux
301 *
302 * @atpx: atpx info struct
303 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
304 *
305 * Execute the ATPX_FUNCTION_I2C_MUX_CONTROL ATPX function to
306 * switch the i2c/hpd mux between the discrete GPU and integrated GPU
307 * (all asics).
308 * Returns 0 on success, error on failure.
309 */
310static int radeon_atpx_switch_i2c_mux(struct radeon_atpx *atpx, u16 mux_id)
311{
312 ACPI_BUFFER params;
313 ACPI_OBJECT *info;
314 struct atpx_mux input;
315
316 if (atpx->functions.i2c_mux_cntl) {
317 input.size = 4;
318 input.mux = mux_id;
319 params.Length = input.size;
320 params.Pointer = &input;
321 info = radeon_atpx_call(atpx->handle,
322 ATPX_FUNCTION_I2C_MUX_CONTROL,
323 &params);
324 if (!info)
325 return -EIO;
326 AcpiOsFree(info);
327 }
328 return 0;
329}
330
331/**
332 * radeon_atpx_switch_start - notify the sbios of a GPU switch
333 *
334 * @atpx: atpx info struct
335 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
336 *
337 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION ATPX
338 * function to notify the sbios that a switch between the discrete GPU and
339 * integrated GPU has begun (all asics).
340 * Returns 0 on success, error on failure.
341 */
342static int radeon_atpx_switch_start(struct radeon_atpx *atpx, u16 mux_id)
343{
344 ACPI_BUFFER params;
345 ACPI_OBJECT *info;
346 struct atpx_mux input;
347
348 if (atpx->functions.switch_start) {
349 input.size = 4;
350 input.mux = mux_id;
351 params.Length = input.size;
352 params.Pointer = &input;
353 info = radeon_atpx_call(atpx->handle,
354 ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION,
355 &params);
356 if (!info)
357 return -EIO;
358 AcpiOsFree(info);
359 }
360 return 0;
361}
362
363/**
364 * radeon_atpx_switch_end - notify the sbios of a GPU switch
365 *
366 * @atpx: atpx info struct
367 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
368 *
369 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION ATPX
370 * function to notify the sbios that a switch between the discrete GPU and
371 * integrated GPU has ended (all asics).
372 * Returns 0 on success, error on failure.
373 */
374static int radeon_atpx_switch_end(struct radeon_atpx *atpx, u16 mux_id)
375{
376 ACPI_BUFFER params;
377 ACPI_OBJECT *info;
378 struct atpx_mux input;
379
380 if (atpx->functions.switch_end) {
381 input.size = 4;
382 input.mux = mux_id;
383 params.Length = input.size;
384 params.Pointer = &input;
385 info = radeon_atpx_call(atpx->handle,
386 ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION,
387 &params);
388 if (!info)
389 return -EIO;
390 AcpiOsFree(info);
391 }
392 return 0;
393}
394
395/**
396 * radeon_atpx_switchto - switch to the requested GPU
397 *
398 * @id: GPU to switch to
399 *
400 * Execute the necessary ATPX functions to switch between the discrete GPU and
401 * integrated GPU (all asics).
402 * Returns 0 on success, error on failure.
403 */
404static int radeon_atpx_switchto(enum vga_switcheroo_client_id id)
405{
406 u16 gpu_id;
407
408 if (id == VGA_SWITCHEROO_IGD)
409 gpu_id = ATPX_INTEGRATED_GPU;
410 else
411 gpu_id = ATPX_DISCRETE_GPU;
412
413 radeon_atpx_switch_start(&radeon_atpx_priv.atpx, gpu_id);
414 radeon_atpx_switch_disp_mux(&radeon_atpx_priv.atpx, gpu_id);
415 radeon_atpx_switch_i2c_mux(&radeon_atpx_priv.atpx, gpu_id);
416 radeon_atpx_switch_end(&radeon_atpx_priv.atpx, gpu_id);
417
418 return 0;
419}
420
421/**
422 * radeon_atpx_power_state - power down/up the requested GPU
423 *
424 * @id: GPU to power down/up
425 * @state: requested power state (0 = off, 1 = on)
426 *
427 * Execute the necessary ATPX function to power down/up the discrete GPU
428 * (all asics).
429 * Returns 0 on success, error on failure.
430 */
431static int radeon_atpx_power_state(enum vga_switcheroo_client_id id,
432 enum vga_switcheroo_state state)
433{
434 /* on w500 ACPI can't change intel gpu state */
435 if (id == VGA_SWITCHEROO_IGD)
436 return 0;
437
438 radeon_atpx_set_discrete_state(&radeon_atpx_priv.atpx, state);
439 return 0;
440}
441
442/**
443 * radeon_atpx_pci_probe_handle - look up the ATPX handle
444 *
445 * @pdev: pci device
446 *
447 * Look up the ATPX handles (all asics).
448 * Returns true if the handles are found, false if not.
449 */
450static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
451{
452 ACPI_HANDLE dhandle, atpx_handle;
453 ACPI_STATUS status;
454
455 dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
456 if (!dhandle)
457 return false;
458
459 status = AcpiGetHandle(dhandle, "ATPX", &atpx_handle);
460 if (ACPI_FAILURE(status))
461 return false;
462
463 radeon_atpx_priv.dhandle = dhandle;
464 radeon_atpx_priv.atpx.handle = atpx_handle;
465 return true;
466}
467
468/**
469 * radeon_atpx_init - verify the ATPX interface
470 *
471 * Verify the ATPX interface (all asics).
472 * Returns 0 on success, error on failure.
473 */
474static int radeon_atpx_init(void)
475{
b403bed8
MN
476 int r;
477
926deccb 478 /* set up the ATPX handle */
b403bed8
MN
479 r = radeon_atpx_verify_interface(&radeon_atpx_priv.atpx);
480 if (r)
481 return r;
482
483 /* validate the atpx setup */
484 r = radeon_atpx_validate(&radeon_atpx_priv.atpx);
485 if (r)
486 return r;
487
488 return 0;
926deccb
FT
489}
490
491/**
492 * radeon_atpx_get_client_id - get the client id
493 *
494 * @pdev: pci device
495 *
496 * look up whether we are the integrated or discrete GPU (all asics).
497 * Returns the client id.
498 */
499static int radeon_atpx_get_client_id(struct pci_dev *pdev)
500{
501 if (radeon_atpx_priv.dhandle == DEVICE_ACPI_HANDLE(&pdev->dev))
502 return VGA_SWITCHEROO_IGD;
503 else
504 return VGA_SWITCHEROO_DIS;
505}
506
507static struct vga_switcheroo_handler radeon_atpx_handler = {
508 .switchto = radeon_atpx_switchto,
509 .power_state = radeon_atpx_power_state,
510 .init = radeon_atpx_init,
511 .get_client_id = radeon_atpx_get_client_id,
512};
513
514/**
515 * radeon_atpx_detect - detect whether we have PX
516 *
517 * Check if we have a PX system (all asics).
518 * Returns true if we have a PX system, false if not.
519 */
520static bool radeon_atpx_detect(void)
521{
522 char acpi_method_name[255] = { 0 };
523 ACPI_BUFFER buffer = {sizeof(acpi_method_name), acpi_method_name};
524 struct pci_dev *pdev = NULL;
525 bool has_atpx = false;
526 int vga_count = 0;
527
528 while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
529 vga_count++;
530
531 has_atpx |= (radeon_atpx_pci_probe_handle(pdev) == true);
532 }
533
534 if (has_atpx && vga_count == 2) {
535 AcpiGetName(radeon_atpx_priv.atpx.handle, ACPI_FULL_PATHNAME, &buffer);
536 DRM_INFO("VGA switcheroo: detected switching method %s handle\n",
537 acpi_method_name);
538 radeon_atpx_priv.atpx_detected = true;
539 return true;
540 }
541 return false;
542}
543#endif /* DUMBBELL_WIP */
544
545/**
546 * radeon_register_atpx_handler - register with vga_switcheroo
547 *
548 * Register the PX callbacks with vga_switcheroo (all asics).
549 */
550void radeon_register_atpx_handler(void)
551{
552#ifdef DUMBBELL_WIP
553 bool r;
554
555 /* detect if we have any ATPX + 2 VGA in the system */
556 r = radeon_atpx_detect();
557 if (!r)
558 return;
559
560 vga_switcheroo_register_handler(&radeon_atpx_handler);
561#endif /* DUMBBELL_WIP */
562}
563
564/**
565 * radeon_unregister_atpx_handler - unregister with vga_switcheroo
566 *
567 * Unregister the PX callbacks with vga_switcheroo (all asics).
568 */
569void radeon_unregister_atpx_handler(void)
570{
571#ifdef DUMBBELL_WIP
572 vga_switcheroo_unregister_handler();
573#endif /* DUMBBELL_WIP */
574}