LXR linux/drivers/gpu/drm/nouveau/nouveau

   1#include <linux/pci.h>
   2#include <linux/acpi.h>
   3#include <linux/slab.h>
   4#include <linux/mxm-wmi.h>
   5#include <linux/vga_switcheroo.h>
   6#include <drm/drm_edid.h>
   7#include <acpi/video.h>
   8
   9#include "nouveau_drv.h"
  10#include "nouveau_acpi.h"
  11
  12#define NOUVEAU_DSM_LED 0x02
  13#define NOUVEAU_DSM_LED_STATE 0x00
  14#define NOUVEAU_DSM_LED_OFF 0x10
  15#define NOUVEAU_DSM_LED_STAMINA 0x11
  16#define NOUVEAU_DSM_LED_SPEED 0x12
  17
  18#define NOUVEAU_DSM_POWER 0x03
  19#define NOUVEAU_DSM_POWER_STATE 0x00
  20#define NOUVEAU_DSM_POWER_SPEED 0x01
  21#define NOUVEAU_DSM_POWER_STAMINA 0x02
  22
  23#define NOUVEAU_DSM_OPTIMUS_CAPS 0x1A
  24#define NOUVEAU_DSM_OPTIMUS_FLAGS 0x1B
  25
  26#define NOUVEAU_DSM_OPTIMUS_POWERDOWN_PS3 (3 << 24)
  27#define NOUVEAU_DSM_OPTIMUS_NO_POWERDOWN_PS3 (2 << 24)
  28#define NOUVEAU_DSM_OPTIMUS_FLAGS_CHANGED (1)
  29
  30#define NOUVEAU_DSM_OPTIMUS_SET_POWERDOWN (NOUVEAU_DSM_OPTIMUS_POWERDOWN_PS3 | NOUVEAU_DSM_OPTIMUS_FLAGS_CHANGED)
  31
  32/* result of the optimus caps function */
  33#define OPTIMUS_ENABLED (1 << 0)
  34#define OPTIMUS_STATUS_MASK (3 << 3)
  35#define OPTIMUS_STATUS_OFF  (0 << 3)
  36#define OPTIMUS_STATUS_ON_ENABLED  (1 << 3)
  37#define OPTIMUS_STATUS_PWR_STABLE  (3 << 3)
  38#define OPTIMUS_DISPLAY_HOTPLUG (1 << 6)
  39#define OPTIMUS_CAPS_MASK (7 << 24)
  40#define OPTIMUS_DYNAMIC_PWR_CAP (1 << 24)
  41
  42#define OPTIMUS_AUDIO_CAPS_MASK (3 << 27)
  43#define OPTIMUS_HDA_CODEC_MASK (2 << 27) /* hda bios control */
  44
  45static struct nouveau_dsm_priv {
  46        bool dsm_detected;
  47        bool optimus_detected;
  48        bool optimus_flags_detected;
  49        bool optimus_skip_dsm;
  50        acpi_handle dhandle;
  51        acpi_handle rom_handle;
  52} nouveau_dsm_priv;
  53
  54bool nouveau_is_optimus(void) {
  55        return nouveau_dsm_priv.optimus_detected;
  56}
  57
  58bool nouveau_is_v1_dsm(void) {
  59        return nouveau_dsm_priv.dsm_detected;
  60}
  61
  62#ifdef CONFIG_VGA_SWITCHEROO
  63static const guid_t nouveau_dsm_muid =
  64        GUID_INIT(0x9D95A0A0, 0x0060, 0x4D48,
  65                  0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4);
  66
  67static const guid_t nouveau_op_dsm_muid =
  68        GUID_INIT(0xA486D8F8, 0x0BDA, 0x471B,
  69                  0xA7, 0x2B, 0x60, 0x42, 0xA6, 0xB5, 0xBE, 0xE0);
  70
  71static int nouveau_optimus_dsm(acpi_handle handle, int func, int arg, uint32_t *result)
  72{
  73        int i;
  74        union acpi_object *obj;
  75        char args_buff[4];
  76        union acpi_object argv4 = {
  77                .buffer.type = ACPI_TYPE_BUFFER,
  78                .buffer.length = 4,
  79                .buffer.pointer = args_buff
  80        };
  81
  82        /* ACPI is little endian, AABBCCDD becomes {DD,CC,BB,AA} */
  83        for (i = 0; i < 4; i++)
  84                args_buff[i] = (arg >> i * 8) & 0xFF;
  85
  86        *result = 0;
  87        obj = acpi_evaluate_dsm_typed(handle, &nouveau_op_dsm_muid, 0x00000100,
  88                                      func, &argv4, ACPI_TYPE_BUFFER);
  89        if (!obj) {
  90                acpi_handle_info(handle, "failed to evaluate _DSM\n");
  91                return AE_ERROR;
  92        } else {
  93                if (obj->buffer.length == 4) {
  94                        *result |= obj->buffer.pointer[0];
  95                        *result |= (obj->buffer.pointer[1] << 8);
  96                        *result |= (obj->buffer.pointer[2] << 16);
  97                        *result |= (obj->buffer.pointer[3] << 24);
  98                }
  99                ACPI_FREE(obj);
 100        }
 101
 102        return 0;
 103}
 104
 105/*
 106 * On some platforms, _DSM(nouveau_op_dsm_muid, func0) has special
 107 * requirements on the fourth parameter, so a private implementation
 108 * instead of using acpi_check_dsm().
 109 */
 110static int nouveau_dsm_get_optimus_functions(acpi_handle handle)
 111{
 112        int result;
 113
 114        /*
 115         * Function 0 returns a Buffer containing available functions.
 116         * The args parameter is ignored for function 0, so just put 0 in it
 117         */
 118        if (nouveau_optimus_dsm(handle, 0, 0, &result))
 119                return 0;
 120
 121        /*
 122         * ACPI Spec v4 9.14.1: if bit 0 is zero, no function is supported.
 123         * If the n-th bit is enabled, function n is supported
 124         */
 125        if (result & 1 && result & (1 << NOUVEAU_DSM_OPTIMUS_CAPS))
 126                return result;
 127        return 0;
 128}
 129
 130static int nouveau_dsm(acpi_handle handle, int func, int arg)
 131{
 132        int ret = 0;
 133        union acpi_object *obj;
 134        union acpi_object argv4 = {
 135                .integer.type = ACPI_TYPE_INTEGER,
 136                .integer.value = arg,
 137        };
 138
 139        obj = acpi_evaluate_dsm_typed(handle, &nouveau_dsm_muid, 0x00000102,
 140                                      func, &argv4, ACPI_TYPE_INTEGER);
 141        if (!obj) {
 142                acpi_handle_info(handle, "failed to evaluate _DSM\n");
 143                return AE_ERROR;
 144        } else {
 145                if (obj->integer.value == 0x80000002)
 146                        ret = -ENODEV;
 147                ACPI_FREE(obj);
 148        }
 149
 150        return ret;
 151}
 152
 153static int nouveau_dsm_switch_mux(acpi_handle handle, int mux_id)
 154{
 155        mxm_wmi_call_mxmx(mux_id == NOUVEAU_DSM_LED_STAMINA ? MXM_MXDS_ADAPTER_IGD : MXM_MXDS_ADAPTER_0);
 156        mxm_wmi_call_mxds(mux_id == NOUVEAU_DSM_LED_STAMINA ? MXM_MXDS_ADAPTER_IGD : MXM_MXDS_ADAPTER_0);
 157        return nouveau_dsm(handle, NOUVEAU_DSM_LED, mux_id);
 158}
 159
 160static int nouveau_dsm_set_discrete_state(acpi_handle handle, enum vga_switcheroo_state state)
 161{
 162        int arg;
 163        if (state == VGA_SWITCHEROO_ON)
 164                arg = NOUVEAU_DSM_POWER_SPEED;
 165        else
 166                arg = NOUVEAU_DSM_POWER_STAMINA;
 167        nouveau_dsm(handle, NOUVEAU_DSM_POWER, arg);
 168        return 0;
 169}
 170
 171static int nouveau_dsm_switchto(enum vga_switcheroo_client_id id)
 172{
 173        if (!nouveau_dsm_priv.dsm_detected)
 174                return 0;
 175        if (id == VGA_SWITCHEROO_IGD)
 176                return nouveau_dsm_switch_mux(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_LED_STAMINA);
 177        else
 178                return nouveau_dsm_switch_mux(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_LED_SPEED);
 179}
 180
 181static int nouveau_dsm_power_state(enum vga_switcheroo_client_id id,
 182                                   enum vga_switcheroo_state state)
 183{
 184        if (id == VGA_SWITCHEROO_IGD)
 185                return 0;
 186
 187        /* Optimus laptops have the card already disabled in
 188         * nouveau_switcheroo_set_state */
 189        if (!nouveau_dsm_priv.dsm_detected)
 190                return 0;
 191
 192        return nouveau_dsm_set_discrete_state(nouveau_dsm_priv.dhandle, state);
 193}
 194
 195static int nouveau_dsm_get_client_id(struct pci_dev *pdev)
 196{
 197        /* easy option one - intel vendor ID means Integrated */
 198        if (pdev->vendor == PCI_VENDOR_ID_INTEL)
 199                return VGA_SWITCHEROO_IGD;
 200
 201        /* is this device on Bus 0? - this may need improving */
 202        if (pdev->bus->number == 0)
 203                return VGA_SWITCHEROO_IGD;
 204
 205        return VGA_SWITCHEROO_DIS;
 206}
 207
 208static const struct vga_switcheroo_handler nouveau_dsm_handler = {
 209        .switchto = nouveau_dsm_switchto,
 210        .power_state = nouveau_dsm_power_state,
 211        .get_client_id = nouveau_dsm_get_client_id,
 212};
 213
 214/*
 215 * Firmware supporting Windows 8 or later do not use _DSM to put the device into
 216 * D3cold, they instead rely on disabling power resources on the parent.
 217 */
 218static bool nouveau_pr3_present(struct pci_dev *pdev)
 219{
 220        struct pci_dev *parent_pdev = pci_upstream_bridge(pdev);
 221        struct acpi_device *parent_adev;
 222
 223        if (!parent_pdev)
 224                return false;
 225
 226        if (!parent_pdev->bridge_d3) {
 227                /*
 228                 * Parent PCI bridge is currently not power managed.
 229                 * Since userspace can change these afterwards to be on
 230                 * the safe side we stick with _DSM and prevent usage of
 231                 * _PR3 from the bridge.
 232                 */
 233                pci_d3cold_disable(pdev);
 234                return false;
 235        }
 236
 237        parent_adev = ACPI_COMPANION(&parent_pdev->dev);
 238        if (!parent_adev)
 239                return false;
 240
 241        return parent_adev->power.flags.power_resources &&
 242                acpi_has_method(parent_adev->handle, "_PR3");
 243}
 244
 245static void nouveau_dsm_pci_probe(struct pci_dev *pdev, acpi_handle *dhandle_out,
 246                                  bool *has_mux, bool *has_opt,
 247                                  bool *has_opt_flags, bool *has_pr3)
 248{
 249        acpi_handle dhandle;
 250        bool supports_mux;
 251        int optimus_funcs;
 252
 253        dhandle = ACPI_HANDLE(&pdev->dev);
 254        if (!dhandle)
 255                return;
 256
 257        if (!acpi_has_method(dhandle, "_DSM"))
 258                return;
 259
 260        supports_mux = acpi_check_dsm(dhandle, &nouveau_dsm_muid, 0x00000102,
 261                                      1 << NOUVEAU_DSM_POWER);
 262        optimus_funcs = nouveau_dsm_get_optimus_functions(dhandle);
 263
 264        /* Does not look like a Nvidia device. */
 265        if (!supports_mux && !optimus_funcs)
 266                return;
 267
 268        *dhandle_out = dhandle;
 269        *has_mux = supports_mux;
 270        *has_opt = !!optimus_funcs;
 271        *has_opt_flags = optimus_funcs & (1 << NOUVEAU_DSM_OPTIMUS_FLAGS);
 272        *has_pr3 = false;
 273
 274        if (optimus_funcs) {
 275                uint32_t result;
 276                nouveau_optimus_dsm(dhandle, NOUVEAU_DSM_OPTIMUS_CAPS, 0,
 277                                    &result);
 278                dev_info(&pdev->dev, "optimus capabilities: %s, status %s%s\n",
 279                         (result & OPTIMUS_ENABLED) ? "enabled" : "disabled",
 280                         (result & OPTIMUS_DYNAMIC_PWR_CAP) ? "dynamic power, " : "",
 281                         (result & OPTIMUS_HDA_CODEC_MASK) ? "hda bios codec supported" : "");
 282
 283                *has_pr3 = nouveau_pr3_present(pdev);
 284        }
 285}
 286
 287static bool nouveau_dsm_detect(void)
 288{
 289        char acpi_method_name[255] = { 0 };
 290        struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
 291        struct pci_dev *pdev = NULL;
 292        acpi_handle dhandle = NULL;
 293        bool has_mux = false;
 294        bool has_optimus = false;
 295        bool has_optimus_flags = false;
 296        bool has_power_resources = false;
 297        int vga_count = 0;
 298        bool guid_valid;
 299        bool ret = false;
 300
 301        /* lookup the MXM GUID */
 302        guid_valid = mxm_wmi_supported();
 303
 304        if (guid_valid)
 305                printk("MXM: GUID detected in BIOS\n");
 306
 307        /* now do DSM detection */
 308        while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
 309                vga_count++;
 310
 311                nouveau_dsm_pci_probe(pdev, &dhandle, &has_mux, &has_optimus,
 312                                      &has_optimus_flags, &has_power_resources);
 313        }
 314
 315        while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_3D << 8, pdev)) != NULL) {
 316                vga_count++;
 317
 318                nouveau_dsm_pci_probe(pdev, &dhandle, &has_mux, &has_optimus,
 319                                      &has_optimus_flags, &has_power_resources);
 320        }
 321
 322        /* find the optimus DSM or the old v1 DSM */
 323        if (has_optimus) {
 324                nouveau_dsm_priv.dhandle = dhandle;
 325                acpi_get_name(nouveau_dsm_priv.dhandle, ACPI_FULL_PATHNAME,
 326                        &buffer);
 327                pr_info("VGA switcheroo: detected Optimus DSM method %s handle\n",
 328                        acpi_method_name);
 329                if (has_power_resources)
 330                        pr_info("nouveau: detected PR support, will not use DSM\n");
 331                nouveau_dsm_priv.optimus_detected = true;
 332                nouveau_dsm_priv.optimus_flags_detected = has_optimus_flags;
 333                nouveau_dsm_priv.optimus_skip_dsm = has_power_resources;
 334                ret = true;
 335        } else if (vga_count == 2 && has_mux && guid_valid) {
 336                nouveau_dsm_priv.dhandle = dhandle;
 337                acpi_get_name(nouveau_dsm_priv.dhandle, ACPI_FULL_PATHNAME,
 338                        &buffer);
 339                pr_info("VGA switcheroo: detected DSM switching method %s handle\n",
 340                        acpi_method_name);
 341                nouveau_dsm_priv.dsm_detected = true;
 342                ret = true;
 343        }
 344
 345
 346        return ret;
 347}
 348
 349void nouveau_register_dsm_handler(void)
 350{
 351        bool r;
 352
 353        r = nouveau_dsm_detect();
 354        if (!r)
 355                return;
 356
 357        vga_switcheroo_register_handler(&nouveau_dsm_handler, 0);
 358}
 359
 360/* Must be called for Optimus models before the card can be turned off */
 361void nouveau_switcheroo_optimus_dsm(void)
 362{
 363        u32 result = 0;
 364        if (!nouveau_dsm_priv.optimus_detected || nouveau_dsm_priv.optimus_skip_dsm)
 365                return;
 366
 367        if (nouveau_dsm_priv.optimus_flags_detected)
 368                nouveau_optimus_dsm(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_OPTIMUS_FLAGS,
 369                                    0x3, &result);
 370
 371        nouveau_optimus_dsm(nouveau_dsm_priv.dhandle, NOUVEAU_DSM_OPTIMUS_CAPS,
 372                NOUVEAU_DSM_OPTIMUS_SET_POWERDOWN, &result);
 373
 374}
 375
 376void nouveau_unregister_dsm_handler(void)
 377{
 378        if (nouveau_dsm_priv.optimus_detected || nouveau_dsm_priv.dsm_detected)
 379                vga_switcheroo_unregister_handler();
 380}
 381#else
 382void nouveau_register_dsm_handler(void) {}
 383void nouveau_unregister_dsm_handler(void) {}
 384void nouveau_switcheroo_optimus_dsm(void) {}
 385#endif
 386
 387/* retrieve the ROM in 4k blocks */
 388static int nouveau_rom_call(acpi_handle rom_handle, uint8_t *bios,
 389                            int offset, int len)
 390{
 391        acpi_status status;
 392        union acpi_object rom_arg_elements[2], *obj;
 393        struct acpi_object_list rom_arg;
 394        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL};
 395
 396        rom_arg.count = 2;
 397        rom_arg.pointer = &rom_arg_elements[0];
 398
 399        rom_arg_elements[0].type = ACPI_TYPE_INTEGER;
 400        rom_arg_elements[0].integer.value = offset;
 401
 402        rom_arg_elements[1].type = ACPI_TYPE_INTEGER;
 403        rom_arg_elements[1].integer.value = len;
 404
 405        status = acpi_evaluate_object(rom_handle, NULL, &rom_arg, &buffer);
 406        if (ACPI_FAILURE(status)) {
 407                pr_info("failed to evaluate ROM got %s\n",
 408                        acpi_format_exception(status));
 409                return -ENODEV;
 410        }
 411        obj = (union acpi_object *)buffer.pointer;
 412        len = min(len, (int)obj->buffer.length);
 413        memcpy(bios+offset, obj->buffer.pointer, len);
 414        kfree(buffer.pointer);
 415        return len;
 416}
 417
 418bool nouveau_acpi_rom_supported(struct device *dev)
 419{
 420        acpi_status status;
 421        acpi_handle dhandle, rom_handle;
 422
 423        dhandle = ACPI_HANDLE(dev);
 424        if (!dhandle)
 425                return false;
 426
 427        status = acpi_get_handle(dhandle, "_ROM", &rom_handle);
 428        if (ACPI_FAILURE(status))
 429                return false;
 430
 431        nouveau_dsm_priv.rom_handle = rom_handle;
 432        return true;
 433}
 434
 435int nouveau_acpi_get_bios_chunk(uint8_t *bios, int offset, int len)
 436{
 437        return nouveau_rom_call(nouveau_dsm_priv.rom_handle, bios, offset, len);
 438}
 439
 440void *
 441nouveau_acpi_edid(struct drm_device *dev, struct drm_connector *connector)
 442{
 443        struct acpi_device *acpidev;
 444        acpi_handle handle;
 445        int type, ret;
 446        void *edid;
 447
 448        switch (connector->connector_type) {
 449        case DRM_MODE_CONNECTOR_LVDS:
 450        case DRM_MODE_CONNECTOR_eDP:
 451                type = ACPI_VIDEO_DISPLAY_LCD;
 452                break;
 453        default:
 454                return NULL;
 455        }
 456
 457        handle = ACPI_HANDLE(&dev->pdev->dev);
 458        if (!handle)
 459                return NULL;
 460
 461        ret = acpi_bus_get_device(handle, &acpidev);
 462        if (ret)
 463                return NULL;
 464
 465        ret = acpi_video_get_edid(acpidev, type, -1, &edid);
 466        if (ret < 0)
 467                return NULL;
 468
 469        return kmemdup(edid, EDID_LENGTH, GFP_KERNEL);
 470}
 471