/* * vga_switcheroo.c - Support for laptop with dual GPU using one set of outputs * * Copyright (c) 2010 Red Hat Inc. * Author : Dave Airlie <[email protected]> * * Copyright (c) 2015 Lukas Wunner <[email protected]> * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS * IN THE SOFTWARE. * */ #define pr_fmt(fmt) … #include <linux/apple-gmux.h> #include <linux/console.h> #include <linux/debugfs.h> #include <linux/fb.h> #include <linux/fs.h> #include <linux/fbcon.h> #include <linux/module.h> #include <linux/pci.h> #include <linux/pm_domain.h> #include <linux/pm_runtime.h> #include <linux/seq_file.h> #include <linux/uaccess.h> #include <linux/vgaarb.h> #include <linux/vga_switcheroo.h> /** * DOC: Overview * * vga_switcheroo is the Linux subsystem for laptop hybrid graphics. * These come in two flavors: * * * muxed: Dual GPUs with a multiplexer chip to switch outputs between GPUs. * * muxless: Dual GPUs but only one of them is connected to outputs. * The other one is merely used to offload rendering, its results * are copied over PCIe into the framebuffer. On Linux this is * supported with DRI PRIME. * * Hybrid graphics started to appear in the late Naughties and were initially * all muxed. Newer laptops moved to a muxless architecture for cost reasons. * A notable exception is the MacBook Pro which continues to use a mux. * Muxes come with varying capabilities: Some switch only the panel, others * can also switch external displays. Some switch all display pins at once * while others can switch just the DDC lines. (To allow EDID probing * for the inactive GPU.) Also, muxes are often used to cut power to the * discrete GPU while it is not used. * * DRM drivers register GPUs with vga_switcheroo, these are henceforth called * clients. The mux is called the handler. Muxless machines also register a * handler to control the power state of the discrete GPU, its ->switchto * callback is a no-op for obvious reasons. The discrete GPU is often equipped * with an HDA controller for the HDMI/DP audio signal, this will also * register as a client so that vga_switcheroo can take care of the correct * suspend/resume order when changing the discrete GPU's power state. In total * there can thus be up to three clients: Two vga clients (GPUs) and one audio * client (on the discrete GPU). The code is mostly prepared to support * machines with more than two GPUs should they become available. * * The GPU to which the outputs are currently switched is called the * active client in vga_switcheroo parlance. The GPU not in use is the * inactive client. When the inactive client's DRM driver is loaded, * it will be unable to probe the panel's EDID and hence depends on * VBIOS to provide its display modes. If the VBIOS modes are bogus or * if there is no VBIOS at all (which is common on the MacBook Pro), * a client may alternatively request that the DDC lines are temporarily * switched to it, provided that the handler supports this. Switching * only the DDC lines and not the entire output avoids unnecessary * flickering. */ /** * struct vga_switcheroo_client - registered client * @pdev: client pci device * @fb_info: framebuffer to which console is remapped on switching * @pwr_state: current power state if manual power control is used. * For driver power control, call vga_switcheroo_pwr_state(). * @ops: client callbacks * @id: client identifier. Determining the id requires the handler, * so gpus are initially assigned VGA_SWITCHEROO_UNKNOWN_ID * and later given their true id in vga_switcheroo_enable() * @active: whether the outputs are currently switched to this client * @driver_power_control: whether power state is controlled by the driver's * runtime pm. If true, writing ON and OFF to the vga_switcheroo debugfs * interface is a no-op so as not to interfere with runtime pm * @list: client list * @vga_dev: pci device, indicate which GPU is bound to current audio client * * Registered client. A client can be either a GPU or an audio device on a GPU. * For audio clients, the @fb_info and @active members are bogus. For GPU * clients, the @vga_dev is bogus. */ struct vga_switcheroo_client { … }; /* * protects access to struct vgasr_priv */ static DEFINE_MUTEX(vgasr_mutex); /** * struct vgasr_priv - vga_switcheroo private data * @active: whether vga_switcheroo is enabled. * Prerequisite is the registration of two GPUs and a handler * @delayed_switch_active: whether a delayed switch is pending * @delayed_client_id: client to which a delayed switch is pending * @debugfs_root: directory for vga_switcheroo debugfs interface * @registered_clients: number of registered GPUs * (counting only vga clients, not audio clients) * @clients: list of registered clients * @handler: registered handler * @handler_flags: flags of registered handler * @mux_hw_lock: protects mux state * (in particular while DDC lines are temporarily switched) * @old_ddc_owner: client to which DDC lines will be switched back on unlock * * vga_switcheroo private data. Currently only one vga_switcheroo instance * per system is supported. */ struct vgasr_priv { … }; #define ID_BIT_AUDIO … #define client_is_audio(c) … #define client_is_vga(c) … #define client_id(c) … static void vga_switcheroo_debugfs_init(struct vgasr_priv *priv); static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv); /* only one switcheroo per system */ static struct vgasr_priv vgasr_priv = …; static bool vga_switcheroo_ready(void) { … } static void vga_switcheroo_enable(void) { … } /** * vga_switcheroo_register_handler() - register handler * @handler: handler callbacks * @handler_flags: handler flags * * Register handler. Enable vga_switcheroo if two vga clients have already * registered. * * Return: 0 on success, -EINVAL if a handler was already registered. */ int vga_switcheroo_register_handler( const struct vga_switcheroo_handler *handler, enum vga_switcheroo_handler_flags_t handler_flags) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_unregister_handler() - unregister handler * * Unregister handler. Disable vga_switcheroo. */ void vga_switcheroo_unregister_handler(void) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_handler_flags() - obtain handler flags * * Helper for clients to obtain the handler flags bitmask. * * Return: Handler flags. A value of 0 means that no handler is registered * or that the handler has no special capabilities. */ enum vga_switcheroo_handler_flags_t vga_switcheroo_handler_flags(void) { … } EXPORT_SYMBOL(…); static int register_client(struct pci_dev *pdev, const struct vga_switcheroo_client_ops *ops, enum vga_switcheroo_client_id id, struct pci_dev *vga_dev, bool active, bool driver_power_control) { … } /** * vga_switcheroo_register_client - register vga client * @pdev: client pci device * @ops: client callbacks * @driver_power_control: whether power state is controlled by the driver's * runtime pm * * Register vga client (GPU). Enable vga_switcheroo if another GPU and a * handler have already registered. The power state of the client is assumed * to be ON. Beforehand, vga_switcheroo_client_probe_defer() shall be called * to ensure that all prerequisites are met. * * Return: 0 on success, -ENOMEM on memory allocation error. */ int vga_switcheroo_register_client(struct pci_dev *pdev, const struct vga_switcheroo_client_ops *ops, bool driver_power_control) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_register_audio_client - register audio client * @pdev: client pci device * @ops: client callbacks * @vga_dev: pci device which is bound to current audio client * * Register audio client (audio device on a GPU). The client is assumed * to use runtime PM. Beforehand, vga_switcheroo_client_probe_defer() * shall be called to ensure that all prerequisites are met. * * Return: 0 on success, -ENOMEM on memory allocation error, -EINVAL on getting * client id error. */ int vga_switcheroo_register_audio_client(struct pci_dev *pdev, const struct vga_switcheroo_client_ops *ops, struct pci_dev *vga_dev) { … } EXPORT_SYMBOL(…); static struct vga_switcheroo_client * find_client_from_pci(struct list_head *head, struct pci_dev *pdev) { … } static struct vga_switcheroo_client * find_client_from_id(struct list_head *head, enum vga_switcheroo_client_id client_id) { … } static struct vga_switcheroo_client * find_active_client(struct list_head *head) { … } /** * vga_switcheroo_client_probe_defer() - whether to defer probing a given client * @pdev: client pci device * * Determine whether any prerequisites are not fulfilled to probe a given * client. Drivers shall invoke this early on in their ->probe callback * and return %-EPROBE_DEFER if it evaluates to %true. Thou shalt not * register the client ere thou hast called this. * * Return: %true if probing should be deferred, otherwise %false. */ bool vga_switcheroo_client_probe_defer(struct pci_dev *pdev) { … } EXPORT_SYMBOL(…); static enum vga_switcheroo_state vga_switcheroo_pwr_state(struct vga_switcheroo_client *client) { … } /** * vga_switcheroo_get_client_state() - obtain power state of a given client * @pdev: client pci device * * Obtain power state of a given client as seen from vga_switcheroo. * The function is only called from hda_intel.c. * * Return: Power state. */ enum vga_switcheroo_state vga_switcheroo_get_client_state(struct pci_dev *pdev) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_unregister_client() - unregister client * @pdev: client pci device * * Unregister client. Disable vga_switcheroo if this is a vga client (GPU). */ void vga_switcheroo_unregister_client(struct pci_dev *pdev) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_client_fb_set() - set framebuffer of a given client * @pdev: client pci device * @info: framebuffer * * Set framebuffer of a given client. The console will be remapped to this * on switching. */ void vga_switcheroo_client_fb_set(struct pci_dev *pdev, struct fb_info *info) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_lock_ddc() - temporarily switch DDC lines to a given client * @pdev: client pci device * * Temporarily switch DDC lines to the client identified by @pdev * (but leave the outputs otherwise switched to where they are). * This allows the inactive client to probe EDID. The DDC lines must * afterwards be switched back by calling vga_switcheroo_unlock_ddc(), * even if this function returns an error. * * Return: Previous DDC owner on success or a negative int on error. * Specifically, %-ENODEV if no handler has registered or if the handler * does not support switching the DDC lines. Also, a negative value * returned by the handler is propagated back to the caller. * The return value has merely an informational purpose for any caller * which might be interested in it. It is acceptable to ignore the return * value and simply rely on the result of the subsequent EDID probe, * which will be %NULL if DDC switching failed. */ int vga_switcheroo_lock_ddc(struct pci_dev *pdev) { … } EXPORT_SYMBOL(…); /** * vga_switcheroo_unlock_ddc() - switch DDC lines back to previous owner * @pdev: client pci device * * Switch DDC lines back to the previous owner after calling * vga_switcheroo_lock_ddc(). This must be called even if * vga_switcheroo_lock_ddc() returned an error. * * Return: Previous DDC owner on success (i.e. the client identifier of @pdev) * or a negative int on error. * Specifically, %-ENODEV if no handler has registered or if the handler * does not support switching the DDC lines. Also, a negative value * returned by the handler is propagated back to the caller. * Finally, invoking this function without calling vga_switcheroo_lock_ddc() * first is not allowed and will result in %-EINVAL. */ int vga_switcheroo_unlock_ddc(struct pci_dev *pdev) { … } EXPORT_SYMBOL(…); /** * DOC: Manual switching and manual power control * * In this mode of use, the file /sys/kernel/debug/vgaswitcheroo/switch * can be read to retrieve the current vga_switcheroo state and commands * can be written to it to change the state. The file appears as soon as * two GPU drivers and one handler have registered with vga_switcheroo. * The following commands are understood: * * * OFF: Power off the device not in use. * * ON: Power on the device not in use. * * IGD: Switch to the integrated graphics device. * Power on the integrated GPU if necessary, power off the discrete GPU. * Prerequisite is that no user space processes (e.g. Xorg, alsactl) * have opened device files of the GPUs or the audio client. If the * switch fails, the user may invoke lsof(8) or fuser(1) on /dev/dri/ * and /dev/snd/controlC1 to identify processes blocking the switch. * * DIS: Switch to the discrete graphics device. * * DIGD: Delayed switch to the integrated graphics device. * This will perform the switch once the last user space process has * closed the device files of the GPUs and the audio client. * * DDIS: Delayed switch to the discrete graphics device. * * MIGD: Mux-only switch to the integrated graphics device. * Does not remap console or change the power state of either gpu. * If the integrated GPU is currently off, the screen will turn black. * If it is on, the screen will show whatever happens to be in VRAM. * Either way, the user has to blindly enter the command to switch back. * * MDIS: Mux-only switch to the discrete graphics device. * * For GPUs whose power state is controlled by the driver's runtime pm, * the ON and OFF commands are a no-op (see next section). * * For muxless machines, the IGD/DIS, DIGD/DDIS and MIGD/MDIS commands * should not be used. */ static int vga_switcheroo_show(struct seq_file *m, void *v) { … } static int vga_switcheroo_debugfs_open(struct inode *inode, struct file *file) { … } static int vga_switchon(struct vga_switcheroo_client *client) { … } static int vga_switchoff(struct vga_switcheroo_client *client) { … } static void set_audio_state(enum vga_switcheroo_client_id id, enum vga_switcheroo_state state) { … } /* stage one happens before delay */ static int vga_switchto_stage1(struct vga_switcheroo_client *new_client) { … } /* post delay */ static int vga_switchto_stage2(struct vga_switcheroo_client *new_client) { … } static bool check_can_switch(void) { … } static ssize_t vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { … } static const struct file_operations vga_switcheroo_debugfs_fops = …; static void vga_switcheroo_debugfs_fini(struct vgasr_priv *priv) { … } static void vga_switcheroo_debugfs_init(struct vgasr_priv *priv) { … } /** * vga_switcheroo_process_delayed_switch() - helper for delayed switching * * Process a delayed switch if one is pending. * * Return: 0 on success. -EINVAL if no delayed switch is pending, if the client * has unregistered in the meantime or if there are other clients blocking the * switch. If the actual switch fails, an error is reported and 0 is returned. */ int vga_switcheroo_process_delayed_switch(void) { … } EXPORT_SYMBOL(…); /** * DOC: Driver power control * * In this mode of use, the discrete GPU automatically powers up and down at * the discretion of the driver's runtime pm. On muxed machines, the user may * still influence the muxer state by way of the debugfs interface, however * the ON and OFF commands become a no-op for the discrete GPU. * * This mode is the default on Nvidia HybridPower/Optimus and ATI PowerXpress. * Specifying nouveau.runpm=0, radeon.runpm=0 or amdgpu.runpm=0 on the kernel * command line disables it. * * After the GPU has been suspended, the handler needs to be called to cut * power to the GPU. Likewise it needs to reinstate power before the GPU * can resume. This is achieved by vga_switcheroo_init_domain_pm_ops(), * which augments the GPU's suspend/resume functions by the requisite * calls to the handler. * * When the audio device resumes, the GPU needs to be woken. This is achieved * by a PCI quirk which calls device_link_add() to declare a dependency on the * GPU. That way, the GPU is kept awake whenever and as long as the audio * device is in use. * * On muxed machines, if the mux is initially switched to the discrete GPU, * the user ends up with a black screen when the GPU powers down after boot. * As a workaround, the mux is forced to the integrated GPU on runtime suspend, * cf. https://bugs.freedesktop.org/show_bug.cgi?id=75917 */ static void vga_switcheroo_power_switch(struct pci_dev *pdev, enum vga_switcheroo_state state) { … } /* switcheroo power domain */ static int vga_switcheroo_runtime_suspend(struct device *dev) { … } static int vga_switcheroo_runtime_resume(struct device *dev) { … } /** * vga_switcheroo_init_domain_pm_ops() - helper for driver power control * @dev: vga client device * @domain: power domain * * Helper for GPUs whose power state is controlled by the driver's runtime pm. * After the GPU has been suspended, the handler needs to be called to cut * power to the GPU. Likewise it needs to reinstate power before the GPU * can resume. To this end, this helper augments the suspend/resume functions * by the requisite calls to the handler. It needs only be called on platforms * where the power switch is separate to the device being powered down. */ int vga_switcheroo_init_domain_pm_ops(struct device *dev, struct dev_pm_domain *domain) { … } EXPORT_SYMBOL(…); void vga_switcheroo_fini_domain_pm_ops(struct device *dev) { … } EXPORT_SYMBOL(…);
Codebase Browser
linux