drivers/gpu/drm/i915/intel_acpi.c

   1 /*
   2  * Intel ACPI functions
   3  *
   4  * _DSM related code stolen from nouveau_acpi.c.
   5  */
   6 #include <linux/pci.h>
   7 #include <linux/acpi.h>
   8 #include <linux/vga_switcheroo.h>
   9 #include <acpi/acpi_drivers.h>
  10
  11 #include <drm/drmP.h>
  12 #include "i915_drv.h"
  13
  14 #define INTEL_DSM_REVISION_ID 1 /* For Calpella anyway... */
  15
  16 #define INTEL_DSM_FN_SUPPORTED_FUNCTIONS 0 /* No args */
  17 #define INTEL_DSM_FN_PLATFORM_MUX_INFO 1 /* No args */
  18
  19 static struct intel_dsm_priv {
  20         acpi_handle dhandle;
  21 } intel_dsm_priv;
  22
  23 static const u8 intel_dsm_guid[] = {
  24         0xd3, 0x73, 0xd8, 0x7e,
  25         0xd0, 0xc2,
  26         0x4f, 0x4e,
  27         0xa8, 0x54,
  28         0x0f, 0x13, 0x17, 0xb0, 0x1c, 0x2c
  29 };
  30
  31 static int intel_dsm(acpi_handle handle, int func)
  32 {
  33         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
  34         struct acpi_object_list input;
  35         union acpi_object params[4];
  36         union acpi_object *obj;
  37         u32 result;
  38         int ret = 0;
  39
  40         input.count = 4;
  41         input.pointer = params;
  42         params[0].type = ACPI_TYPE_BUFFER;
  43         params[0].buffer.length = sizeof(intel_dsm_guid);
  44         params[0].buffer.pointer = (char *)intel_dsm_guid;
  45         params[1].type = ACPI_TYPE_INTEGER;
  46         params[1].integer.value = INTEL_DSM_REVISION_ID;
  47         params[2].type = ACPI_TYPE_INTEGER;
  48         params[2].integer.value = func;
  49         params[3].type = ACPI_TYPE_PACKAGE;
  50         params[3].package.count = 0;
  51         params[3].package.elements = NULL;
  52
  53         ret = acpi_evaluate_object(handle, "_DSM", &input, &output);
  54         if (ret) {
  55                 DRM_DEBUG_DRIVER("failed to evaluate _DSM: %d\n", ret);
  56                 return ret;
  57         }
  58
  59         obj = (union acpi_object *)output.pointer;
  60
  61         result = 0;
  62         switch (obj->type) {
  63         case ACPI_TYPE_INTEGER:
  64                 result = obj->integer.value;
  65                 break;
  66
  67         case ACPI_TYPE_BUFFER:
  68                 if (obj->buffer.length == 4) {
  69                         result = (obj->buffer.pointer[0] |
  70                                 (obj->buffer.pointer[1] <<  8) |
  71                                 (obj->buffer.pointer[2] << 16) |
  72                                 (obj->buffer.pointer[3] << 24));
  73                         break;
  74                 }
  75         default:
  76                 ret = -EINVAL;
  77                 break;
  78         }
  79         if (result == 0x80000002)
  80                 ret = -ENODEV;
  81
  82         kfree(output.pointer);
  83         return ret;
  84 }
  85
  86 static char *intel_dsm_port_name(u8 id)
  87 {
  88         switch (id) {
  89         case 0:
  90                 return "Reserved";
  91         case 1:
  92                 return "Analog VGA";
  93         case 2:
  94                 return "LVDS";
  95         case 3:
  96                 return "Reserved";
  97         case 4:
  98                 return "HDMI/DVI_B";
  99         case 5:
 100                 return "HDMI/DVI_C";
 101         case 6:
 102                 return "HDMI/DVI_D";
 103         case 7:
 104                 return "DisplayPort_A";
 105         case 8:
 106                 return "DisplayPort_B";
 107         case 9:
 108                 return "DisplayPort_C";
 109         case 0xa:
 110                 return "DisplayPort_D";
 111         case 0xb:
 112         case 0xc:
 113         case 0xd:
 114                 return "Reserved";
 115         case 0xe:
 116                 return "WiDi";
 117         default:
 118                 return "bad type";
 119         }
 120 }
 121
 122 static char *intel_dsm_mux_type(u8 type)
 123 {
 124         switch (type) {
 125         case 0:
 126                 return "unknown";
 127         case 1:
 128                 return "No MUX, iGPU only";
 129         case 2:
 130                 return "No MUX, dGPU only";
 131         case 3:
 132                 return "MUXed between iGPU and dGPU";
 133         default:
 134                 return "bad type";
 135         }
 136 }
 137
 138 static void intel_dsm_platform_mux_info(void)
 139 {
 140         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 141         struct acpi_object_list input;
 142         union acpi_object params[4];
 143         union acpi_object *pkg;
 144         int i, ret;
 145
 146         input.count = 4;
 147         input.pointer = params;
 148         params[0].type = ACPI_TYPE_BUFFER;
 149         params[0].buffer.length = sizeof(intel_dsm_guid);
 150         params[0].buffer.pointer = (char *)intel_dsm_guid;
 151         params[1].type = ACPI_TYPE_INTEGER;
 152         params[1].integer.value = INTEL_DSM_REVISION_ID;
 153         params[2].type = ACPI_TYPE_INTEGER;
 154         params[2].integer.value = INTEL_DSM_FN_PLATFORM_MUX_INFO;
 155         params[3].type = ACPI_TYPE_PACKAGE;
 156         params[3].package.count = 0;
 157         params[3].package.elements = NULL;
 158
 159         ret = acpi_evaluate_object(intel_dsm_priv.dhandle, "_DSM", &input,
 160                                    &output);
 161         if (ret) {
 162                 DRM_DEBUG_DRIVER("failed to evaluate _DSM: %d\n", ret);
 163                 goto out;
 164         }
 165
 166         pkg = (union acpi_object *)output.pointer;
 167
 168         if (pkg->type == ACPI_TYPE_PACKAGE) {
 169                 union acpi_object *connector_count = &pkg->package.elements[0];
 170                 DRM_DEBUG_DRIVER("MUX info connectors: %lld\n",
 171                           (unsigned long long)connector_count->integer.value);
 172                 for (i = 1; i < pkg->package.count; i++) {
 173                         union acpi_object *obj = &pkg->package.elements[i];
 174                         union acpi_object *connector_id =
 175                                 &obj->package.elements[0];
 176                         union acpi_object *info = &obj->package.elements[1];
 177                         DRM_DEBUG_DRIVER("Connector id: 0x%016llx\n",
 178                                   (unsigned long long)connector_id->integer.value);
 179                         DRM_DEBUG_DRIVER("  port id: %s\n",
 180                                intel_dsm_port_name(info->buffer.pointer[0]));
 181                         DRM_DEBUG_DRIVER("  display mux info: %s\n",
 182                                intel_dsm_mux_type(info->buffer.pointer[1]));
 183                         DRM_DEBUG_DRIVER("  aux/dc mux info: %s\n",
 184                                intel_dsm_mux_type(info->buffer.pointer[2]));
 185                         DRM_DEBUG_DRIVER("  hpd mux info: %s\n",
 186                                intel_dsm_mux_type(info->buffer.pointer[3]));
 187                 }
 188         }
 189
 190 out:
 191         kfree(output.pointer);
 192 }
 193
 194 static bool intel_dsm_pci_probe(struct pci_dev *pdev)
 195 {
 196         acpi_handle dhandle;
 197         int ret;
 198
 199         dhandle = ACPI_HANDLE(&pdev->dev);
 200         if (!dhandle)
 201                 return false;
 202
 203         if (!acpi_has_method(dhandle, "_DSM")) {
 204                 DRM_DEBUG_KMS("no _DSM method for intel device\n");
 205                 return false;
 206         }
 207
 208         ret = intel_dsm(dhandle, INTEL_DSM_FN_SUPPORTED_FUNCTIONS);
 209         if (ret < 0) {
 210                 DRM_DEBUG_KMS("failed to get supported _DSM functions\n");
 211                 return false;
 212         }
 213
 214         intel_dsm_priv.dhandle = dhandle;
 215
 216         intel_dsm_platform_mux_info();
 217         return true;
 218 }
 219
 220 static bool intel_dsm_detect(void)
 221 {
 222         char acpi_method_name[255] = { 0 };
 223         struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
 224         struct pci_dev *pdev = NULL;
 225         bool has_dsm = false;
 226         int vga_count = 0;
 227
 228         while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
 229                 vga_count++;
 230                 has_dsm |= intel_dsm_pci_probe(pdev);
 231         }
 232
 233         if (vga_count == 2 && has_dsm) {
 234                 acpi_get_name(intel_dsm_priv.dhandle, ACPI_FULL_PATHNAME, &buffer);
 235                 DRM_DEBUG_DRIVER("VGA switcheroo: detected DSM switching method %s handle\n",
 236                                  acpi_method_name);
 237                 return true;
 238         }
 239
 240         return false;
 241 }
 242
 243 void intel_register_dsm_handler(void)
 244 {
 245         if (!intel_dsm_detect())
 246                 return;
 247 }
 248
 249 void intel_unregister_dsm_handler(void)
 250 {
 251 }