[deliverable/linux.git] / drivers / gpu / drm / radeon / radeon_atpx_handler.c

/*
 * Copyright (c) 2010 Red Hat Inc.
 * Author : Dave Airlie <airlied@redhat.com>
 *
 * Licensed under GPLv2
 *
 * ATPX support for both Intel/ATI
 */
#include <linux/vga_switcheroo.h>
#include <linux/slab.h>
#include <linux/acpi.h>
#include <linux/pci.h>

#include "radeon_acpi.h"

struct radeon_atpx_functions {
	bool px_params;
	bool power_cntl;
	bool disp_mux_cntl;
	bool i2c_mux_cntl;
	bool switch_start;
	bool switch_end;
	bool disp_connectors_mapping;
	bool disp_detetion_ports;
};

struct radeon_atpx {
	acpi_handle handle;
	struct radeon_atpx_functions functions;
};

static struct radeon_atpx_priv {
	bool atpx_detected;
	/* handle for device - and atpx */
	acpi_handle dhandle;
	acpi_handle other_handle;
	struct radeon_atpx atpx;
} radeon_atpx_priv;

struct atpx_verify_interface {
	u16 size;		/* structure size in bytes (includes size field) */
	u16 version;		/* version */
	u32 function_bits;	/* supported functions bit vector */
} __packed;

struct atpx_px_params {
	u16 size;		/* structure size in bytes (includes size field) */
	u32 valid_flags;	/* which flags are valid */
	u32 flags;		/* flags */
} __packed;

struct atpx_power_control {
	u16 size;
	u8 dgpu_state;
} __packed;

struct atpx_mux {
	u16 size;
	u16 mux;
} __packed;

bool radeon_is_px(void) {
	return radeon_atpx_priv.atpx_detected;
}

/**
 * radeon_atpx_call - call an ATPX method
 *
 * @handle: acpi handle
 * @function: the ATPX function to execute
 * @params: ATPX function params
 *
 * Executes the requested ATPX function (all asics).
 * Returns a pointer to the acpi output buffer.
 */
static union acpi_object *radeon_atpx_call(acpi_handle handle, int function,
					   struct acpi_buffer *params)
{
	acpi_status status;
	union acpi_object atpx_arg_elements[2];
	struct acpi_object_list atpx_arg;
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };

	atpx_arg.count = 2;
	atpx_arg.pointer = &atpx_arg_elements[0];

	atpx_arg_elements[0].type = ACPI_TYPE_INTEGER;
	atpx_arg_elements[0].integer.value = function;

	if (params) {
		atpx_arg_elements[1].type = ACPI_TYPE_BUFFER;
		atpx_arg_elements[1].buffer.length = params->length;
		atpx_arg_elements[1].buffer.pointer = params->pointer;
	} else {
		/* We need a second fake parameter */
		atpx_arg_elements[1].type = ACPI_TYPE_INTEGER;
		atpx_arg_elements[1].integer.value = 0;
	}

	status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer);

	/* Fail only if calling the method fails and ATPX is supported */
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
		printk("failed to evaluate ATPX got %s\n",
		       acpi_format_exception(status));
		kfree(buffer.pointer);
		return NULL;
	}

	return buffer.pointer;
}

/**
 * radeon_atpx_parse_functions - parse supported functions
 *
 * @f: supported functions struct
 * @mask: supported functions mask from ATPX
 *
 * Use the supported functions mask from ATPX function
 * ATPX_FUNCTION_VERIFY_INTERFACE to determine what functions
 * are supported (all asics).
 */
static void radeon_atpx_parse_functions(struct radeon_atpx_functions *f, u32 mask)
{
	f->px_params = mask & ATPX_GET_PX_PARAMETERS_SUPPORTED;
	f->power_cntl = mask & ATPX_POWER_CONTROL_SUPPORTED;
	f->disp_mux_cntl = mask & ATPX_DISPLAY_MUX_CONTROL_SUPPORTED;
	f->i2c_mux_cntl = mask & ATPX_I2C_MUX_CONTROL_SUPPORTED;
	f->switch_start = mask & ATPX_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION_SUPPORTED;
	f->switch_end = mask & ATPX_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION_SUPPORTED;
	f->disp_connectors_mapping = mask & ATPX_GET_DISPLAY_CONNECTORS_MAPPING_SUPPORTED;
	f->disp_detetion_ports = mask & ATPX_GET_DISPLAY_DETECTION_PORTS_SUPPORTED;
}

/**
 * radeon_atpx_validate_functions - validate ATPX functions
 *
 * @atpx: radeon atpx struct
 *
 * Validate that required functions are enabled (all asics).
 * returns 0 on success, error on failure.
 */
static int radeon_atpx_validate(struct radeon_atpx *atpx)
{
	/* make sure required functions are enabled */
	/* dGPU power control is required */
	atpx->functions.power_cntl = true;

	if (atpx->functions.px_params) {
		union acpi_object *info;
		struct atpx_px_params output;
		size_t size;
		u32 valid_bits;

		info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_GET_PX_PARAMETERS, NULL);
		if (!info)
			return -EIO;

		memset(&output, 0, sizeof(output));

		size = *(u16 *) info->buffer.pointer;
		if (size < 10) {
			printk("ATPX buffer is too small: %zu\n", size);
			kfree(info);
			return -EINVAL;
		}
		size = min(sizeof(output), size);

		memcpy(&output, info->buffer.pointer, size);

		valid_bits = output.flags & output.valid_flags;
		/* if separate mux flag is set, mux controls are required */
		if (valid_bits & ATPX_SEPARATE_MUX_FOR_I2C) {
			atpx->functions.i2c_mux_cntl = true;
			atpx->functions.disp_mux_cntl = true;
		}
		/* if any outputs are muxed, mux controls are required */
		if (valid_bits & (ATPX_CRT1_RGB_SIGNAL_MUXED |
				  ATPX_TV_SIGNAL_MUXED |
				  ATPX_DFP_SIGNAL_MUXED))
			atpx->functions.disp_mux_cntl = true;

		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_verify_interface - verify ATPX
 *
 * @atpx: radeon atpx struct
 *
 * Execute the ATPX_FUNCTION_VERIFY_INTERFACE ATPX function
 * to initialize ATPX and determine what features are supported
 * (all asics).
 * returns 0 on success, error on failure.
 */
static int radeon_atpx_verify_interface(struct radeon_atpx *atpx)
{
	union acpi_object *info;
	struct atpx_verify_interface output;
	size_t size;
	int err = 0;

	info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_VERIFY_INTERFACE, NULL);
	if (!info)
		return -EIO;

	memset(&output, 0, sizeof(output));

	size = *(u16 *) info->buffer.pointer;
	if (size < 8) {
		printk("ATPX buffer is too small: %zu\n", size);
		err = -EINVAL;
		goto out;
	}
	size = min(sizeof(output), size);

	memcpy(&output, info->buffer.pointer, size);

	/* TODO: check version? */
	printk("ATPX version %u, functions 0x%08x\n",
	       output.version, output.function_bits);

	radeon_atpx_parse_functions(&atpx->functions, output.function_bits);

out:
	kfree(info);
	return err;
}

/**
 * radeon_atpx_set_discrete_state - power up/down discrete GPU
 *
 * @atpx: atpx info struct
 * @state: discrete GPU state (0 = power down, 1 = power up)
 *
 * Execute the ATPX_FUNCTION_POWER_CONTROL ATPX function to
 * power down/up the discrete GPU (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_set_discrete_state(struct radeon_atpx *atpx, u8 state)
{
	struct acpi_buffer params;
	union acpi_object *info;
	struct atpx_power_control input;

	if (atpx->functions.power_cntl) {
		input.size = 3;
		input.dgpu_state = state;
		params.length = input.size;
		params.pointer = &input;
		info = radeon_atpx_call(atpx->handle,
					ATPX_FUNCTION_POWER_CONTROL,
					&params);
		if (!info)
			return -EIO;
		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_switch_disp_mux - switch display mux
 *
 * @atpx: atpx info struct
 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
 *
 * Execute the ATPX_FUNCTION_DISPLAY_MUX_CONTROL ATPX function to
 * switch the display mux between the discrete GPU and integrated GPU
 * (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_switch_disp_mux(struct radeon_atpx *atpx, u16 mux_id)
{
	struct acpi_buffer params;
	union acpi_object *info;
	struct atpx_mux input;

	if (atpx->functions.disp_mux_cntl) {
		input.size = 4;
		input.mux = mux_id;
		params.length = input.size;
		params.pointer = &input;
		info = radeon_atpx_call(atpx->handle,
					ATPX_FUNCTION_DISPLAY_MUX_CONTROL,
					&params);
		if (!info)
			return -EIO;
		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_switch_i2c_mux - switch i2c/hpd mux
 *
 * @atpx: atpx info struct
 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
 *
 * Execute the ATPX_FUNCTION_I2C_MUX_CONTROL ATPX function to
 * switch the i2c/hpd mux between the discrete GPU and integrated GPU
 * (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_switch_i2c_mux(struct radeon_atpx *atpx, u16 mux_id)
{
	struct acpi_buffer params;
	union acpi_object *info;
	struct atpx_mux input;

	if (atpx->functions.i2c_mux_cntl) {
		input.size = 4;
		input.mux = mux_id;
		params.length = input.size;
		params.pointer = &input;
		info = radeon_atpx_call(atpx->handle,
					ATPX_FUNCTION_I2C_MUX_CONTROL,
					&params);
		if (!info)
			return -EIO;
		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_switch_start - notify the sbios of a GPU switch
 *
 * @atpx: atpx info struct
 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
 *
 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION ATPX
 * function to notify the sbios that a switch between the discrete GPU and
 * integrated GPU has begun (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_switch_start(struct radeon_atpx *atpx, u16 mux_id)
{
	struct acpi_buffer params;
	union acpi_object *info;
	struct atpx_mux input;

	if (atpx->functions.switch_start) {
		input.size = 4;
		input.mux = mux_id;
		params.length = input.size;
		params.pointer = &input;
		info = radeon_atpx_call(atpx->handle,
					ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION,
					&params);
		if (!info)
			return -EIO;
		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_switch_end - notify the sbios of a GPU switch
 *
 * @atpx: atpx info struct
 * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
 *
 * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION ATPX
 * function to notify the sbios that a switch between the discrete GPU and
 * integrated GPU has ended (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_switch_end(struct radeon_atpx *atpx, u16 mux_id)
{
	struct acpi_buffer params;
	union acpi_object *info;
	struct atpx_mux input;

	if (atpx->functions.switch_end) {
		input.size = 4;
		input.mux = mux_id;
		params.length = input.size;
		params.pointer = &input;
		info = radeon_atpx_call(atpx->handle,
					ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION,
					&params);
		if (!info)
			return -EIO;
		kfree(info);
	}
	return 0;
}

/**
 * radeon_atpx_switchto - switch to the requested GPU
 *
 * @id: GPU to switch to
 *
 * Execute the necessary ATPX functions to switch between the discrete GPU and
 * integrated GPU (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_switchto(enum vga_switcheroo_client_id id)
{
	u16 gpu_id;

	if (id == VGA_SWITCHEROO_IGD)
		gpu_id = ATPX_INTEGRATED_GPU;
	else
		gpu_id = ATPX_DISCRETE_GPU;

	radeon_atpx_switch_start(&radeon_atpx_priv.atpx, gpu_id);
	radeon_atpx_switch_disp_mux(&radeon_atpx_priv.atpx, gpu_id);
	radeon_atpx_switch_i2c_mux(&radeon_atpx_priv.atpx, gpu_id);
	radeon_atpx_switch_end(&radeon_atpx_priv.atpx, gpu_id);

	return 0;
}

/**
 * radeon_atpx_power_state - power down/up the requested GPU
 *
 * @id: GPU to power down/up
 * @state: requested power state (0 = off, 1 = on)
 *
 * Execute the necessary ATPX function to power down/up the discrete GPU
 * (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_power_state(enum vga_switcheroo_client_id id,
				   enum vga_switcheroo_state state)
{
	/* on w500 ACPI can't change intel gpu state */
	if (id == VGA_SWITCHEROO_IGD)
		return 0;

	radeon_atpx_set_discrete_state(&radeon_atpx_priv.atpx, state);
	return 0;
}

/**
 * radeon_atpx_pci_probe_handle - look up the ATPX handle
 *
 * @pdev: pci device
 *
 * Look up the ATPX handles (all asics).
 * Returns true if the handles are found, false if not.
 */
static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
{
	acpi_handle dhandle, atpx_handle;
	acpi_status status;

	dhandle = ACPI_HANDLE(&pdev->dev);
	if (!dhandle)
		return false;

	status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);
	if (ACPI_FAILURE(status)) {
		radeon_atpx_priv.other_handle = dhandle;
		return false;
	}
	radeon_atpx_priv.dhandle = dhandle;
	radeon_atpx_priv.atpx.handle = atpx_handle;
	return true;
}

/**
 * radeon_atpx_init - verify the ATPX interface
 *
 * Verify the ATPX interface (all asics).
 * Returns 0 on success, error on failure.
 */
static int radeon_atpx_init(void)
{
	int r;

	/* set up the ATPX handle */
	r = radeon_atpx_verify_interface(&radeon_atpx_priv.atpx);
	if (r)
		return r;

	/* validate the atpx setup */
	r = radeon_atpx_validate(&radeon_atpx_priv.atpx);
	if (r)
		return r;

	return 0;
}

/**
 * radeon_atpx_get_client_id - get the client id
 *
 * @pdev: pci device
 *
 * look up whether we are the integrated or discrete GPU (all asics).
 * Returns the client id.
 */
static int radeon_atpx_get_client_id(struct pci_dev *pdev)
{
	if (radeon_atpx_priv.dhandle == ACPI_HANDLE(&pdev->dev))
		return VGA_SWITCHEROO_IGD;
	else
		return VGA_SWITCHEROO_DIS;
}

static struct vga_switcheroo_handler radeon_atpx_handler = {
	.switchto = radeon_atpx_switchto,
	.power_state = radeon_atpx_power_state,
	.init = radeon_atpx_init,
	.get_client_id = radeon_atpx_get_client_id,
};

/**
 * radeon_atpx_detect - detect whether we have PX
 *
 * Check if we have a PX system (all asics).
 * Returns true if we have a PX system, false if not.
 */
static bool radeon_atpx_detect(void)
{
	char acpi_method_name[255] = { 0 };
	struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
	struct pci_dev *pdev = NULL;
	bool has_atpx = false;
	int vga_count = 0;

	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
		vga_count++;

		has_atpx |= (radeon_atpx_pci_probe_handle(pdev) == true);
	}

	if (has_atpx && vga_count == 2) {
		acpi_get_name(radeon_atpx_priv.atpx.handle, ACPI_FULL_PATHNAME, &buffer);
		printk(KERN_INFO "VGA switcheroo: detected switching method %s handle\n",
		       acpi_method_name);
		radeon_atpx_priv.atpx_detected = true;
		/*
		 * On some systems hotplug events are generated for the device
		 * being switched off when ATPX is executed.  They cause ACPI
		 * hotplug to trigger and attempt to remove the device from
		 * the system, which causes it to break down.  Prevent that from
		 * happening by setting the no_hotplug flag for the involved
		 * ACPI device objects.
		 */
		acpi_bus_no_hotplug(radeon_atpx_priv.dhandle);
		acpi_bus_no_hotplug(radeon_atpx_priv.other_handle);
		return true;
	}
	return false;
}

/**
 * radeon_register_atpx_handler - register with vga_switcheroo
 *
 * Register the PX callbacks with vga_switcheroo (all asics).
 */
void radeon_register_atpx_handler(void)
{
	bool r;

	/* detect if we have any ATPX + 2 VGA in the system */
	r = radeon_atpx_detect();
	if (!r)
		return;

	vga_switcheroo_register_handler(&radeon_atpx_handler);
}

/**
 * radeon_unregister_atpx_handler - unregister with vga_switcheroo
 *
 * Unregister the PX callbacks with vga_switcheroo (all asics).
 */
void radeon_unregister_atpx_handler(void)
{
	vga_switcheroo_unregister_handler();
}
Commit	Line	Data
6a9ee8af DA	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	*/
6a9ee8af	9	#include <linux/vga_switcheroo.h>
5a0e3ad6	10	#include <linux/slab.h>
7b199811	11	#include <linux/acpi.h>
6a9ee8af DA	12	#include <linux/pci.h>
6a9ee8af DA	13
9e05b2f4	14	#include "radeon_acpi.h"
6a9ee8af	15
48fa412b AD	16	struct radeon_atpx_functions {
	17	bool px_params;
	18	bool power_cntl;
	19	bool disp_mux_cntl;
	20	bool i2c_mux_cntl;
	21	bool switch_start;
	22	bool switch_end;
	23	bool disp_connectors_mapping;
	24	bool disp_detetion_ports;
	25	};
	26
	27	struct radeon_atpx {
492b49a2	28	acpi_handle handle;
48fa412b AD	29	struct radeon_atpx_functions functions;
	30	};
	31
6a9ee8af DA	32	static struct radeon_atpx_priv {
	33	bool atpx_detected;
	34	/* handle for device - and atpx */
	35	acpi_handle dhandle;
f244d8b6	36	acpi_handle other_handle;
48fa412b	37	struct radeon_atpx atpx;
6a9ee8af DA	38	} radeon_atpx_priv;
6a9ee8af DA	39
48fa412b AD	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 */
	44	} __packed;
	45
43a23aa4 AD	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 */
	50	} __packed;
	51
492b49a2 AD	52	struct atpx_power_control {
	53	u16 size;
	54	u8 dgpu_state;
	55	} __packed;
	56
	57	struct atpx_mux {
	58	u16 size;
	59	u16 mux;
	60	} __packed;
	61
10ebc0bc DA	62	bool radeon_is_px(void) {
	63	return radeon_atpx_priv.atpx_detected;
	64	}
	65
48fa412b AD	66	/**
	67	* radeon_atpx_call - call an ATPX method
	68	*
	69	* @handle: acpi handle
	70	* @function: the ATPX function to execute
	71	* @params: ATPX function params
	72	*
	73	* Executes the requested ATPX function (all asics).
	74	* Returns a pointer to the acpi output buffer.
	75	*/
	76	static union acpi_object *radeon_atpx_call(acpi_handle handle, int function,
	77	struct acpi_buffer *params)
6a9ee8af DA	78	{
6a9ee8af DA	79	acpi_status status;
48fa412b	80	union acpi_object atpx_arg_elements[2];
6a9ee8af DA	81	struct acpi_object_list atpx_arg;
	82	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	83
	84	atpx_arg.count = 2;
	85	atpx_arg.pointer = &atpx_arg_elements[0];
	86
	87	atpx_arg_elements[0].type = ACPI_TYPE_INTEGER;
48fa412b AD	88	atpx_arg_elements[0].integer.value = function;
	89
	90	if (params) {
	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;
	94	} else {
	95	/* We need a second fake parameter */
	96	atpx_arg_elements[1].type = ACPI_TYPE_INTEGER;
	97	atpx_arg_elements[1].integer.value = 0;
	98	}
6a9ee8af	99
0b90365e	100	status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer);
6a9ee8af	101
48fa412b AD	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);
	107	return NULL;
6a9ee8af	108	}
48fa412b AD	109
	110	return buffer.pointer;
	111	}
	112
	113	/**
	114	* radeon_atpx_parse_functions - parse supported functions
	115	*
	116	* @f: supported functions struct
	117	* @mask: supported functions mask from ATPX
	118	*
	119	* Use the supported functions mask from ATPX function
	120	* ATPX_FUNCTION_VERIFY_INTERFACE to determine what functions
	121	* are supported (all asics).
	122	*/
	123	static void radeon_atpx_parse_functions(struct radeon_atpx_functions *f, u32 mask)
	124	{
	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;
	133	}
	134
43a23aa4 AD	135	/**
	136	* radeon_atpx_validate_functions - validate ATPX functions
	137	*
	138	* @atpx: radeon atpx struct
	139	*
	140	* Validate that required functions are enabled (all asics).
	141	* returns 0 on success, error on failure.
	142	*/
	143	static int radeon_atpx_validate(struct radeon_atpx *atpx)
	144	{
	145	/* make sure required functions are enabled */
	146	/* dGPU power control is required */
	147	atpx->functions.power_cntl = true;
	148
	149	if (atpx->functions.px_params) {
	150	union acpi_object *info;
	151	struct atpx_px_params output;
	152	size_t size;
	153	u32 valid_bits;
	154
	155	info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_GET_PX_PARAMETERS, NULL);
	156	if (!info)
	157	return -EIO;
	158
	159	memset(&output, 0, sizeof(output));
	160
	161	size = (u16 ) info->buffer.pointer;
	162	if (size < 10) {
	163	printk("ATPX buffer is too small: %zu\n", size);
	164	kfree(info);
	165	return -EINVAL;
	166	}
	167	size = min(sizeof(output), size);
	168
	169	memcpy(&output, info->buffer.pointer, size);
	170
	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;
	176	}
	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;
	182
	183	kfree(info);
	184	}
	185	return 0;
	186	}
	187
48fa412b AD	188	/**
	189	* radeon_atpx_verify_interface - verify ATPX
	190	*
48fa412b AD	191	* @atpx: radeon atpx struct
	192	*
	193	* Execute the ATPX_FUNCTION_VERIFY_INTERFACE ATPX function
	194	* to initialize ATPX and determine what features are supported
	195	* (all asics).
	196	* returns 0 on success, error on failure.
	197	*/
492b49a2	198	static int radeon_atpx_verify_interface(struct radeon_atpx *atpx)
48fa412b AD	199	{
	200	union acpi_object *info;
	201	struct atpx_verify_interface output;
	202	size_t size;
	203	int err = 0;
	204
492b49a2	205	info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_VERIFY_INTERFACE, NULL);
48fa412b AD	206	if (!info)
	207	return -EIO;
	208
	209	memset(&output, 0, sizeof(output));
	210
	211	size = (u16 ) info->buffer.pointer;
	212	if (size < 8) {
bd6126bd	213	printk("ATPX buffer is too small: %zu\n", size);
48fa412b AD	214	err = -EINVAL;
	215	goto out;
	216	}
	217	size = min(sizeof(output), size);
	218
	219	memcpy(&output, info->buffer.pointer, size);
	220
	221	/* TODO: check version? */
9f050c7f AD	222	printk("ATPX version %u, functions 0x%08x\n",
9f050c7f AD	223	output.version, output.function_bits);
48fa412b AD	224
	225	radeon_atpx_parse_functions(&atpx->functions, output.function_bits);
	226
	227	out:
	228	kfree(info);
	229	return err;
6a9ee8af DA	230	}
6a9ee8af DA	231
82e02935 AD	232	/**
	233	* radeon_atpx_set_discrete_state - power up/down discrete GPU
	234	*
	235	* @atpx: atpx info struct
	236	* @state: discrete GPU state (0 = power down, 1 = power up)
	237	*
	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.
	241	*/
492b49a2	242	static int radeon_atpx_set_discrete_state(struct radeon_atpx *atpx, u8 state)
6a9ee8af	243	{
492b49a2 AD	244	struct acpi_buffer params;
	245	union acpi_object *info;
	246	struct atpx_power_control input;
	247
	248	if (atpx->functions.power_cntl) {
	249	input.size = 3;
	250	input.dgpu_state = state;
	251	params.length = input.size;
	252	params.pointer = &input;
	253	info = radeon_atpx_call(atpx->handle,
	254	ATPX_FUNCTION_POWER_CONTROL,
	255	&params);
	256	if (!info)
	257	return -EIO;
	258	kfree(info);
6a9ee8af	259	}
6a9ee8af DA	260	return 0;
	261	}
	262
82e02935 AD	263	/**
	264	* radeon_atpx_switch_disp_mux - switch display mux
	265	*
	266	* @atpx: atpx info struct
	267	* @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
	268	*
	269	* Execute the ATPX_FUNCTION_DISPLAY_MUX_CONTROL ATPX function to
	270	* switch the display mux between the discrete GPU and integrated GPU
	271	* (all asics).
	272	* Returns 0 on success, error on failure.
	273	*/
492b49a2	274	static int radeon_atpx_switch_disp_mux(struct radeon_atpx *atpx, u16 mux_id)
6a9ee8af	275	{
492b49a2 AD	276	struct acpi_buffer params;
	277	union acpi_object *info;
	278	struct atpx_mux input;
	279
	280	if (atpx->functions.disp_mux_cntl) {
	281	input.size = 4;
	282	input.mux = mux_id;
	283	params.length = input.size;
	284	params.pointer = &input;
	285	info = radeon_atpx_call(atpx->handle,
	286	ATPX_FUNCTION_DISPLAY_MUX_CONTROL,
	287	&params);
	288	if (!info)
	289	return -EIO;
	290	kfree(info);
	291	}
	292	return 0;
6a9ee8af DA	293	}
6a9ee8af DA	294
82e02935 AD	295	/**
	296	* radeon_atpx_switch_i2c_mux - switch i2c/hpd mux
	297	*
	298	* @atpx: atpx info struct
	299	* @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
	300	*
	301	* Execute the ATPX_FUNCTION_I2C_MUX_CONTROL ATPX function to
	302	* switch the i2c/hpd mux between the discrete GPU and integrated GPU
	303	* (all asics).
	304	* Returns 0 on success, error on failure.
	305	*/
492b49a2	306	static int radeon_atpx_switch_i2c_mux(struct radeon_atpx *atpx, u16 mux_id)
58e73811	307	{
492b49a2 AD	308	struct acpi_buffer params;
	309	union acpi_object *info;
	310	struct atpx_mux input;
	311
	312	if (atpx->functions.i2c_mux_cntl) {
	313	input.size = 4;
	314	input.mux = mux_id;
	315	params.length = input.size;
	316	params.pointer = &input;
	317	info = radeon_atpx_call(atpx->handle,
	318	ATPX_FUNCTION_I2C_MUX_CONTROL,
	319	&params);
	320	if (!info)
	321	return -EIO;
	322	kfree(info);
	323	}
	324	return 0;
58e73811 AD	325	}
58e73811 AD	326
82e02935 AD	327	/**
	328	* radeon_atpx_switch_start - notify the sbios of a GPU switch
	329	*
	330	* @atpx: atpx info struct
	331	* @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
	332	*
	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.
	337	*/
492b49a2	338	static int radeon_atpx_switch_start(struct radeon_atpx *atpx, u16 mux_id)
58e73811	339	{
492b49a2 AD	340	struct acpi_buffer params;
	341	union acpi_object *info;
	342	struct atpx_mux input;
	343
	344	if (atpx->functions.switch_start) {
	345	input.size = 4;
	346	input.mux = mux_id;
	347	params.length = input.size;
	348	params.pointer = &input;
	349	info = radeon_atpx_call(atpx->handle,
	350	ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION,
	351	&params);
	352	if (!info)
	353	return -EIO;
	354	kfree(info);
	355	}
	356	return 0;
58e73811 AD	357	}
58e73811 AD	358
82e02935 AD	359	/**
	360	* radeon_atpx_switch_end - notify the sbios of a GPU switch
	361	*
	362	* @atpx: atpx info struct
	363	* @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
	364	*
	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.
	369	*/
492b49a2	370	static int radeon_atpx_switch_end(struct radeon_atpx *atpx, u16 mux_id)
58e73811	371	{
492b49a2 AD	372	struct acpi_buffer params;
	373	union acpi_object *info;
	374	struct atpx_mux input;
	375
	376	if (atpx->functions.switch_end) {
	377	input.size = 4;
	378	input.mux = mux_id;
	379	params.length = input.size;
	380	params.pointer = &input;
	381	info = radeon_atpx_call(atpx->handle,
	382	ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION,
	383	&params);
	384	if (!info)
	385	return -EIO;
	386	kfree(info);
	387	}
	388	return 0;
58e73811	389	}
6a9ee8af	390
82e02935 AD	391	/**
	392	* radeon_atpx_switchto - switch to the requested GPU
	393	*
	394	* @id: GPU to switch to
	395	*
	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.
	399	*/
6a9ee8af DA	400	static int radeon_atpx_switchto(enum vga_switcheroo_client_id id)
6a9ee8af DA	401	{
492b49a2	402	u16 gpu_id;
58e73811	403
6a9ee8af	404	if (id == VGA_SWITCHEROO_IGD)
9e05b2f4	405	gpu_id = ATPX_INTEGRATED_GPU;
6a9ee8af	406	else
9e05b2f4	407	gpu_id = ATPX_DISCRETE_GPU;
58e73811	408
492b49a2 AD	409	radeon_atpx_switch_start(&radeon_atpx_priv.atpx, gpu_id);
	410	radeon_atpx_switch_disp_mux(&radeon_atpx_priv.atpx, gpu_id);
	411	radeon_atpx_switch_i2c_mux(&radeon_atpx_priv.atpx, gpu_id);
	412	radeon_atpx_switch_end(&radeon_atpx_priv.atpx, gpu_id);
58e73811	413
6a9ee8af DA	414	return 0;
	415	}
	416
82e02935	417	/**
dfdcbebc	418	* radeon_atpx_power_state - power down/up the requested GPU
82e02935	419	*
dfdcbebc	420	* @id: GPU to power down/up
82e02935 AD	421	* @state: requested power state (0 = off, 1 = on)
	422	*
	423	* Execute the necessary ATPX function to power down/up the discrete GPU
	424	* (all asics).
	425	* Returns 0 on success, error on failure.
	426	*/
6a9ee8af DA	427	static int radeon_atpx_power_state(enum vga_switcheroo_client_id id,
	428	enum vga_switcheroo_state state)
	429	{
	430	/* on w500 ACPI can't change intel gpu state */
	431	if (id == VGA_SWITCHEROO_IGD)
	432	return 0;
	433
492b49a2	434	radeon_atpx_set_discrete_state(&radeon_atpx_priv.atpx, state);
6a9ee8af DA	435	return 0;
	436	}
	437
82e02935	438	/**
c9bd773c	439	* radeon_atpx_pci_probe_handle - look up the ATPX handle
82e02935 AD	440	*
	441	* @pdev: pci device
	442	*
c9bd773c	443	* Look up the ATPX handles (all asics).
82e02935 AD	444	* Returns true if the handles are found, false if not.
82e02935 AD	445	*/
6a9ee8af DA	446	static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
6a9ee8af DA	447	{
c61e2775	448	acpi_handle dhandle, atpx_handle;
6a9ee8af DA	449	acpi_status status;
6a9ee8af DA	450
3a83f992	451	dhandle = ACPI_HANDLE(&pdev->dev);
6a9ee8af DA	452	if (!dhandle)
	453	return false;
	454
	455	status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);
f244d8b6 RW	456	if (ACPI_FAILURE(status)) {
f244d8b6 RW	457	radeon_atpx_priv.other_handle = dhandle;
6a9ee8af	458	return false;
f244d8b6	459	}
6a9ee8af	460	radeon_atpx_priv.dhandle = dhandle;
492b49a2	461	radeon_atpx_priv.atpx.handle = atpx_handle;
6a9ee8af DA	462	return true;
	463	}
	464
82e02935 AD	465	/**
	466	* radeon_atpx_init - verify the ATPX interface
	467	*
	468	* Verify the ATPX interface (all asics).
	469	* Returns 0 on success, error on failure.
	470	*/
6a9ee8af DA	471	static int radeon_atpx_init(void)
6a9ee8af DA	472	{
43a23aa4 AD	473	int r;
43a23aa4 AD	474
6a9ee8af	475	/* set up the ATPX handle */
43a23aa4 AD	476	r = radeon_atpx_verify_interface(&radeon_atpx_priv.atpx);
	477	if (r)
	478	return r;
	479
	480	/* validate the atpx setup */
	481	r = radeon_atpx_validate(&radeon_atpx_priv.atpx);
	482	if (r)
	483	return r;
	484
	485	return 0;
6a9ee8af DA	486	}
6a9ee8af DA	487
82e02935 AD	488	/**
	489	* radeon_atpx_get_client_id - get the client id
	490	*
	491	* @pdev: pci device
	492	*
	493	* look up whether we are the integrated or discrete GPU (all asics).
	494	* Returns the client id.
	495	*/
6a9ee8af DA	496	static int radeon_atpx_get_client_id(struct pci_dev *pdev)
6a9ee8af DA	497	{
3a83f992	498	if (radeon_atpx_priv.dhandle == ACPI_HANDLE(&pdev->dev))
6a9ee8af DA	499	return VGA_SWITCHEROO_IGD;
	500	else
	501	return VGA_SWITCHEROO_DIS;
	502	}
	503
	504	static struct vga_switcheroo_handler radeon_atpx_handler = {
	505	.switchto = radeon_atpx_switchto,
	506	.power_state = radeon_atpx_power_state,
	507	.init = radeon_atpx_init,
	508	.get_client_id = radeon_atpx_get_client_id,
	509	};
	510
82e02935 AD	511	/**
	512	* radeon_atpx_detect - detect whether we have PX
	513	*
	514	* Check if we have a PX system (all asics).
	515	* Returns true if we have a PX system, false if not.
	516	*/
6a9ee8af DA	517	static bool radeon_atpx_detect(void)
	518	{
	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;
	523	int vga_count = 0;
	524
	525	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
	526	vga_count++;
	527
	528	has_atpx \|= (radeon_atpx_pci_probe_handle(pdev) == true);
	529	}
	530
	531	if (has_atpx && vga_count == 2) {
492b49a2	532	acpi_get_name(radeon_atpx_priv.atpx.handle, ACPI_FULL_PATHNAME, &buffer);
6a9ee8af DA	533	printk(KERN_INFO "VGA switcheroo: detected switching method %s handle\n",
	534	acpi_method_name);
	535	radeon_atpx_priv.atpx_detected = true;
f244d8b6 RW	536	/*
	537	* On some systems hotplug events are generated for the device
	538	* being switched off when ATPX is executed. They cause ACPI
	539	* hotplug to trigger and attempt to remove the device from
	540	* the system, which causes it to break down. Prevent that from
	541	* happening by setting the no_hotplug flag for the involved
	542	* ACPI device objects.
	543	*/
	544	acpi_bus_no_hotplug(radeon_atpx_priv.dhandle);
	545	acpi_bus_no_hotplug(radeon_atpx_priv.other_handle);
6a9ee8af DA	546	return true;
	547	}
	548	return false;
	549	}
	550
82e02935 AD	551	/**
	552	* radeon_register_atpx_handler - register with vga_switcheroo
	553	*
	554	* Register the PX callbacks with vga_switcheroo (all asics).
	555	*/
6a9ee8af DA	556	void radeon_register_atpx_handler(void)
	557	{
	558	bool r;
	559
	560	/* detect if we have any ATPX + 2 VGA in the system */
	561	r = radeon_atpx_detect();
	562	if (!r)
	563	return;
	564
	565	vga_switcheroo_register_handler(&radeon_atpx_handler);
	566	}
	567
82e02935 AD	568	/**
	569	* radeon_unregister_atpx_handler - unregister with vga_switcheroo
	570	*
	571	* Unregister the PX callbacks with vga_switcheroo (all asics).
	572	*/
6a9ee8af DA	573	void radeon_unregister_atpx_handler(void)
	574	{
	575	vga_switcheroo_unregister_handler();
	576	}