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 #include <linux/vga_switcheroo.h>
10 #include <linux/slab.h>
11 #include <linux/acpi.h>
12 #include <linux/pci.h>
13 
14 #include "radeon_acpi.h"
15 
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 {
28 	acpi_handle handle;
29 	struct radeon_atpx_functions functions;
30 };
31 
32 static struct radeon_atpx_priv {
33 	bool atpx_detected;
34 	/* handle for device - and atpx */
35 	acpi_handle dhandle;
36 	acpi_handle other_handle;
37 	struct radeon_atpx atpx;
38 } radeon_atpx_priv;
39 
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 
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 
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 
62 bool radeon_is_px(void) {
63 	return radeon_atpx_priv.atpx_detected;
64 }
65 
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)
78 {
79 	acpi_status status;
80 	union acpi_object atpx_arg_elements[2];
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;
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 	}
99 
100 	status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer);
101 
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;
108 	}
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 
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 
188 /**
189  * radeon_atpx_verify_interface - verify ATPX
190  *
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  */
198 static int radeon_atpx_verify_interface(struct radeon_atpx *atpx)
199 {
200 	union acpi_object *info;
201 	struct atpx_verify_interface output;
202 	size_t size;
203 	int err = 0;
204 
205 	info = radeon_atpx_call(atpx->handle, ATPX_FUNCTION_VERIFY_INTERFACE, NULL);
206 	if (!info)
207 		return -EIO;
208 
209 	memset(&output, 0, sizeof(output));
210 
211 	size = *(u16 *) info->buffer.pointer;
212 	if (size < 8) {
213 		printk("ATPX buffer is too small: %zu\n", size);
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? */
222 	printk("ATPX version %u\n", output.version);
223 
224 	radeon_atpx_parse_functions(&atpx->functions, output.function_bits);
225 
226 out:
227 	kfree(info);
228 	return err;
229 }
230 
231 /**
232  * radeon_atpx_set_discrete_state - power up/down discrete GPU
233  *
234  * @atpx: atpx info struct
235  * @state: discrete GPU state (0 = power down, 1 = power up)
236  *
237  * Execute the ATPX_FUNCTION_POWER_CONTROL ATPX function to
238  * power down/up the discrete GPU (all asics).
239  * Returns 0 on success, error on failure.
240  */
241 static int radeon_atpx_set_discrete_state(struct radeon_atpx *atpx, u8 state)
242 {
243 	struct acpi_buffer params;
244 	union acpi_object *info;
245 	struct atpx_power_control input;
246 
247 	if (atpx->functions.power_cntl) {
248 		input.size = 3;
249 		input.dgpu_state = state;
250 		params.length = input.size;
251 		params.pointer = &input;
252 		info = radeon_atpx_call(atpx->handle,
253 					ATPX_FUNCTION_POWER_CONTROL,
254 					&params);
255 		if (!info)
256 			return -EIO;
257 		kfree(info);
258 	}
259 	return 0;
260 }
261 
262 /**
263  * radeon_atpx_switch_disp_mux - switch display mux
264  *
265  * @atpx: atpx info struct
266  * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
267  *
268  * Execute the ATPX_FUNCTION_DISPLAY_MUX_CONTROL ATPX function to
269  * switch the display mux between the discrete GPU and integrated GPU
270  * (all asics).
271  * Returns 0 on success, error on failure.
272  */
273 static int radeon_atpx_switch_disp_mux(struct radeon_atpx *atpx, u16 mux_id)
274 {
275 	struct acpi_buffer params;
276 	union acpi_object *info;
277 	struct atpx_mux input;
278 
279 	if (atpx->functions.disp_mux_cntl) {
280 		input.size = 4;
281 		input.mux = mux_id;
282 		params.length = input.size;
283 		params.pointer = &input;
284 		info = radeon_atpx_call(atpx->handle,
285 					ATPX_FUNCTION_DISPLAY_MUX_CONTROL,
286 					&params);
287 		if (!info)
288 			return -EIO;
289 		kfree(info);
290 	}
291 	return 0;
292 }
293 
294 /**
295  * radeon_atpx_switch_i2c_mux - switch i2c/hpd mux
296  *
297  * @atpx: atpx info struct
298  * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
299  *
300  * Execute the ATPX_FUNCTION_I2C_MUX_CONTROL ATPX function to
301  * switch the i2c/hpd mux between the discrete GPU and integrated GPU
302  * (all asics).
303  * Returns 0 on success, error on failure.
304  */
305 static int radeon_atpx_switch_i2c_mux(struct radeon_atpx *atpx, u16 mux_id)
306 {
307 	struct acpi_buffer params;
308 	union acpi_object *info;
309 	struct atpx_mux input;
310 
311 	if (atpx->functions.i2c_mux_cntl) {
312 		input.size = 4;
313 		input.mux = mux_id;
314 		params.length = input.size;
315 		params.pointer = &input;
316 		info = radeon_atpx_call(atpx->handle,
317 					ATPX_FUNCTION_I2C_MUX_CONTROL,
318 					&params);
319 		if (!info)
320 			return -EIO;
321 		kfree(info);
322 	}
323 	return 0;
324 }
325 
326 /**
327  * radeon_atpx_switch_start - notify the sbios of a GPU switch
328  *
329  * @atpx: atpx info struct
330  * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
331  *
332  * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION ATPX
333  * function to notify the sbios that a switch between the discrete GPU and
334  * integrated GPU has begun (all asics).
335  * Returns 0 on success, error on failure.
336  */
337 static int radeon_atpx_switch_start(struct radeon_atpx *atpx, u16 mux_id)
338 {
339 	struct acpi_buffer params;
340 	union acpi_object *info;
341 	struct atpx_mux input;
342 
343 	if (atpx->functions.switch_start) {
344 		input.size = 4;
345 		input.mux = mux_id;
346 		params.length = input.size;
347 		params.pointer = &input;
348 		info = radeon_atpx_call(atpx->handle,
349 					ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_START_NOTIFICATION,
350 					&params);
351 		if (!info)
352 			return -EIO;
353 		kfree(info);
354 	}
355 	return 0;
356 }
357 
358 /**
359  * radeon_atpx_switch_end - notify the sbios of a GPU switch
360  *
361  * @atpx: atpx info struct
362  * @mux_id: mux state (0 = integrated GPU, 1 = discrete GPU)
363  *
364  * Execute the ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION ATPX
365  * function to notify the sbios that a switch between the discrete GPU and
366  * integrated GPU has ended (all asics).
367  * Returns 0 on success, error on failure.
368  */
369 static int radeon_atpx_switch_end(struct radeon_atpx *atpx, u16 mux_id)
370 {
371 	struct acpi_buffer params;
372 	union acpi_object *info;
373 	struct atpx_mux input;
374 
375 	if (atpx->functions.switch_end) {
376 		input.size = 4;
377 		input.mux = mux_id;
378 		params.length = input.size;
379 		params.pointer = &input;
380 		info = radeon_atpx_call(atpx->handle,
381 					ATPX_FUNCTION_GRAPHICS_DEVICE_SWITCH_END_NOTIFICATION,
382 					&params);
383 		if (!info)
384 			return -EIO;
385 		kfree(info);
386 	}
387 	return 0;
388 }
389 
390 /**
391  * radeon_atpx_switchto - switch to the requested GPU
392  *
393  * @id: GPU to switch to
394  *
395  * Execute the necessary ATPX functions to switch between the discrete GPU and
396  * integrated GPU (all asics).
397  * Returns 0 on success, error on failure.
398  */
399 static int radeon_atpx_switchto(enum vga_switcheroo_client_id id)
400 {
401 	u16 gpu_id;
402 
403 	if (id == VGA_SWITCHEROO_IGD)
404 		gpu_id = ATPX_INTEGRATED_GPU;
405 	else
406 		gpu_id = ATPX_DISCRETE_GPU;
407 
408 	radeon_atpx_switch_start(&radeon_atpx_priv.atpx, gpu_id);
409 	radeon_atpx_switch_disp_mux(&radeon_atpx_priv.atpx, gpu_id);
410 	radeon_atpx_switch_i2c_mux(&radeon_atpx_priv.atpx, gpu_id);
411 	radeon_atpx_switch_end(&radeon_atpx_priv.atpx, gpu_id);
412 
413 	return 0;
414 }
415 
416 /**
417  * radeon_atpx_power_state - power down/up the requested GPU
418  *
419  * @id: GPU to power down/up
420  * @state: requested power state (0 = off, 1 = on)
421  *
422  * Execute the necessary ATPX function to power down/up the discrete GPU
423  * (all asics).
424  * Returns 0 on success, error on failure.
425  */
426 static int radeon_atpx_power_state(enum vga_switcheroo_client_id id,
427 				   enum vga_switcheroo_state state)
428 {
429 	/* on w500 ACPI can't change intel gpu state */
430 	if (id == VGA_SWITCHEROO_IGD)
431 		return 0;
432 
433 	radeon_atpx_set_discrete_state(&radeon_atpx_priv.atpx, state);
434 	return 0;
435 }
436 
437 /**
438  * radeon_atpx_pci_probe_handle - look up the ATPX handle
439  *
440  * @pdev: pci device
441  *
442  * Look up the ATPX handles (all asics).
443  * Returns true if the handles are found, false if not.
444  */
445 static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
446 {
447 	acpi_handle dhandle, atpx_handle;
448 	acpi_status status;
449 
450 	dhandle = ACPI_HANDLE(&pdev->dev);
451 	if (!dhandle)
452 		return false;
453 
454 	status = acpi_get_handle(dhandle, "ATPX", &atpx_handle);
455 	if (ACPI_FAILURE(status)) {
456 		radeon_atpx_priv.other_handle = dhandle;
457 		return false;
458 	}
459 	radeon_atpx_priv.dhandle = dhandle;
460 	radeon_atpx_priv.atpx.handle = atpx_handle;
461 	return true;
462 }
463 
464 /**
465  * radeon_atpx_init - verify the ATPX interface
466  *
467  * Verify the ATPX interface (all asics).
468  * Returns 0 on success, error on failure.
469  */
470 static int radeon_atpx_init(void)
471 {
472 	int r;
473 
474 	/* set up the ATPX handle */
475 	r = radeon_atpx_verify_interface(&radeon_atpx_priv.atpx);
476 	if (r)
477 		return r;
478 
479 	/* validate the atpx setup */
480 	r = radeon_atpx_validate(&radeon_atpx_priv.atpx);
481 	if (r)
482 		return r;
483 
484 	return 0;
485 }
486 
487 /**
488  * radeon_atpx_get_client_id - get the client id
489  *
490  * @pdev: pci device
491  *
492  * look up whether we are the integrated or discrete GPU (all asics).
493  * Returns the client id.
494  */
495 static int radeon_atpx_get_client_id(struct pci_dev *pdev)
496 {
497 	if (radeon_atpx_priv.dhandle == ACPI_HANDLE(&pdev->dev))
498 		return VGA_SWITCHEROO_IGD;
499 	else
500 		return VGA_SWITCHEROO_DIS;
501 }
502 
503 static struct vga_switcheroo_handler radeon_atpx_handler = {
504 	.switchto = radeon_atpx_switchto,
505 	.power_state = radeon_atpx_power_state,
506 	.init = radeon_atpx_init,
507 	.get_client_id = radeon_atpx_get_client_id,
508 };
509 
510 /**
511  * radeon_atpx_detect - detect whether we have PX
512  *
513  * Check if we have a PX system (all asics).
514  * Returns true if we have a PX system, false if not.
515  */
516 static bool radeon_atpx_detect(void)
517 {
518 	char acpi_method_name[255] = { 0 };
519 	struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
520 	struct pci_dev *pdev = NULL;
521 	bool has_atpx = false;
522 	int vga_count = 0;
523 
524 	while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
525 		vga_count++;
526 
527 		has_atpx |= (radeon_atpx_pci_probe_handle(pdev) == true);
528 	}
529 
530 	if (has_atpx && vga_count == 2) {
531 		acpi_get_name(radeon_atpx_priv.atpx.handle, ACPI_FULL_PATHNAME, &buffer);
532 		printk(KERN_INFO "VGA switcheroo: detected switching method %s handle\n",
533 		       acpi_method_name);
534 		radeon_atpx_priv.atpx_detected = true;
535 		/*
536 		 * On some systems hotplug events are generated for the device
537 		 * being switched off when ATPX is executed.  They cause ACPI
538 		 * hotplug to trigger and attempt to remove the device from
539 		 * the system, which causes it to break down.  Prevent that from
540 		 * happening by setting the no_hotplug flag for the involved
541 		 * ACPI device objects.
542 		 */
543 		acpi_bus_no_hotplug(radeon_atpx_priv.dhandle);
544 		acpi_bus_no_hotplug(radeon_atpx_priv.other_handle);
545 		return true;
546 	}
547 	return false;
548 }
549 
550 /**
551  * radeon_register_atpx_handler - register with vga_switcheroo
552  *
553  * Register the PX callbacks with vga_switcheroo (all asics).
554  */
555 void radeon_register_atpx_handler(void)
556 {
557 	bool r;
558 
559 	/* detect if we have any ATPX + 2 VGA in the system */
560 	r = radeon_atpx_detect();
561 	if (!r)
562 		return;
563 
564 	vga_switcheroo_register_handler(&radeon_atpx_handler);
565 }
566 
567 /**
568  * radeon_unregister_atpx_handler - unregister with vga_switcheroo
569  *
570  * Unregister the PX callbacks with vga_switcheroo (all asics).
571  */
572 void radeon_unregister_atpx_handler(void)
573 {
574 	vga_switcheroo_unregister_handler();
575 }
576