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