drivers/gpu/drm/gma500/power.c

   1 /**************************************************************************
   2  * Copyright (c) 2009-2011, Intel Corporation.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  * Authors:
  25  *    Benjamin Defnet <benjamin.r.defnet@intel.com>
  26  *    Rajesh Poornachandran <rajesh.poornachandran@intel.com>
  27  * Massively reworked
  28  *    Alan Cox <alan@linux.intel.com>
  29  */
  30
  31 #include "gem.h"
  32 #include "power.h"
  33 #include "psb_drv.h"
  34 #include "psb_reg.h"
  35 #include "psb_intel_reg.h"
  36 #include "psb_irq.h"
  37 #include <linux/mutex.h>
  38 #include <linux/pm_runtime.h>
  39
  40 /**
  41  *      gma_power_init          -       initialise power manager
  42  *      @dev: our device
  43  *
  44  *      Set up for power management tracking of our hardware.
  45  */
  46 void gma_power_init(struct drm_device *dev)
  47 {
  48         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
  49
  50         /* FIXME: Move APM/OSPM base into relevant device code */
  51         dev_priv->apm_base = dev_priv->apm_reg & 0xffff;
  52         dev_priv->ospm_base &= 0xffff;
  53
  54         if (dev_priv->ops->init_pm)
  55                 dev_priv->ops->init_pm(dev);
  56
  57         /*
  58          * Runtime pm support is broken atm. So for now unconditionally
  59          * call pm_runtime_get() here and put it again in psb_driver_unload()
  60          *
  61          * To fix this we need to call pm_runtime_get() once for each active
  62          * pipe at boot and then put() / get() for each pipe disable / enable
  63          * so that the device gets runtime suspended when no pipes are active.
  64          * Once this is in place the pm_runtime_get() below should be replaced
  65          * by a pm_runtime_allow() call to undo the pm_runtime_forbid() from
  66          * pci_pm_init().
  67          */
  68         pm_runtime_get(dev->dev);
  69
  70         dev_priv->pm_initialized = true;
  71 }
  72
  73 /**
  74  *      gma_power_uninit        -       end power manager
  75  *      @dev: device to end for
  76  *
  77  *      Undo the effects of gma_power_init
  78  */
  79 void gma_power_uninit(struct drm_device *dev)
  80 {
  81         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
  82
  83         if (!dev_priv->pm_initialized)
  84                 return;
  85
  86         pm_runtime_put_noidle(dev->dev);
  87 }
  88
  89 /**
  90  *      gma_suspend_display     -       suspend the display logic
  91  *      @dev: our DRM device
  92  *
  93  *      Suspend the display logic of the graphics interface
  94  */
  95 static void gma_suspend_display(struct drm_device *dev)
  96 {
  97         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
  98
  99         dev_priv->ops->save_regs(dev);
 100         dev_priv->ops->power_down(dev);
 101 }
 102
 103 /**
 104  *      gma_resume_display      -       resume display side logic
 105  *      @pdev: PCI device
 106  *
 107  *      Resume the display hardware restoring state and enabling
 108  *      as necessary.
 109  */
 110 static void gma_resume_display(struct pci_dev *pdev)
 111 {
 112         struct drm_device *dev = pci_get_drvdata(pdev);
 113         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
 114
 115         /* turn on the display power island */
 116         dev_priv->ops->power_up(dev);
 117
 118         PSB_WVDC32(dev_priv->pge_ctl | _PSB_PGETBL_ENABLED, PSB_PGETBL_CTL);
 119         pci_write_config_word(pdev, PSB_GMCH_CTRL,
 120                         dev_priv->gmch_ctrl | _PSB_GMCH_ENABLED);
 121
 122         /* Rebuild our GTT mappings */
 123         psb_gtt_resume(dev);
 124         psb_gem_mm_resume(dev);
 125         dev_priv->ops->restore_regs(dev);
 126 }
 127
 128 /**
 129  *      gma_suspend_pci         -       suspend PCI side
 130  *      @pdev: PCI device
 131  *
 132  *      Perform the suspend processing on our PCI device state
 133  */
 134 static void gma_suspend_pci(struct pci_dev *pdev)
 135 {
 136         struct drm_device *dev = pci_get_drvdata(pdev);
 137         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
 138         int bsm, vbt;
 139
 140         pci_save_state(pdev);
 141         pci_read_config_dword(pdev, 0x5C, &bsm);
 142         dev_priv->regs.saveBSM = bsm;
 143         pci_read_config_dword(pdev, 0xFC, &vbt);
 144         dev_priv->regs.saveVBT = vbt;
 145
 146         pci_disable_device(pdev);
 147         pci_set_power_state(pdev, PCI_D3hot);
 148 }
 149
 150 /**
 151  *      gma_resume_pci          -       resume helper
 152  *      @pdev: our PCI device
 153  *
 154  *      Perform the resume processing on our PCI device state - rewrite
 155  *      register state and re-enable the PCI device
 156  */
 157 static int gma_resume_pci(struct pci_dev *pdev)
 158 {
 159         struct drm_device *dev = pci_get_drvdata(pdev);
 160         struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
 161
 162         pci_set_power_state(pdev, PCI_D0);
 163         pci_restore_state(pdev);
 164         pci_write_config_dword(pdev, 0x5c, dev_priv->regs.saveBSM);
 165         pci_write_config_dword(pdev, 0xFC, dev_priv->regs.saveVBT);
 166
 167         return pci_enable_device(pdev);
 168 }
 169
 170 /**
 171  *      gma_power_suspend               -       bus callback for suspend
 172  *      @_dev: our device
 173  *
 174  *      Called back by the PCI layer during a suspend of the system. We
 175  *      perform the necessary shut down steps and save enough state that
 176  *      we can undo this when resume is called.
 177  */
 178 int gma_power_suspend(struct device *_dev)
 179 {
 180         struct pci_dev *pdev = to_pci_dev(_dev);
 181         struct drm_device *dev = pci_get_drvdata(pdev);
 182
 183         gma_irq_uninstall(dev);
 184         gma_suspend_display(dev);
 185         gma_suspend_pci(pdev);
 186         return 0;
 187 }
 188
 189 /**
 190  *      gma_power_resume                -       resume power
 191  *      @_dev: our device
 192  *
 193  *      Resume the PCI side of the graphics and then the displays
 194  */
 195 int gma_power_resume(struct device *_dev)
 196 {
 197         struct pci_dev *pdev = to_pci_dev(_dev);
 198         struct drm_device *dev = pci_get_drvdata(pdev);
 199
 200         gma_resume_pci(pdev);
 201         gma_resume_display(pdev);
 202         gma_irq_install(dev);
 203         return 0;
 204 }
 205
 206 /**
 207  *      gma_power_begin         -       begin requiring power
 208  *      @dev: our DRM device
 209  *      @force_on: true to force power on
 210  *
 211  *      Begin an action that requires the display power island is enabled.
 212  *      We refcount the islands.
 213  */
 214 bool gma_power_begin(struct drm_device *dev, bool force_on)
 215 {
 216         if (force_on)
 217                 return pm_runtime_resume_and_get(dev->dev) == 0;
 218         else
 219                 return pm_runtime_get_if_in_use(dev->dev) == 1;
 220 }
 221
 222 /**
 223  *      gma_power_end           -       end use of power
 224  *      @dev: Our DRM device
 225  *
 226  *      Indicate that one of our gma_power_begin() requested periods when
 227  *      the diplay island power is needed has completed.
 228  */
 229 void gma_power_end(struct drm_device *dev)
 230 {
 231         pm_runtime_put(dev->dev);
 232 }