drivers/gpu/drm/nouveau/nouveau_acpi.c

   1 #include <linux/pci.h>
   2 #include <linux/acpi.h>
   3 #include <acpi/acpi_drivers.h>
   4 #include <acpi/acpi_bus.h>
   5
   6 #include "drmP.h"
   7 #include "drm.h"
   8 #include "drm_sarea.h"
   9 #include "drm_crtc_helper.h"
  10 #include "nouveau_drv.h"
  11 #include "nouveau_drm.h"
  12 #include "nv50_display.h"
  13
  14 #include <linux/vga_switcheroo.h>
  15
  16 #define NOUVEAU_DSM_SUPPORTED 0x00
  17 #define NOUVEAU_DSM_SUPPORTED_FUNCTIONS 0x00
  18
  19 #define NOUVEAU_DSM_ACTIVE 0x01
  20 #define NOUVEAU_DSM_ACTIVE_QUERY 0x00
  21
  22 #define NOUVEAU_DSM_LED 0x02
  23 #define NOUVEAU_DSM_LED_STATE 0x00
  24 #define NOUVEAU_DSM_LED_OFF 0x10
  25 #define NOUVEAU_DSM_LED_STAMINA 0x11
  26 #define NOUVEAU_DSM_LED_SPEED 0x12
  27
  28 #define NOUVEAU_DSM_POWER 0x03
  29 #define NOUVEAU_DSM_POWER_STATE 0x00
  30 #define NOUVEAU_DSM_POWER_SPEED 0x01
  31 #define NOUVEAU_DSM_POWER_STAMINA 0x02
  32
  33 static struct nouveau_dsm_priv {
  34         bool dsm_detected;
  35         acpi_handle dhandle;
  36         acpi_handle dsm_handle;
  37 } nouveau_dsm_priv;
  38
  39 static const char nouveau_dsm_muid[] = {
  40         0xA0, 0xA0, 0x95, 0x9D, 0x60, 0x00, 0x48, 0x4D,
  41         0xB3, 0x4D, 0x7E, 0x5F, 0xEA, 0x12, 0x9F, 0xD4,
  42 };
  43
  44 static int nouveau_dsm(acpi_handle handle, int func, int arg, int *result)
  45 {
  46         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
  47         struct acpi_object_list input;
  48         union acpi_object params[4];
  49         union acpi_object *obj;
  50         int err;
  51
  52         input.count = 4;
  53         input.pointer = params;
  54         params[0].type = ACPI_TYPE_BUFFER;
  55         params[0].buffer.length = sizeof(nouveau_dsm_muid);
  56         params[0].buffer.pointer = (char *)nouveau_dsm_muid;
  57         params[1].type = ACPI_TYPE_INTEGER;
  58         params[1].integer.value = 0x00000102;
  59         params[2].type = ACPI_TYPE_INTEGER;
  60         params[2].integer.value = func;
  61         params[3].type = ACPI_TYPE_INTEGER;
  62         params[3].integer.value = arg;
  63
  64         err = acpi_evaluate_object(handle, "_DSM", &input, &output);
  65         if (err) {
  66                 printk(KERN_INFO "failed to evaluate _DSM: %d\n", err);
  67                 return err;
  68         }
  69
  70         obj = (union acpi_object *)output.pointer;
  71
  72         if (obj->type == ACPI_TYPE_INTEGER)
  73                 if (obj->integer.value == 0x80000002)
  74                         return -ENODEV;
  75
  76         if (obj->type == ACPI_TYPE_BUFFER) {
  77                 if (obj->buffer.length == 4 && result) {
  78                         *result = 0;
  79                         *result |= obj->buffer.pointer[0];
  80                         *result |= (obj->buffer.pointer[1] << 8);
  81                         *result |= (obj->buffer.pointer[2] << 16);
  82                         *result |= (obj->buffer.pointer[3] << 24);
  83                 }
  84         }
  85
  86         kfree(output.pointer);
  87         return 0;
  88 }
  89
  90 static int nouveau_dsm_switch_mux(acpi_handle handle, int mux_id)
  91 {
  92         return nouveau_dsm(handle, NOUVEAU_DSM_LED, mux_id, NULL);
  93 }
  94
  95 static int nouveau_dsm_set_discrete_state(acpi_handle handle, enum vga_switcheroo_state state)
  96 {
  97         int arg;
  98         if (state == VGA_SWITCHEROO_ON)
  99                 arg = NOUVEAU_DSM_POWER_SPEED;
 100         else
 101                 arg = NOUVEAU_DSM_POWER_STAMINA;
 102         nouveau_dsm(handle, NOUVEAU_DSM_POWER, arg, NULL);
 103         return 0;
 104 }
 105
 106 static int nouveau_dsm_switchto(enum vga_switcheroo_client_id id)
 107 {
 108         if (id == VGA_SWITCHEROO_IGD)
 109                 return nouveau_dsm_switch_mux(nouveau_dsm_priv.dsm_handle, NOUVEAU_DSM_LED_STAMINA);
 110         else
 111                 return nouveau_dsm_switch_mux(nouveau_dsm_priv.dsm_handle, NOUVEAU_DSM_LED_SPEED);
 112 }
 113
 114 static int nouveau_dsm_power_state(enum vga_switcheroo_client_id id,
 115                                    enum vga_switcheroo_state state)
 116 {
 117         if (id == VGA_SWITCHEROO_IGD)
 118                 return 0;
 119
 120         return nouveau_dsm_set_discrete_state(nouveau_dsm_priv.dsm_handle, state);
 121 }
 122
 123 static int nouveau_dsm_init(void)
 124 {
 125         return 0;
 126 }
 127
 128 static int nouveau_dsm_get_client_id(struct pci_dev *pdev)
 129 {
 130         if (nouveau_dsm_priv.dhandle == DEVICE_ACPI_HANDLE(&pdev->dev))
 131                 return VGA_SWITCHEROO_IGD;
 132         else
 133                 return VGA_SWITCHEROO_DIS;
 134 }
 135
 136 static struct vga_switcheroo_handler nouveau_dsm_handler = {
 137         .switchto = nouveau_dsm_switchto,
 138         .power_state = nouveau_dsm_power_state,
 139         .init = nouveau_dsm_init,
 140         .get_client_id = nouveau_dsm_get_client_id,
 141 };
 142
 143 static bool nouveau_dsm_pci_probe(struct pci_dev *pdev)
 144 {
 145         acpi_handle dhandle, nvidia_handle;
 146         acpi_status status;
 147         int ret;
 148         uint32_t result;
 149
 150         dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
 151         if (!dhandle)
 152                 return false;
 153         status = acpi_get_handle(dhandle, "_DSM", &nvidia_handle);
 154         if (ACPI_FAILURE(status)) {
 155                 return false;
 156         }
 157
 158         ret= nouveau_dsm(nvidia_handle, NOUVEAU_DSM_SUPPORTED,
 159                          NOUVEAU_DSM_SUPPORTED_FUNCTIONS, &result);
 160         if (ret < 0)
 161                 return false;
 162
 163         nouveau_dsm_priv.dhandle = dhandle;
 164         nouveau_dsm_priv.dsm_handle = nvidia_handle;
 165         return true;
 166 }
 167
 168 static bool nouveau_dsm_detect(void)
 169 {
 170         char acpi_method_name[255] = { 0 };
 171         struct acpi_buffer buffer = {sizeof(acpi_method_name), acpi_method_name};
 172         struct pci_dev *pdev = NULL;
 173         int has_dsm = 0;
 174         int vga_count = 0;
 175         while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
 176                 vga_count++;
 177
 178                 has_dsm |= (nouveau_dsm_pci_probe(pdev) == true);
 179         }
 180
 181         if (vga_count == 2 && has_dsm) {
 182                 acpi_get_name(nouveau_dsm_priv.dsm_handle, ACPI_FULL_PATHNAME, &buffer);
 183                 printk(KERN_INFO "VGA switcheroo: detected DSM switching method %s handle\n",
 184                        acpi_method_name);
 185                 nouveau_dsm_priv.dsm_detected = true;
 186                 return true;
 187         }
 188         return false;
 189 }
 190
 191 void nouveau_register_dsm_handler(void)
 192 {
 193         bool r;
 194
 195         r = nouveau_dsm_detect();
 196         if (!r)
 197                 return;
 198
 199         vga_switcheroo_register_handler(&nouveau_dsm_handler);
 200 }
 201
 202 void nouveau_unregister_dsm_handler(void)
 203 {
 204         vga_switcheroo_unregister_handler();
 205 }