drivers/gpu/vga/vga_switcheroo.c

   1 /*
   2  * vga_switcheroo.c - Support for laptop with dual GPU using one set of outputs
   3  *
   4  * Copyright (c) 2010 Red Hat Inc.
   5  * Author : Dave Airlie <airlied@redhat.com>
   6  *
   7  * Copyright (c) 2015 Lukas Wunner <lukas@wunner.de>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the next
  17  * paragraph) shall be included in all copies or substantial portions of the
  18  * Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS
  27  * IN THE SOFTWARE.
  28  *
  29  */
  30
  31 #define pr_fmt(fmt) "vga_switcheroo: " fmt
  32
  33 #include <linux/console.h>
  34 #include <linux/debugfs.h>
  35 #include <linux/fb.h>
  36 #include <linux/fs.h>
  37 #include <linux/module.h>
  38 #include <linux/pci.h>
  39 #include <linux/pm_domain.h>
  40 #include <linux/pm_runtime.h>
  41 #include <linux/seq_file.h>
  42 #include <linux/uaccess.h>
  43 #include <linux/vgaarb.h>
  44 #include <linux/vga_switcheroo.h>
  45
  46 /**
  47  * DOC: Overview
  48  *
  49  * vga_switcheroo is the Linux subsystem for laptop hybrid graphics.
  50  * These come in two flavors:
  51  *
  52  * * muxed: Dual GPUs with a multiplexer chip to switch outputs between GPUs.
  53  * * muxless: Dual GPUs but only one of them is connected to outputs.
  54  *      The other one is merely used to offload rendering, its results
  55  *      are copied over PCIe into the framebuffer. On Linux this is
  56  *      supported with DRI PRIME.
  57  *
  58  * Hybrid graphics started to appear in the late Naughties and were initially
  59  * all muxed. Newer laptops moved to a muxless architecture for cost reasons.
  60  * A notable exception is the MacBook Pro which continues to use a mux.
  61  * Muxes come with varying capabilities: Some switch only the panel, others
  62  * can also switch external displays. Some switch all display pins at once
  63  * while others can switch just the DDC lines. (To allow EDID probing
  64  * for the inactive GPU.) Also, muxes are often used to cut power to the
  65  * discrete GPU while it is not used.
  66  *
  67  * DRM drivers register GPUs with vga_switcheroo, these are henceforth called
  68  * clients. The mux is called the handler. Muxless machines also register a
  69  * handler to control the power state of the discrete GPU, its ->switchto
  70  * callback is a no-op for obvious reasons. The discrete GPU is often equipped
  71  * with an HDA controller for the HDMI/DP audio signal, this will also
  72  * register as a client so that vga_switcheroo can take care of the correct
  73  * suspend/resume order when changing the discrete GPU's power state. In total
  74  * there can thus be up to three clients: Two vga clients (GPUs) and one audio
  75  * client (on the discrete GPU). The code is mostly prepared to support
  76  * machines with more than two GPUs should they become available.
  77  *
  78  * The GPU to which the outputs are currently switched is called the
  79  * active client in vga_switcheroo parlance. The GPU not in use is the
  80  * inactive client. When the inactive client's DRM driver is loaded,
  81  * it will be unable to probe the panel's EDID and hence depends on
  82  * VBIOS to provide its display modes. If the VBIOS modes are bogus or
  83  * if there is no VBIOS at all (which is common on the MacBook Pro),
  84  * a client may alternatively request that the DDC lines are temporarily
  85  * switched to it, provided that the handler supports this. Switching
  86  * only the DDC lines and not the entire output avoids unnecessary
  87  * flickering.
  88  */
  89
  90 /**
  91  * struct vga_switcheroo_client - registered client
  92  * @pdev: client pci device
  93  * @fb_info: framebuffer to which console is remapped on switching
  94  * @pwr_state: current power state
  95  * @ops: client callbacks
  96  * @id: client identifier. Determining the id requires the handler,
  97  *      so gpus are initially assigned VGA_SWITCHEROO_UNKNOWN_ID
  98  *      and later given their true id in vga_switcheroo_enable()
  99  * @active: whether the outputs are currently switched to this client
 100  * @driver_power_control: whether power state is controlled by the driver's
 101  *      runtime pm. If true, writing ON and OFF to the vga_switcheroo debugfs
 102  *      interface is a no-op so as not to interfere with runtime pm
 103  * @list: client list
 104  *
 105  * Registered client. A client can be either a GPU or an audio device on a GPU.
 106  * For audio clients, the @fb_info, @active and @driver_power_control members
 107  * are bogus.
 108  */
 109 struct vga_switcheroo_client {
 110         struct pci_dev *pdev;
 111         struct fb_info *fb_info;
 112         enum vga_switcheroo_state pwr_state;
 113         const struct vga_switcheroo_client_ops *ops;
 114         enum vga_switcheroo_client_id id;
 115         bool active;
 116         bool driver_power_control;
 117         struct list_head list;
 118 };
 119
 120 /*
 121  * protects access to struct vgasr_priv
 122  */
 123 static DEFINE_MUTEX(vgasr_mutex);
 124
 125 /**
 126  * struct vgasr_priv - vga_switcheroo private data
 127  * @active: whether vga_switcheroo is enabled.
 128  *      Prerequisite is the registration of two GPUs and a handler
 129  * @delayed_switch_active: whether a delayed switch is pending
 130  * @delayed_client_id: client to which a delayed switch is pending
 131  * @debugfs_root: directory for vga_switcheroo debugfs interface
 132  * @switch_file: file for vga_switcheroo debugfs interface
 133  * @registered_clients: number of registered GPUs
 134  *      (counting only vga clients, not audio clients)
 135  * @clients: list of registered clients
 136  * @handler: registered handler
 137  * @handler_flags: flags of registered handler
 138  * @mux_hw_lock: protects mux state
 139  *      (in particular while DDC lines are temporarily switched)
 140  * @old_ddc_owner: client to which DDC lines will be switched back on unlock
 141  *
 142  * vga_switcheroo private data. Currently only one vga_switcheroo instance
 143  * per system is supported.
 144  */
 145 struct vgasr_priv {
 146         bool active;
 147         bool delayed_switch_active;
 148         enum vga_switcheroo_client_id delayed_client_id;
 149
 150         struct dentry *debugfs_root;
 151         struct dentry *switch_file;
 152
 153         int registered_clients;
 154         struct list_head clients;
 155
 156         const struct vga_switcheroo_handler *handler;
 157         enum vga_switcheroo_handler_flags_t handler_flags;
 158         struct mutex mux_hw_lock;
 159         int old_ddc_owner;
 160 };
 161
 162 #define ID_BIT_AUDIO            0x100
 163 #define client_is_audio(c)      ((c)->id & ID_BIT_AUDIO)
 164 #define client_is_vga(c)        ((c)->id == VGA_SWITCHEROO_UNKNOWN_ID || \
 165                                  !client_is_audio(c))
 166 #define client_id(c)            ((c)->id & ~ID_BIT_AUDIO)
 167
 168 static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv);
 169 static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv);
 170
 171 /* only one switcheroo per system */
 172 static struct vgasr_priv vgasr_priv = {
 173         .clients = LIST_HEAD_INIT(vgasr_priv.clients),
 174         .mux_hw_lock = __MUTEX_INITIALIZER(vgasr_priv.mux_hw_lock),
 175 };
 176
 177 static bool vga_switcheroo_ready(void)
 178 {
 179         /* we're ready if we get two clients + handler */
 180         return !vgasr_priv.active &&
 181                vgasr_priv.registered_clients == 2 && vgasr_priv.handler;
 182 }
 183
 184 static void vga_switcheroo_enable(void)
 185 {
 186         int ret;
 187         struct vga_switcheroo_client *client;
 188
 189         /* call the handler to init */
 190         if (vgasr_priv.handler->init)
 191                 vgasr_priv.handler->init();
 192
 193         list_for_each_entry(client, &vgasr_priv.clients, list) {
 194                 if (client->id != VGA_SWITCHEROO_UNKNOWN_ID)
 195                         continue;
 196                 ret = vgasr_priv.handler->get_client_id(client->pdev);
 197                 if (ret < 0)
 198                         return;
 199
 200                 client->id = ret;
 201         }
 202         vga_switcheroo_debugfs_init(&vgasr_priv);
 203         vgasr_priv.active = true;
 204 }
 205
 206 /**
 207  * vga_switcheroo_register_handler() - register handler
 208  * @handler: handler callbacks
 209  * @handler_flags: handler flags
 210  *
 211  * Register handler. Enable vga_switcheroo if two vga clients have already
 212  * registered.
 213  *
 214  * Return: 0 on success, -EINVAL if a handler was already registered.
 215  */
 216 int vga_switcheroo_register_handler(const struct vga_switcheroo_handler *handler,
 217                                     enum vga_switcheroo_handler_flags_t handler_flags)
 218 {
 219         mutex_lock(&vgasr_mutex);
 220         if (vgasr_priv.handler) {
 221                 mutex_unlock(&vgasr_mutex);
 222                 return -EINVAL;
 223         }
 224
 225         vgasr_priv.handler = handler;
 226         vgasr_priv.handler_flags = handler_flags;
 227         if (vga_switcheroo_ready()) {
 228                 pr_info("enabled\n");
 229                 vga_switcheroo_enable();
 230         }
 231         mutex_unlock(&vgasr_mutex);
 232         return 0;
 233 }
 234 EXPORT_SYMBOL(vga_switcheroo_register_handler);
 235
 236 /**
 237  * vga_switcheroo_unregister_handler() - unregister handler
 238  *
 239  * Unregister handler. Disable vga_switcheroo.
 240  */
 241 void vga_switcheroo_unregister_handler(void)
 242 {
 243         mutex_lock(&vgasr_mutex);
 244         mutex_lock(&vgasr_priv.mux_hw_lock);
 245         vgasr_priv.handler_flags = 0;
 246         vgasr_priv.handler = NULL;
 247         if (vgasr_priv.active) {
 248                 pr_info("disabled\n");
 249                 vga_switcheroo_debugfs_fini(&vgasr_priv);
 250                 vgasr_priv.active = false;
 251         }
 252         mutex_unlock(&vgasr_priv.mux_hw_lock);
 253         mutex_unlock(&vgasr_mutex);
 254 }
 255 EXPORT_SYMBOL(vga_switcheroo_unregister_handler);
 256
 257 /**
 258  * vga_switcheroo_handler_flags() - obtain handler flags
 259  *
 260  * Helper for clients to obtain the handler flags bitmask.
 261  *
 262  * Return: Handler flags. A value of 0 means that no handler is registered
 263  * or that the handler has no special capabilities.
 264  */
 265 enum vga_switcheroo_handler_flags_t vga_switcheroo_handler_flags(void)
 266 {
 267         return vgasr_priv.handler_flags;
 268 }
 269 EXPORT_SYMBOL(vga_switcheroo_handler_flags);
 270
 271 static int register_client(struct pci_dev *pdev,
 272                            const struct vga_switcheroo_client_ops *ops,
 273                            enum vga_switcheroo_client_id id, bool active,
 274                            bool driver_power_control)
 275 {
 276         struct vga_switcheroo_client *client;
 277
 278         client = kzalloc(sizeof(*client), GFP_KERNEL);
 279         if (!client)
 280                 return -ENOMEM;
 281
 282         client->pwr_state = VGA_SWITCHEROO_ON;
 283         client->pdev = pdev;
 284         client->ops = ops;
 285         client->id = id;
 286         client->active = active;
 287         client->driver_power_control = driver_power_control;
 288
 289         mutex_lock(&vgasr_mutex);
 290         list_add_tail(&client->list, &vgasr_priv.clients);
 291         if (client_is_vga(client))
 292                 vgasr_priv.registered_clients++;
 293
 294         if (vga_switcheroo_ready()) {
 295                 pr_info("enabled\n");
 296                 vga_switcheroo_enable();
 297         }
 298         mutex_unlock(&vgasr_mutex);
 299         return 0;
 300 }
 301
 302 /**
 303  * vga_switcheroo_register_client - register vga client
 304  * @pdev: client pci device
 305  * @ops: client callbacks
 306  * @driver_power_control: whether power state is controlled by the driver's
 307  *      runtime pm
 308  *
 309  * Register vga client (GPU). Enable vga_switcheroo if another GPU and a
 310  * handler have already registered. The power state of the client is assumed
 311  * to be ON.
 312  *
 313  * Return: 0 on success, -ENOMEM on memory allocation error.
 314  */
 315 int vga_switcheroo_register_client(struct pci_dev *pdev,
 316                                    const struct vga_switcheroo_client_ops *ops,
 317                                    bool driver_power_control)
 318 {
 319         return register_client(pdev, ops, VGA_SWITCHEROO_UNKNOWN_ID,
 320                                pdev == vga_default_device(),
 321                                driver_power_control);
 322 }
 323 EXPORT_SYMBOL(vga_switcheroo_register_client);
 324
 325 /**
 326  * vga_switcheroo_register_audio_client - register audio client
 327  * @pdev: client pci device
 328  * @ops: client callbacks
 329  * @id: client identifier
 330  *
 331  * Register audio client (audio device on a GPU). The power state of the
 332  * client is assumed to be ON.
 333  *
 334  * Return: 0 on success, -ENOMEM on memory allocation error.
 335  */
 336 int vga_switcheroo_register_audio_client(struct pci_dev *pdev,
 337                                          const struct vga_switcheroo_client_ops *ops,
 338                                          enum vga_switcheroo_client_id id)
 339 {
 340         return register_client(pdev, ops, id | ID_BIT_AUDIO, false, false);
 341 }
 342 EXPORT_SYMBOL(vga_switcheroo_register_audio_client);
 343
 344 static struct vga_switcheroo_client *
 345 find_client_from_pci(struct list_head *head, struct pci_dev *pdev)
 346 {
 347         struct vga_switcheroo_client *client;
 348
 349         list_for_each_entry(client, head, list)
 350                 if (client->pdev == pdev)
 351                         return client;
 352         return NULL;
 353 }
 354
 355 static struct vga_switcheroo_client *
 356 find_client_from_id(struct list_head *head,
 357                     enum vga_switcheroo_client_id client_id)
 358 {
 359         struct vga_switcheroo_client *client;
 360
 361         list_for_each_entry(client, head, list)
 362                 if (client->id == client_id)
 363                         return client;
 364         return NULL;
 365 }
 366
 367 static struct vga_switcheroo_client *
 368 find_active_client(struct list_head *head)
 369 {
 370         struct vga_switcheroo_client *client;
 371
 372         list_for_each_entry(client, head, list)
 373                 if (client->active)
 374                         return client;
 375         return NULL;
 376 }
 377
 378 /**
 379  * vga_switcheroo_get_client_state() - obtain power state of a given client
 380  * @pdev: client pci device
 381  *
 382  * Obtain power state of a given client as seen from vga_switcheroo.
 383  * The function is only called from hda_intel.c.
 384  *
 385  * Return: Power state.
 386  */
 387 enum vga_switcheroo_state vga_switcheroo_get_client_state(struct pci_dev *pdev)
 388 {
 389         struct vga_switcheroo_client *client;
 390         enum vga_switcheroo_state ret;
 391
 392         mutex_lock(&vgasr_mutex);
 393         client = find_client_from_pci(&vgasr_priv.clients, pdev);
 394         if (!client)
 395                 ret = VGA_SWITCHEROO_NOT_FOUND;
 396         else
 397                 ret = client->pwr_state;
 398         mutex_unlock(&vgasr_mutex);
 399         return ret;
 400 }
 401 EXPORT_SYMBOL(vga_switcheroo_get_client_state);
 402
 403 /**
 404  * vga_switcheroo_unregister_client() - unregister client
 405  * @pdev: client pci device
 406  *
 407  * Unregister client. Disable vga_switcheroo if this is a vga client (GPU).
 408  */
 409 void vga_switcheroo_unregister_client(struct pci_dev *pdev)
 410 {
 411         struct vga_switcheroo_client *client;
 412
 413         mutex_lock(&vgasr_mutex);
 414         client = find_client_from_pci(&vgasr_priv.clients, pdev);
 415         if (client) {
 416                 if (client_is_vga(client))
 417                         vgasr_priv.registered_clients--;
 418                 list_del(&client->list);
 419                 kfree(client);
 420         }
 421         if (vgasr_priv.active && vgasr_priv.registered_clients < 2) {
 422                 pr_info("disabled\n");
 423                 vga_switcheroo_debugfs_fini(&vgasr_priv);
 424                 vgasr_priv.active = false;
 425         }
 426         mutex_unlock(&vgasr_mutex);
 427 }
 428 EXPORT_SYMBOL(vga_switcheroo_unregister_client);
 429
 430 /**
 431  * vga_switcheroo_client_fb_set() - set framebuffer of a given client
 432  * @pdev: client pci device
 433  * @info: framebuffer
 434  *
 435  * Set framebuffer of a given client. The console will be remapped to this
 436  * on switching.
 437  */
 438 void vga_switcheroo_client_fb_set(struct pci_dev *pdev,
 439                                  struct fb_info *info)
 440 {
 441         struct vga_switcheroo_client *client;
 442
 443         mutex_lock(&vgasr_mutex);
 444         client = find_client_from_pci(&vgasr_priv.clients, pdev);
 445         if (client)
 446                 client->fb_info = info;
 447         mutex_unlock(&vgasr_mutex);
 448 }
 449 EXPORT_SYMBOL(vga_switcheroo_client_fb_set);
 450
 451 /**
 452  * vga_switcheroo_lock_ddc() - temporarily switch DDC lines to a given client
 453  * @pdev: client pci device
 454  *
 455  * Temporarily switch DDC lines to the client identified by @pdev
 456  * (but leave the outputs otherwise switched to where they are).
 457  * This allows the inactive client to probe EDID. The DDC lines must
 458  * afterwards be switched back by calling vga_switcheroo_unlock_ddc(),
 459  * even if this function returns an error.
 460  *
 461  * Return: Previous DDC owner on success or a negative int on error.
 462  * Specifically, %-ENODEV if no handler has registered or if the handler
 463  * does not support switching the DDC lines. Also, a negative value
 464  * returned by the handler is propagated back to the caller.
 465  * The return value has merely an informational purpose for any caller
 466  * which might be interested in it. It is acceptable to ignore the return
 467  * value and simply rely on the result of the subsequent EDID probe,
 468  * which will be %NULL if DDC switching failed.
 469  */
 470 int vga_switcheroo_lock_ddc(struct pci_dev *pdev)
 471 {
 472         enum vga_switcheroo_client_id id;
 473
 474         mutex_lock(&vgasr_priv.mux_hw_lock);
 475         if (!vgasr_priv.handler || !vgasr_priv.handler->switch_ddc) {
 476                 vgasr_priv.old_ddc_owner = -ENODEV;
 477                 return -ENODEV;
 478         }
 479
 480         id = vgasr_priv.handler->get_client_id(pdev);
 481         vgasr_priv.old_ddc_owner = vgasr_priv.handler->switch_ddc(id);
 482         return vgasr_priv.old_ddc_owner;
 483 }
 484 EXPORT_SYMBOL(vga_switcheroo_lock_ddc);
 485
 486 /**
 487  * vga_switcheroo_unlock_ddc() - switch DDC lines back to previous owner
 488  * @pdev: client pci device
 489  *
 490  * Switch DDC lines back to the previous owner after calling
 491  * vga_switcheroo_lock_ddc(). This must be called even if
 492  * vga_switcheroo_lock_ddc() returned an error.
 493  *
 494  * Return: Previous DDC owner on success (i.e. the client identifier of @pdev)
 495  * or a negative int on error.
 496  * Specifically, %-ENODEV if no handler has registered or if the handler
 497  * does not support switching the DDC lines. Also, a negative value
 498  * returned by the handler is propagated back to the caller.
 499  * Finally, invoking this function without calling vga_switcheroo_lock_ddc()
 500  * first is not allowed and will result in %-EINVAL.
 501  */
 502 int vga_switcheroo_unlock_ddc(struct pci_dev *pdev)
 503 {
 504         enum vga_switcheroo_client_id id;
 505         int ret = vgasr_priv.old_ddc_owner;
 506
 507         if (WARN_ON_ONCE(!mutex_is_locked(&vgasr_priv.mux_hw_lock)))
 508                 return -EINVAL;
 509
 510         if (vgasr_priv.old_ddc_owner >= 0) {
 511                 id = vgasr_priv.handler->get_client_id(pdev);
 512                 if (vgasr_priv.old_ddc_owner != id)
 513                         ret = vgasr_priv.handler->switch_ddc(
 514                                                      vgasr_priv.old_ddc_owner);
 515         }
 516         mutex_unlock(&vgasr_priv.mux_hw_lock);
 517         return ret;
 518 }
 519 EXPORT_SYMBOL(vga_switcheroo_unlock_ddc);
 520
 521 /**
 522  * DOC: Manual switching and manual power control
 523  *
 524  * In this mode of use, the file /sys/kernel/debug/vgaswitcheroo/switch
 525  * can be read to retrieve the current vga_switcheroo state and commands
 526  * can be written to it to change the state. The file appears as soon as
 527  * two GPU drivers and one handler have registered with vga_switcheroo.
 528  * The following commands are understood:
 529  *
 530  * * OFF: Power off the device not in use.
 531  * * ON: Power on the device not in use.
 532  * * IGD: Switch to the integrated graphics device.
 533  *      Power on the integrated GPU if necessary, power off the discrete GPU.
 534  *      Prerequisite is that no user space processes (e.g. Xorg, alsactl)
 535  *      have opened device files of the GPUs or the audio client. If the
 536  *      switch fails, the user may invoke lsof(8) or fuser(1) on /dev/dri/
 537  *      and /dev/snd/controlC1 to identify processes blocking the switch.
 538  * * DIS: Switch to the discrete graphics device.
 539  * * DIGD: Delayed switch to the integrated graphics device.
 540  *      This will perform the switch once the last user space process has
 541  *      closed the device files of the GPUs and the audio client.
 542  * * DDIS: Delayed switch to the discrete graphics device.
 543  * * MIGD: Mux-only switch to the integrated graphics device.
 544  *      Does not remap console or change the power state of either gpu.
 545  *      If the integrated GPU is currently off, the screen will turn black.
 546  *      If it is on, the screen will show whatever happens to be in VRAM.
 547  *      Either way, the user has to blindly enter the command to switch back.
 548  * * MDIS: Mux-only switch to the discrete graphics device.
 549  *
 550  * For GPUs whose power state is controlled by the driver's runtime pm,
 551  * the ON and OFF commands are a no-op (see next section).
 552  *
 553  * For muxless machines, the IGD/DIS, DIGD/DDIS and MIGD/MDIS commands
 554  * should not be used.
 555  */
 556
 557 static int vga_switcheroo_show(struct seq_file *m, void *v)
 558 {
 559         struct vga_switcheroo_client *client;
 560         int i = 0;
 561
 562         mutex_lock(&vgasr_mutex);
 563         list_for_each_entry(client, &vgasr_priv.clients, list) {
 564                 seq_printf(m, "%d:%s%s:%c:%s%s:%s\n", i,
 565                            client_id(client) == VGA_SWITCHEROO_DIS ? "DIS" :
 566                                                                      "IGD",
 567                            client_is_vga(client) ? "" : "-Audio",
 568                            client->active ? '+' : ' ',
 569                            client->driver_power_control ? "Dyn" : "",
 570                            client->pwr_state ? "Pwr" : "Off",
 571                            pci_name(client->pdev));
 572                 i++;
 573         }
 574         mutex_unlock(&vgasr_mutex);
 575         return 0;
 576 }
 577
 578 static int vga_switcheroo_debugfs_open(struct inode *inode, struct file *file)
 579 {
 580         return single_open(file, vga_switcheroo_show, NULL);
 581 }
 582
 583 static int vga_switchon(struct vga_switcheroo_client *client)
 584 {
 585         if (client->driver_power_control)
 586                 return 0;
 587         if (vgasr_priv.handler->power_state)
 588                 vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_ON);
 589         /* call the driver callback to turn on device */
 590         client->ops->set_gpu_state(client->pdev, VGA_SWITCHEROO_ON);
 591         client->pwr_state = VGA_SWITCHEROO_ON;
 592         return 0;
 593 }
 594
 595 static int vga_switchoff(struct vga_switcheroo_client *client)
 596 {
 597         if (client->driver_power_control)
 598                 return 0;
 599         /* call the driver callback to turn off device */
 600         client->ops->set_gpu_state(client->pdev, VGA_SWITCHEROO_OFF);
 601         if (vgasr_priv.handler->power_state)
 602                 vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_OFF);
 603         client->pwr_state = VGA_SWITCHEROO_OFF;
 604         return 0;
 605 }
 606
 607 static void set_audio_state(enum vga_switcheroo_client_id id,
 608                             enum vga_switcheroo_state state)
 609 {
 610         struct vga_switcheroo_client *client;
 611
 612         client = find_client_from_id(&vgasr_priv.clients, id | ID_BIT_AUDIO);
 613         if (client && client->pwr_state != state) {
 614                 client->ops->set_gpu_state(client->pdev, state);
 615                 client->pwr_state = state;
 616         }
 617 }
 618
 619 /* stage one happens before delay */
 620 static int vga_switchto_stage1(struct vga_switcheroo_client *new_client)
 621 {
 622         struct vga_switcheroo_client *active;
 623
 624         active = find_active_client(&vgasr_priv.clients);
 625         if (!active)
 626                 return 0;
 627
 628         if (new_client->pwr_state == VGA_SWITCHEROO_OFF)
 629                 vga_switchon(new_client);
 630
 631         vga_set_default_device(new_client->pdev);
 632         return 0;
 633 }
 634
 635 /* post delay */
 636 static int vga_switchto_stage2(struct vga_switcheroo_client *new_client)
 637 {
 638         int ret;
 639         struct vga_switcheroo_client *active;
 640
 641         active = find_active_client(&vgasr_priv.clients);
 642         if (!active)
 643                 return 0;
 644
 645         active->active = false;
 646
 647         set_audio_state(active->id, VGA_SWITCHEROO_OFF);
 648
 649         if (new_client->fb_info) {
 650                 struct fb_event event;
 651
 652                 console_lock();
 653                 event.info = new_client->fb_info;
 654                 fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event);
 655                 console_unlock();
 656         }
 657
 658         mutex_lock(&vgasr_priv.mux_hw_lock);
 659         ret = vgasr_priv.handler->switchto(new_client->id);
 660         mutex_unlock(&vgasr_priv.mux_hw_lock);
 661         if (ret)
 662                 return ret;
 663
 664         if (new_client->ops->reprobe)
 665                 new_client->ops->reprobe(new_client->pdev);
 666
 667         if (active->pwr_state == VGA_SWITCHEROO_ON)
 668                 vga_switchoff(active);
 669
 670         set_audio_state(new_client->id, VGA_SWITCHEROO_ON);
 671
 672         new_client->active = true;
 673         return 0;
 674 }
 675
 676 static bool check_can_switch(void)
 677 {
 678         struct vga_switcheroo_client *client;
 679
 680         list_for_each_entry(client, &vgasr_priv.clients, list) {
 681                 if (!client->ops->can_switch(client->pdev)) {
 682                         pr_err("client %x refused switch\n", client->id);
 683                         return false;
 684                 }
 685         }
 686         return true;
 687 }
 688
 689 static ssize_t
 690 vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
 691                              size_t cnt, loff_t *ppos)
 692 {
 693         char usercmd[64];
 694         int ret;
 695         bool delay = false, can_switch;
 696         bool just_mux = false;
 697         enum vga_switcheroo_client_id client_id = VGA_SWITCHEROO_UNKNOWN_ID;
 698         struct vga_switcheroo_client *client = NULL;
 699
 700         if (cnt > 63)
 701                 cnt = 63;
 702
 703         if (copy_from_user(usercmd, ubuf, cnt))
 704                 return -EFAULT;
 705
 706         mutex_lock(&vgasr_mutex);
 707
 708         if (!vgasr_priv.active) {
 709                 cnt = -EINVAL;
 710                 goto out;
 711         }
 712
 713         /* pwr off the device not in use */
 714         if (strncmp(usercmd, "OFF", 3) == 0) {
 715                 list_for_each_entry(client, &vgasr_priv.clients, list) {
 716                         if (client->active || client_is_audio(client))
 717                                 continue;
 718                         if (client->driver_power_control)
 719                                 continue;
 720                         set_audio_state(client->id, VGA_SWITCHEROO_OFF);
 721                         if (client->pwr_state == VGA_SWITCHEROO_ON)
 722                                 vga_switchoff(client);
 723                 }
 724                 goto out;
 725         }
 726         /* pwr on the device not in use */
 727         if (strncmp(usercmd, "ON", 2) == 0) {
 728                 list_for_each_entry(client, &vgasr_priv.clients, list) {
 729                         if (client->active || client_is_audio(client))
 730                                 continue;
 731                         if (client->driver_power_control)
 732                                 continue;
 733                         if (client->pwr_state == VGA_SWITCHEROO_OFF)
 734                                 vga_switchon(client);
 735                         set_audio_state(client->id, VGA_SWITCHEROO_ON);
 736                 }
 737                 goto out;
 738         }
 739
 740         /* request a delayed switch - test can we switch now */
 741         if (strncmp(usercmd, "DIGD", 4) == 0) {
 742                 client_id = VGA_SWITCHEROO_IGD;
 743                 delay = true;
 744         }
 745
 746         if (strncmp(usercmd, "DDIS", 4) == 0) {
 747                 client_id = VGA_SWITCHEROO_DIS;
 748                 delay = true;
 749         }
 750
 751         if (strncmp(usercmd, "IGD", 3) == 0)
 752                 client_id = VGA_SWITCHEROO_IGD;
 753
 754         if (strncmp(usercmd, "DIS", 3) == 0)
 755                 client_id = VGA_SWITCHEROO_DIS;
 756
 757         if (strncmp(usercmd, "MIGD", 4) == 0) {
 758                 just_mux = true;
 759                 client_id = VGA_SWITCHEROO_IGD;
 760         }
 761         if (strncmp(usercmd, "MDIS", 4) == 0) {
 762                 just_mux = true;
 763                 client_id = VGA_SWITCHEROO_DIS;
 764         }
 765
 766         if (client_id == VGA_SWITCHEROO_UNKNOWN_ID)
 767                 goto out;
 768         client = find_client_from_id(&vgasr_priv.clients, client_id);
 769         if (!client)
 770                 goto out;
 771
 772         vgasr_priv.delayed_switch_active = false;
 773
 774         if (just_mux) {
 775                 mutex_lock(&vgasr_priv.mux_hw_lock);
 776                 ret = vgasr_priv.handler->switchto(client_id);
 777                 mutex_unlock(&vgasr_priv.mux_hw_lock);
 778                 goto out;
 779         }
 780
 781         if (client->active)
 782                 goto out;
 783
 784         /* okay we want a switch - test if devices are willing to switch */
 785         can_switch = check_can_switch();
 786
 787         if (can_switch == false && delay == false)
 788                 goto out;
 789
 790         if (can_switch) {
 791                 ret = vga_switchto_stage1(client);
 792                 if (ret)
 793                         pr_err("switching failed stage 1 %d\n", ret);
 794
 795                 ret = vga_switchto_stage2(client);
 796                 if (ret)
 797                         pr_err("switching failed stage 2 %d\n", ret);
 798
 799         } else {
 800                 pr_info("setting delayed switch to client %d\n", client->id);
 801                 vgasr_priv.delayed_switch_active = true;
 802                 vgasr_priv.delayed_client_id = client_id;
 803
 804                 ret = vga_switchto_stage1(client);
 805                 if (ret)
 806                         pr_err("delayed switching stage 1 failed %d\n", ret);
 807         }
 808
 809 out:
 810         mutex_unlock(&vgasr_mutex);
 811         return cnt;
 812 }
 813
 814 static const struct file_operations vga_switcheroo_debugfs_fops = {
 815         .owner = THIS_MODULE,
 816         .open = vga_switcheroo_debugfs_open,
 817         .write = vga_switcheroo_debugfs_write,
 818         .read = seq_read,
 819         .llseek = seq_lseek,
 820         .release = single_release,
 821 };
 822
 823 static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv)
 824 {
 825         debugfs_remove(priv->switch_file);
 826         priv->switch_file = NULL;
 827
 828         debugfs_remove(priv->debugfs_root);
 829         priv->debugfs_root = NULL;
 830 }
 831
 832 static int vga_switcheroo_debugfs_init(struct vgasr_priv *priv)
 833 {
 834         static const char mp[] = "/sys/kernel/debug";
 835
 836         /* already initialised */
 837         if (priv->debugfs_root)
 838                 return 0;
 839         priv->debugfs_root = debugfs_create_dir("vgaswitcheroo", NULL);
 840
 841         if (!priv->debugfs_root) {
 842                 pr_err("Cannot create %s/vgaswitcheroo\n", mp);
 843                 goto fail;
 844         }
 845
 846         priv->switch_file = debugfs_create_file("switch", 0644,
 847                                                 priv->debugfs_root, NULL,
 848                                                 &vga_switcheroo_debugfs_fops);
 849         if (!priv->switch_file) {
 850                 pr_err("cannot create %s/vgaswitcheroo/switch\n", mp);
 851                 goto fail;
 852         }
 853         return 0;
 854 fail:
 855         vga_switcheroo_debugfs_fini(priv);
 856         return -1;
 857 }
 858
 859 /**
 860  * vga_switcheroo_process_delayed_switch() - helper for delayed switching
 861  *
 862  * Process a delayed switch if one is pending. DRM drivers should call this
 863  * from their ->lastclose callback.
 864  *
 865  * Return: 0 on success. -EINVAL if no delayed switch is pending, if the client
 866  * has unregistered in the meantime or if there are other clients blocking the
 867  * switch. If the actual switch fails, an error is reported and 0 is returned.
 868  */
 869 int vga_switcheroo_process_delayed_switch(void)
 870 {
 871         struct vga_switcheroo_client *client;
 872         int ret;
 873         int err = -EINVAL;
 874
 875         mutex_lock(&vgasr_mutex);
 876         if (!vgasr_priv.delayed_switch_active)
 877                 goto err;
 878
 879         pr_info("processing delayed switch to %d\n",
 880                 vgasr_priv.delayed_client_id);
 881
 882         client = find_client_from_id(&vgasr_priv.clients,
 883                                      vgasr_priv.delayed_client_id);
 884         if (!client || !check_can_switch())
 885                 goto err;
 886
 887         ret = vga_switchto_stage2(client);
 888         if (ret)
 889                 pr_err("delayed switching failed stage 2 %d\n", ret);
 890
 891         vgasr_priv.delayed_switch_active = false;
 892         err = 0;
 893 err:
 894         mutex_unlock(&vgasr_mutex);
 895         return err;
 896 }
 897 EXPORT_SYMBOL(vga_switcheroo_process_delayed_switch);
 898
 899 /**
 900  * DOC: Driver power control
 901  *
 902  * In this mode of use, the discrete GPU automatically powers up and down at
 903  * the discretion of the driver's runtime pm. On muxed machines, the user may
 904  * still influence the muxer state by way of the debugfs interface, however
 905  * the ON and OFF commands become a no-op for the discrete GPU.
 906  *
 907  * This mode is the default on Nvidia HybridPower/Optimus and ATI PowerXpress.
 908  * Specifying nouveau.runpm=0, radeon.runpm=0 or amdgpu.runpm=0 on the kernel
 909  * command line disables it.
 910  *
 911  * When the driver decides to power up or down, it notifies vga_switcheroo
 912  * thereof so that it can (a) power the audio device on the GPU up or down,
 913  * and (b) update its internal power state representation for the device.
 914  * This is achieved by vga_switcheroo_set_dynamic_switch().
 915  *
 916  * After the GPU has been suspended, the handler needs to be called to cut
 917  * power to the GPU. Likewise it needs to reinstate power before the GPU
 918  * can resume. This is achieved by vga_switcheroo_init_domain_pm_ops(),
 919  * which augments the GPU's suspend/resume functions by the requisite
 920  * calls to the handler.
 921  *
 922  * When the audio device resumes, the GPU needs to be woken. This is achieved
 923  * by vga_switcheroo_init_domain_pm_optimus_hdmi_audio(), which augments the
 924  * audio device's resume function.
 925  *
 926  * On muxed machines, if the mux is initially switched to the discrete GPU,
 927  * the user ends up with a black screen when the GPU powers down after boot.
 928  * As a workaround, the mux is forced to the integrated GPU on runtime suspend,
 929  * cf. https://bugs.freedesktop.org/show_bug.cgi?id=75917
 930  */
 931
 932 static void vga_switcheroo_power_switch(struct pci_dev *pdev,
 933                                         enum vga_switcheroo_state state)
 934 {
 935         struct vga_switcheroo_client *client;
 936
 937         if (!vgasr_priv.handler->power_state)
 938                 return;
 939
 940         client = find_client_from_pci(&vgasr_priv.clients, pdev);
 941         if (!client)
 942                 return;
 943
 944         if (!client->driver_power_control)
 945                 return;
 946
 947         vgasr_priv.handler->power_state(client->id, state);
 948 }
 949
 950 /**
 951  * vga_switcheroo_set_dynamic_switch() - helper for driver power control
 952  * @pdev: client pci device
 953  * @dynamic: new power state
 954  *
 955  * Helper for GPUs whose power state is controlled by the driver's runtime pm.
 956  * When the driver decides to power up or down, it notifies vga_switcheroo
 957  * thereof using this helper so that it can (a) power the audio device on
 958  * the GPU up or down, and (b) update its internal power state representation
 959  * for the device.
 960  */
 961 void vga_switcheroo_set_dynamic_switch(struct pci_dev *pdev,
 962                                        enum vga_switcheroo_state dynamic)
 963 {
 964         struct vga_switcheroo_client *client;
 965
 966         mutex_lock(&vgasr_mutex);
 967         client = find_client_from_pci(&vgasr_priv.clients, pdev);
 968         if (!client || !client->driver_power_control) {
 969                 mutex_unlock(&vgasr_mutex);
 970                 return;
 971         }
 972
 973         client->pwr_state = dynamic;
 974         set_audio_state(client->id, dynamic);
 975         mutex_unlock(&vgasr_mutex);
 976 }
 977 EXPORT_SYMBOL(vga_switcheroo_set_dynamic_switch);
 978
 979 /* switcheroo power domain */
 980 static int vga_switcheroo_runtime_suspend(struct device *dev)
 981 {
 982         struct pci_dev *pdev = to_pci_dev(dev);
 983         int ret;
 984
 985         ret = dev->bus->pm->runtime_suspend(dev);
 986         if (ret)
 987                 return ret;
 988         mutex_lock(&vgasr_mutex);
 989         if (vgasr_priv.handler->switchto) {
 990                 mutex_lock(&vgasr_priv.mux_hw_lock);
 991                 vgasr_priv.handler->switchto(VGA_SWITCHEROO_IGD);
 992                 mutex_unlock(&vgasr_priv.mux_hw_lock);
 993         }
 994         vga_switcheroo_power_switch(pdev, VGA_SWITCHEROO_OFF);
 995         mutex_unlock(&vgasr_mutex);
 996         return 0;
 997 }
 998
 999 static int vga_switcheroo_runtime_resume(struct device *dev)
1000 {
1001         struct pci_dev *pdev = to_pci_dev(dev);
1002         int ret;
1003
1004         mutex_lock(&vgasr_mutex);
1005         vga_switcheroo_power_switch(pdev, VGA_SWITCHEROO_ON);
1006         mutex_unlock(&vgasr_mutex);
1007         ret = dev->bus->pm->runtime_resume(dev);
1008         if (ret)
1009                 return ret;
1010
1011         return 0;
1012 }
1013
1014 /**
1015  * vga_switcheroo_init_domain_pm_ops() - helper for driver power control
1016  * @dev: vga client device
1017  * @domain: power domain
1018  *
1019  * Helper for GPUs whose power state is controlled by the driver's runtime pm.
1020  * After the GPU has been suspended, the handler needs to be called to cut
1021  * power to the GPU. Likewise it needs to reinstate power before the GPU
1022  * can resume. To this end, this helper augments the suspend/resume functions
1023  * by the requisite calls to the handler. It needs only be called on platforms
1024  * where the power switch is separate to the device being powered down.
1025  */
1026 int vga_switcheroo_init_domain_pm_ops(struct device *dev,
1027                                       struct dev_pm_domain *domain)
1028 {
1029         /* copy over all the bus versions */
1030         if (dev->bus && dev->bus->pm) {
1031                 domain->ops = *dev->bus->pm;
1032                 domain->ops.runtime_suspend = vga_switcheroo_runtime_suspend;
1033                 domain->ops.runtime_resume = vga_switcheroo_runtime_resume;
1034
1035                 dev_pm_domain_set(dev, domain);
1036                 return 0;
1037         }
1038         dev_pm_domain_set(dev, NULL);
1039         return -EINVAL;
1040 }
1041 EXPORT_SYMBOL(vga_switcheroo_init_domain_pm_ops);
1042
1043 void vga_switcheroo_fini_domain_pm_ops(struct device *dev)
1044 {
1045         dev_pm_domain_set(dev, NULL);
1046 }
1047 EXPORT_SYMBOL(vga_switcheroo_fini_domain_pm_ops);
1048
1049 static int vga_switcheroo_runtime_resume_hdmi_audio(struct device *dev)
1050 {
1051         struct pci_dev *pdev = to_pci_dev(dev);
1052         struct vga_switcheroo_client *client;
1053         struct device *video_dev = NULL;
1054         int ret;
1055
1056         /* we need to check if we have to switch back on the video
1057            device so the audio device can come back */
1058         mutex_lock(&vgasr_mutex);
1059         list_for_each_entry(client, &vgasr_priv.clients, list) {
1060                 if (PCI_SLOT(client->pdev->devfn) == PCI_SLOT(pdev->devfn) &&
1061                     client_is_vga(client)) {
1062                         video_dev = &client->pdev->dev;
1063                         break;
1064                 }
1065         }
1066         mutex_unlock(&vgasr_mutex);
1067
1068         if (video_dev) {
1069                 ret = pm_runtime_get_sync(video_dev);
1070                 if (ret && ret != 1)
1071                         return ret;
1072         }
1073         ret = dev->bus->pm->runtime_resume(dev);
1074
1075         /* put the reference for the gpu */
1076         if (video_dev) {
1077                 pm_runtime_mark_last_busy(video_dev);
1078                 pm_runtime_put_autosuspend(video_dev);
1079         }
1080         return ret;
1081 }
1082
1083 /**
1084  * vga_switcheroo_init_domain_pm_optimus_hdmi_audio() - helper for driver
1085  *      power control
1086  * @dev: audio client device
1087  * @domain: power domain
1088  *
1089  * Helper for GPUs whose power state is controlled by the driver's runtime pm.
1090  * When the audio device resumes, the GPU needs to be woken. This helper
1091  * augments the audio device's resume function to do that.
1092  *
1093  * Return: 0 on success, -EINVAL if no power management operations are
1094  * defined for this device.
1095  */
1096 int
1097 vga_switcheroo_init_domain_pm_optimus_hdmi_audio(struct device *dev,
1098                                                  struct dev_pm_domain *domain)
1099 {
1100         /* copy over all the bus versions */
1101         if (dev->bus && dev->bus->pm) {
1102                 domain->ops = *dev->bus->pm;
1103                 domain->ops.runtime_resume =
1104                         vga_switcheroo_runtime_resume_hdmi_audio;
1105
1106                 dev_pm_domain_set(dev, domain);
1107                 return 0;
1108         }
1109         dev_pm_domain_set(dev, NULL);
1110         return -EINVAL;
1111 }
1112 EXPORT_SYMBOL(vga_switcheroo_init_domain_pm_optimus_hdmi_audio);