2 * Copyright (c) 2010 Red Hat Inc.
3 * Author : Dave Airlie <airlied@redhat.com>
7 * ATPX support for both Intel/ATI
9 #include <linux/vga_switcheroo.h>
10 #include <linux/slab.h>
11 #include <linux/acpi.h>
12 #include <linux/pci.h>
14 #include "amdgpu_acpi.h"
16 struct amdgpu_atpx_functions
{
23 bool disp_connectors_mapping
;
24 bool disp_detetion_ports
;
29 struct amdgpu_atpx_functions functions
;
32 static struct amdgpu_atpx_priv
{
34 /* handle for device - and atpx */
36 acpi_handle other_handle
;
37 struct amdgpu_atpx atpx
;
40 struct atpx_verify_interface
{
41 u16 size
; /* structure size in bytes (includes size field) */
42 u16 version
; /* version */
43 u32 function_bits
; /* supported functions bit vector */
46 struct atpx_px_params
{
47 u16 size
; /* structure size in bytes (includes size field) */
48 u32 valid_flags
; /* which flags are valid */
49 u32 flags
; /* flags */
52 struct atpx_power_control
{
62 bool amdgpu_has_atpx(void) {
63 return amdgpu_atpx_priv
.atpx_detected
;
67 * amdgpu_atpx_call - call an ATPX method
69 * @handle: acpi handle
70 * @function: the ATPX function to execute
71 * @params: ATPX function params
73 * Executes the requested ATPX function (all asics).
74 * Returns a pointer to the acpi output buffer.
76 static union acpi_object
*amdgpu_atpx_call(acpi_handle handle
, int function
,
77 struct acpi_buffer
*params
)
80 union acpi_object atpx_arg_elements
[2];
81 struct acpi_object_list atpx_arg
;
82 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
85 atpx_arg
.pointer
= &atpx_arg_elements
[0];
87 atpx_arg_elements
[0].type
= ACPI_TYPE_INTEGER
;
88 atpx_arg_elements
[0].integer
.value
= function
;
91 atpx_arg_elements
[1].type
= ACPI_TYPE_BUFFER
;
92 atpx_arg_elements
[1].buffer
.length
= params
->length
;
93 atpx_arg_elements
[1].buffer
.pointer
= params
->pointer
;
95 /* We need a second fake parameter */
96 atpx_arg_elements
[1].type
= ACPI_TYPE_INTEGER
;
97 atpx_arg_elements
[1].integer
.value
= 0;
100 status
= acpi_evaluate_object(handle
, NULL
, &atpx_arg
, &buffer
);
102 /* Fail only if calling the method fails and ATPX is supported */
103 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
) {
104 printk("failed to evaluate ATPX got %s\n",
105 acpi_format_exception(status
));
106 kfree(buffer
.pointer
);
110 return buffer
.pointer
;
114 * amdgpu_atpx_parse_functions - parse supported functions
116 * @f: supported functions struct
117 * @mask: supported functions mask from ATPX
119 * Use the supported functions mask from ATPX function
120 * ATPX_FUNCTION_VERIFY_INTERFACE to determine what functions
121 * are supported (all asics).
123 static void amdgpu_atpx_parse_functions(struct amdgpu_atpx_functions
*f
, u32 mask
)
125 f
->px_params
= mask
& ATPX_GET_PX_PARAMETERS_SUPPORTED
;
126 f
->power_cntl
= mask
& ATPX_POWER_CONTROL_SUPPORTED
;
127 f
->disp_mux_cntl
= mask
& ATPX_DISPLAY_MUX_CONTROL_SUPPORTED
;
128 f
->i2c_mux_cntl
= mask
& ATPX_I2C_MUX_CONTROL_SUPPORTED
;
129 f
->switch_start
= mask
& ATPX_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION_SUPPORTED
;
130 f
->switch_end
= mask
& ATPX_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION_SUPPORTED
;
131 f
->disp_connectors_mapping
= mask
& ATPX_GET_DISPLAY_CONNECTORS_MAPPING_SUPPORTED
;
132 f
->disp_detetion_ports
= mask
& ATPX_GET_DISPLAY_DETECTION_PORTS_SUPPORTED
;
136 * amdgpu_atpx_validate_functions - validate ATPX functions
138 * @atpx: amdgpu atpx struct
140 * Validate that required functions are enabled (all asics).
141 * returns 0 on success, error on failure.
143 static int amdgpu_atpx_validate(struct amdgpu_atpx
*atpx
)
145 /* make sure required functions are enabled */
146 /* dGPU power control is required */
147 atpx
->functions
.power_cntl
= true;
149 if (atpx
->functions
.px_params
) {
150 union acpi_object
*info
;
151 struct atpx_px_params output
;
155 info
= amdgpu_atpx_call(atpx
->handle
, ATPX_FUNCTION_GET_PX_PARAMETERS
, NULL
);
159 memset(&output
, 0, sizeof(output
));
161 size
= *(u16
*) info
->buffer
.pointer
;
163 printk("ATPX buffer is too small: %zu\n", size
);
167 size
= min(sizeof(output
), size
);
169 memcpy(&output
, info
->buffer
.pointer
, size
);
171 valid_bits
= output
.flags
& output
.valid_flags
;
172 /* if separate mux flag is set, mux controls are required */
173 if (valid_bits
& ATPX_SEPARATE_MUX_FOR_I2C
) {
174 atpx
->functions
.i2c_mux_cntl
= true;
175 atpx
->functions
.disp_mux_cntl
= true;
177 /* if any outputs are muxed, mux controls are required */
178 if (valid_bits
& (ATPX_CRT1_RGB_SIGNAL_MUXED
|
179 ATPX_TV_SIGNAL_MUXED
|
180 ATPX_DFP_SIGNAL_MUXED
))
181 atpx
->functions
.disp_mux_cntl
= true;
189 * amdgpu_atpx_verify_interface - verify ATPX
191 * @atpx: amdgpu atpx struct
193 * Execute the ATPX_FUNCTION_VERIFY_INTERFACE ATPX function
194 * to initialize ATPX and determine what features are supported
196 * returns 0 on success, error on failure.
198 static int amdgpu_atpx_verify_interface(struct amdgpu_atpx
*atpx
)
200 union acpi_object
*info
;
201 struct atpx_verify_interface output
;
205 info
= amdgpu_atpx_call(atpx
->handle
, ATPX_FUNCTION_VERIFY_INTERFACE
, NULL
);
209 memset(&output
, 0, sizeof(output
));
211 size
= *(u16
*) info
->buffer
.pointer
;
213 printk("ATPX buffer is too small: %zu\n", size
);
217 size
= min(sizeof(output
), size
);
219 memcpy(&output
, info
->buffer
.pointer
, size
);
221 /* TODO: check version? */
222 printk("ATPX version %u, functions 0x%08x\n",
223 output
.version
, output
.function_bits
);
225 amdgpu_atpx_parse_functions(&atpx
->functions
, output
.function_bits
);
233 * amdgpu_atpx_set_discrete_state - power up/down discrete GPU
235 * @atpx: atpx info struct
236 * @state: discrete GPU state (0 = power down, 1 = power up)
238 * Execute the ATPX_FUNCTION_POWER_CONTROL ATPX function to
239 * power down/up the discrete GPU (all asics).
240 * Returns 0 on success, error on failure.
242 static int amdgpu_atpx_set_discrete_state(struct amdgpu_atpx
*atpx
, u8 state
)
244 struct acpi_buffer params
;
245 union acpi_object
*info
;
246 struct atpx_power_control input
;
248 if (atpx
->functions
.power_cntl
) {
250 input
.dgpu_state
= state
;
251 params
.length
= input
.size
;
252 params
.pointer
= &input
;
253 info
= amdgpu_atpx_call(atpx
->handle
,
254 ATPX_FUNCTION_POWER_CONTROL
,
264 * amdgpu_atpx_switch_disp_mux - switch display mux
266 * @atpx: atpx info struct
267 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
269 * Execute the ATPX_FUNCTION_DISPLAY_MUX_CONTROL ATPX function to
270 * switch the display mux between the discrete GPU and integrated GPU
272 * Returns 0 on success, error on failure.
274 static int amdgpu_atpx_switch_disp_mux(struct amdgpu_atpx
*atpx
, u16 mux_id
)
276 struct acpi_buffer params
;
277 union acpi_object
*info
;
278 struct atpx_mux input
;
280 if (atpx
->functions
.disp_mux_cntl
) {
283 params
.length
= input
.size
;
284 params
.pointer
= &input
;
285 info
= amdgpu_atpx_call(atpx
->handle
,
286 ATPX_FUNCTION_DISPLAY_MUX_CONTROL
,
296 * amdgpu_atpx_switch_i2c_mux - switch i2c/hpd mux
298 * @atpx: atpx info struct
299 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
301 * Execute the ATPX_FUNCTION_I2C_MUX_CONTROL ATPX function to
302 * switch the i2c/hpd mux between the discrete GPU and integrated GPU
304 * Returns 0 on success, error on failure.
306 static int amdgpu_atpx_switch_i2c_mux(struct amdgpu_atpx
*atpx
, u16 mux_id
)
308 struct acpi_buffer params
;
309 union acpi_object
*info
;
310 struct atpx_mux input
;
312 if (atpx
->functions
.i2c_mux_cntl
) {
315 params
.length
= input
.size
;
316 params
.pointer
= &input
;
317 info
= amdgpu_atpx_call(atpx
->handle
,
318 ATPX_FUNCTION_I2C_MUX_CONTROL
,
328 * amdgpu_atpx_switch_start - notify the sbios of a GPU switch
330 * @atpx: atpx info struct
331 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
333 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION ATPX
334 * function to notify the sbios that a switch between the discrete GPU and
335 * integrated GPU has begun (all asics).
336 * Returns 0 on success, error on failure.
338 static int amdgpu_atpx_switch_start(struct amdgpu_atpx
*atpx
, u16 mux_id
)
340 struct acpi_buffer params
;
341 union acpi_object
*info
;
342 struct atpx_mux input
;
344 if (atpx
->functions
.switch_start
) {
347 params
.length
= input
.size
;
348 params
.pointer
= &input
;
349 info
= amdgpu_atpx_call(atpx
->handle
,
350 ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION
,
360 * amdgpu_atpx_switch_end - notify the sbios of a GPU switch
362 * @atpx: atpx info struct
363 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
365 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION ATPX
366 * function to notify the sbios that a switch between the discrete GPU and
367 * integrated GPU has ended (all asics).
368 * Returns 0 on success, error on failure.
370 static int amdgpu_atpx_switch_end(struct amdgpu_atpx
*atpx
, u16 mux_id
)
372 struct acpi_buffer params
;
373 union acpi_object
*info
;
374 struct atpx_mux input
;
376 if (atpx
->functions
.switch_end
) {
379 params
.length
= input
.size
;
380 params
.pointer
= &input
;
381 info
= amdgpu_atpx_call(atpx
->handle
,
382 ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION
,
392 * amdgpu_atpx_switchto - switch to the requested GPU
394 * @id: GPU to switch to
396 * Execute the necessary ATPX functions to switch between the discrete GPU and
397 * integrated GPU (all asics).
398 * Returns 0 on success, error on failure.
400 static int amdgpu_atpx_switchto(enum vga_switcheroo_client_id id
)
404 if (id
== VGA_SWITCHEROO_IGD
)
405 gpu_id
= ATPX_INTEGRATED_GPU
;
407 gpu_id
= ATPX_DISCRETE_GPU
;
409 amdgpu_atpx_switch_start(&amdgpu_atpx_priv
.atpx
, gpu_id
);
410 amdgpu_atpx_switch_disp_mux(&amdgpu_atpx_priv
.atpx
, gpu_id
);
411 amdgpu_atpx_switch_i2c_mux(&amdgpu_atpx_priv
.atpx
, gpu_id
);
412 amdgpu_atpx_switch_end(&amdgpu_atpx_priv
.atpx
, gpu_id
);
418 * amdgpu_atpx_power_state - power down/up the requested GPU
420 * @id: GPU to power down/up
421 * @state: requested power state (0 = off, 1 = on)
423 * Execute the necessary ATPX function to power down/up the discrete GPU
425 * Returns 0 on success, error on failure.
427 static int amdgpu_atpx_power_state(enum vga_switcheroo_client_id id
,
428 enum vga_switcheroo_state state
)
430 /* on w500 ACPI can't change intel gpu state */
431 if (id
== VGA_SWITCHEROO_IGD
)
434 amdgpu_atpx_set_discrete_state(&amdgpu_atpx_priv
.atpx
, state
);
439 * amdgpu_atpx_pci_probe_handle - look up the ATPX handle
443 * Look up the ATPX handles (all asics).
444 * Returns true if the handles are found, false if not.
446 static bool amdgpu_atpx_pci_probe_handle(struct pci_dev
*pdev
)
448 acpi_handle dhandle
, atpx_handle
;
451 dhandle
= ACPI_HANDLE(&pdev
->dev
);
455 status
= acpi_get_handle(dhandle
, "ATPX", &atpx_handle
);
456 if (ACPI_FAILURE(status
)) {
457 amdgpu_atpx_priv
.other_handle
= dhandle
;
460 amdgpu_atpx_priv
.dhandle
= dhandle
;
461 amdgpu_atpx_priv
.atpx
.handle
= atpx_handle
;
466 * amdgpu_atpx_init - verify the ATPX interface
468 * Verify the ATPX interface (all asics).
469 * Returns 0 on success, error on failure.
471 static int amdgpu_atpx_init(void)
475 /* set up the ATPX handle */
476 r
= amdgpu_atpx_verify_interface(&amdgpu_atpx_priv
.atpx
);
480 /* validate the atpx setup */
481 r
= amdgpu_atpx_validate(&amdgpu_atpx_priv
.atpx
);
489 * amdgpu_atpx_get_client_id - get the client id
493 * look up whether we are the integrated or discrete GPU (all asics).
494 * Returns the client id.
496 static int amdgpu_atpx_get_client_id(struct pci_dev
*pdev
)
498 if (amdgpu_atpx_priv
.dhandle
== ACPI_HANDLE(&pdev
->dev
))
499 return VGA_SWITCHEROO_IGD
;
501 return VGA_SWITCHEROO_DIS
;
504 static struct vga_switcheroo_handler amdgpu_atpx_handler
= {
505 .switchto
= amdgpu_atpx_switchto
,
506 .power_state
= amdgpu_atpx_power_state
,
507 .init
= amdgpu_atpx_init
,
508 .get_client_id
= amdgpu_atpx_get_client_id
,
512 * amdgpu_atpx_detect - detect whether we have PX
514 * Check if we have a PX system (all asics).
515 * Returns true if we have a PX system, false if not.
517 static bool amdgpu_atpx_detect(void)
519 char acpi_method_name
[255] = { 0 };
520 struct acpi_buffer buffer
= {sizeof(acpi_method_name
), acpi_method_name
};
521 struct pci_dev
*pdev
= NULL
;
522 bool has_atpx
= false;
525 while ((pdev
= pci_get_class(PCI_CLASS_DISPLAY_VGA
<< 8, pdev
)) != NULL
) {
528 has_atpx
|= (amdgpu_atpx_pci_probe_handle(pdev
) == true);
531 while ((pdev
= pci_get_class(PCI_CLASS_DISPLAY_OTHER
<< 8, pdev
)) != NULL
) {
534 has_atpx
|= (amdgpu_atpx_pci_probe_handle(pdev
) == true);
537 if (has_atpx
&& vga_count
== 2) {
538 acpi_get_name(amdgpu_atpx_priv
.atpx
.handle
, ACPI_FULL_PATHNAME
, &buffer
);
539 printk(KERN_INFO
"VGA switcheroo: detected switching method %s handle\n",
541 amdgpu_atpx_priv
.atpx_detected
= true;
548 * amdgpu_register_atpx_handler - register with vga_switcheroo
550 * Register the PX callbacks with vga_switcheroo (all asics).
552 void amdgpu_register_atpx_handler(void)
556 /* detect if we have any ATPX + 2 VGA in the system */
557 r
= amdgpu_atpx_detect();
561 vga_switcheroo_register_handler(&amdgpu_atpx_handler
);
565 * amdgpu_unregister_atpx_handler - unregister with vga_switcheroo
567 * Unregister the PX callbacks with vga_switcheroo (all asics).
569 void amdgpu_unregister_atpx_handler(void)
571 vga_switcheroo_unregister_handler();