xref: /linux/drivers/gpu/drm/gma500/power.c (revision 5c8166419acf468b5bc3e48f928a040485d3e0c2)
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 "power.h"
32 #include "psb_drv.h"
33 #include "psb_reg.h"
34 #include "psb_intel_reg.h"
35 #include "psb_irq.h"
36 #include <linux/mutex.h>
37 #include <linux/pm_runtime.h>
38 
39 static struct mutex power_mutex;	/* Serialize power ops */
40 static DEFINE_SPINLOCK(power_ctrl_lock);	/* Serialize power claim */
41 
42 /**
43  *	gma_power_init		-	initialise power manager
44  *	@dev: our device
45  *
46  *	Set up for power management tracking of our hardware.
47  */
48 void gma_power_init(struct drm_device *dev)
49 {
50 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
51 
52 	/* FIXME: Move APM/OSPM base into relevant device code */
53 	dev_priv->apm_base = dev_priv->apm_reg & 0xffff;
54 	dev_priv->ospm_base &= 0xffff;
55 
56 	dev_priv->display_power = true;	/* We start active */
57 	dev_priv->display_count = 0;	/* Currently no users */
58 	dev_priv->suspended = false;	/* And not suspended */
59 	mutex_init(&power_mutex);
60 
61 	if (dev_priv->ops->init_pm)
62 		dev_priv->ops->init_pm(dev);
63 }
64 
65 /**
66  *	gma_power_uninit	-	end power manager
67  *	@dev: device to end for
68  *
69  *	Undo the effects of gma_power_init
70  */
71 void gma_power_uninit(struct drm_device *dev)
72 {
73 	pm_runtime_disable(dev->dev);
74 	pm_runtime_set_suspended(dev->dev);
75 }
76 
77 /**
78  *	gma_suspend_display	-	suspend the display logic
79  *	@dev: our DRM device
80  *
81  *	Suspend the display logic of the graphics interface
82  */
83 static void gma_suspend_display(struct drm_device *dev)
84 {
85 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
86 
87 	if (dev_priv->suspended)
88 		return;
89 	dev_priv->ops->save_regs(dev);
90 	dev_priv->ops->power_down(dev);
91 	dev_priv->display_power = false;
92 }
93 
94 /**
95  *	gma_resume_display	-	resume display side logic
96  *	@pdev: PCI device
97  *
98  *	Resume the display hardware restoring state and enabling
99  *	as necessary.
100  */
101 static void gma_resume_display(struct pci_dev *pdev)
102 {
103 	struct drm_device *dev = pci_get_drvdata(pdev);
104 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
105 
106 	/* turn on the display power island */
107 	dev_priv->ops->power_up(dev);
108 	dev_priv->suspended = false;
109 	dev_priv->display_power = true;
110 
111 	PSB_WVDC32(dev_priv->pge_ctl | _PSB_PGETBL_ENABLED, PSB_PGETBL_CTL);
112 	pci_write_config_word(pdev, PSB_GMCH_CTRL,
113 			dev_priv->gmch_ctrl | _PSB_GMCH_ENABLED);
114 
115 	psb_gtt_restore(dev); /* Rebuild our GTT mappings */
116 	dev_priv->ops->restore_regs(dev);
117 }
118 
119 /**
120  *	gma_suspend_pci		-	suspend PCI side
121  *	@pdev: PCI device
122  *
123  *	Perform the suspend processing on our PCI device state
124  */
125 static void gma_suspend_pci(struct pci_dev *pdev)
126 {
127 	struct drm_device *dev = pci_get_drvdata(pdev);
128 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
129 	int bsm, vbt;
130 
131 	if (dev_priv->suspended)
132 		return;
133 
134 	pci_save_state(pdev);
135 	pci_read_config_dword(pdev, 0x5C, &bsm);
136 	dev_priv->regs.saveBSM = bsm;
137 	pci_read_config_dword(pdev, 0xFC, &vbt);
138 	dev_priv->regs.saveVBT = vbt;
139 	pci_read_config_dword(pdev, PSB_PCIx_MSI_ADDR_LOC, &dev_priv->msi_addr);
140 	pci_read_config_dword(pdev, PSB_PCIx_MSI_DATA_LOC, &dev_priv->msi_data);
141 
142 	pci_disable_device(pdev);
143 	pci_set_power_state(pdev, PCI_D3hot);
144 
145 	dev_priv->suspended = true;
146 }
147 
148 /**
149  *	gma_resume_pci		-	resume helper
150  *	@pdev: our PCI device
151  *
152  *	Perform the resume processing on our PCI device state - rewrite
153  *	register state and re-enable the PCI device
154  */
155 static bool gma_resume_pci(struct pci_dev *pdev)
156 {
157 	struct drm_device *dev = pci_get_drvdata(pdev);
158 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
159 	int ret;
160 
161 	if (!dev_priv->suspended)
162 		return true;
163 
164 	pci_set_power_state(pdev, PCI_D0);
165 	pci_restore_state(pdev);
166 	pci_write_config_dword(pdev, 0x5c, dev_priv->regs.saveBSM);
167 	pci_write_config_dword(pdev, 0xFC, dev_priv->regs.saveVBT);
168 	/* restoring MSI address and data in PCIx space */
169 	pci_write_config_dword(pdev, PSB_PCIx_MSI_ADDR_LOC, dev_priv->msi_addr);
170 	pci_write_config_dword(pdev, PSB_PCIx_MSI_DATA_LOC, dev_priv->msi_data);
171 	ret = pci_enable_device(pdev);
172 
173 	if (ret != 0)
174 		dev_err(&pdev->dev, "pci_enable failed: %d\n", ret);
175 	else
176 		dev_priv->suspended = false;
177 	return !dev_priv->suspended;
178 }
179 
180 /**
181  *	gma_power_suspend		-	bus callback for suspend
182  *	@_dev: our device
183  *
184  *	Called back by the PCI layer during a suspend of the system. We
185  *	perform the necessary shut down steps and save enough state that
186  *	we can undo this when resume is called.
187  */
188 int gma_power_suspend(struct device *_dev)
189 {
190 	struct pci_dev *pdev = to_pci_dev(_dev);
191 	struct drm_device *dev = pci_get_drvdata(pdev);
192 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
193 
194 	mutex_lock(&power_mutex);
195 	if (!dev_priv->suspended) {
196 		if (dev_priv->display_count) {
197 			mutex_unlock(&power_mutex);
198 			dev_err(dev->dev, "GPU hardware busy, cannot suspend\n");
199 			return -EBUSY;
200 		}
201 		psb_irq_uninstall(dev);
202 		gma_suspend_display(dev);
203 		gma_suspend_pci(pdev);
204 	}
205 	mutex_unlock(&power_mutex);
206 	return 0;
207 }
208 
209 /**
210  *	gma_power_resume		-	resume power
211  *	@_dev: our device
212  *
213  *	Resume the PCI side of the graphics and then the displays
214  */
215 int gma_power_resume(struct device *_dev)
216 {
217 	struct pci_dev *pdev = to_pci_dev(_dev);
218 	struct drm_device *dev = pci_get_drvdata(pdev);
219 
220 	mutex_lock(&power_mutex);
221 	gma_resume_pci(pdev);
222 	gma_resume_display(pdev);
223 	psb_irq_preinstall(dev);
224 	psb_irq_postinstall(dev);
225 	mutex_unlock(&power_mutex);
226 	return 0;
227 }
228 
229 /**
230  *	gma_power_is_on		-	returne true if power is on
231  *	@dev: our DRM device
232  *
233  *	Returns true if the display island power is on at this moment
234  */
235 bool gma_power_is_on(struct drm_device *dev)
236 {
237 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
238 	return dev_priv->display_power;
239 }
240 
241 /**
242  *	gma_power_begin		-	begin requiring power
243  *	@dev: our DRM device
244  *	@force_on: true to force power on
245  *
246  *	Begin an action that requires the display power island is enabled.
247  *	We refcount the islands.
248  */
249 bool gma_power_begin(struct drm_device *dev, bool force_on)
250 {
251 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
252 	struct pci_dev *pdev = to_pci_dev(dev->dev);
253 	int ret;
254 	unsigned long flags;
255 
256 	spin_lock_irqsave(&power_ctrl_lock, flags);
257 	/* Power already on ? */
258 	if (dev_priv->display_power) {
259 		dev_priv->display_count++;
260 		pm_runtime_get(dev->dev);
261 		spin_unlock_irqrestore(&power_ctrl_lock, flags);
262 		return true;
263 	}
264 	if (force_on == false)
265 		goto out_false;
266 
267 	/* Ok power up needed */
268 	ret = gma_resume_pci(pdev);
269 	if (ret == 0) {
270 		psb_irq_preinstall(dev);
271 		psb_irq_postinstall(dev);
272 		pm_runtime_get(dev->dev);
273 		dev_priv->display_count++;
274 		spin_unlock_irqrestore(&power_ctrl_lock, flags);
275 		return true;
276 	}
277 out_false:
278 	spin_unlock_irqrestore(&power_ctrl_lock, flags);
279 	return false;
280 }
281 
282 /**
283  *	gma_power_end		-	end use of power
284  *	@dev: Our DRM device
285  *
286  *	Indicate that one of our gma_power_begin() requested periods when
287  *	the diplay island power is needed has completed.
288  */
289 void gma_power_end(struct drm_device *dev)
290 {
291 	struct drm_psb_private *dev_priv = to_drm_psb_private(dev);
292 	unsigned long flags;
293 	spin_lock_irqsave(&power_ctrl_lock, flags);
294 	dev_priv->display_count--;
295 	WARN_ON(dev_priv->display_count < 0);
296 	spin_unlock_irqrestore(&power_ctrl_lock, flags);
297 	pm_runtime_put(dev->dev);
298 }
299 
300 int psb_runtime_suspend(struct device *dev)
301 {
302 	return gma_power_suspend(dev);
303 }
304 
305 int psb_runtime_resume(struct device *dev)
306 {
307 	return gma_power_resume(dev);
308 }
309 
310 int psb_runtime_idle(struct device *dev)
311 {
312 	struct drm_device *drmdev = pci_get_drvdata(to_pci_dev(dev));
313 	struct drm_psb_private *dev_priv = to_drm_psb_private(drmdev);
314 	if (dev_priv->display_count)
315 		return 0;
316 	else
317 		return 1;
318 }
319 
320 int gma_power_thaw(struct device *_dev)
321 {
322 	return gma_power_resume(_dev);
323 }
324 
325 int gma_power_freeze(struct device *_dev)
326 {
327 	return gma_power_suspend(_dev);
328 }
329 
330 int gma_power_restore(struct device *_dev)
331 {
332 	return gma_power_resume(_dev);
333 }
334