drm/i915: Sync i915_gem_pwrite_ioctl() with Linux 3.11
[dragonfly.git] / sys / dev / drm / radeon / radeon_atpx_handler.c
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
22 void radeon_register_atpx_handler(void);
23 void radeon_unregister_atpx_handler(void);
24
25 #ifdef DUMBBELL_WIP
26 struct 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
37 struct radeon_atpx {
38         ACPI_HANDLE handle;
39         struct radeon_atpx_functions functions;
40 };
41
42 static 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
49 struct 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
55 struct 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
61 struct atpx_power_control {
62         u16 size;
63         u8 dgpu_state;
64 } __packed;
65
66 struct 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  */
81 static 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  */
128 static 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
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  */
148 static 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
193 /**
194  * radeon_atpx_verify_interface - verify ATPX
195  *
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  */
203 static 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
231 out:
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  */
246 static 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  */
278 static 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  */
310 static 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  */
342 static 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  */
374 static 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  */
404 static 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  */
431 static 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  */
450 static 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  */
474 static int radeon_atpx_init(void)
475 {
476         int r;
477
478         /* set up the ATPX handle */
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;
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  */
499 static 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
507 static 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  */
520 static 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  */
550 void 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  */
569 void radeon_unregister_atpx_handler(void)
570 {
571 #ifdef DUMBBELL_WIP
572         vga_switcheroo_unregister_handler();
573 #endif /* DUMBBELL_WIP */
574 }