1 /*
2  * Copyright 2008 Intel Corporation <hong.liu@intel.com>
3  * Copyright 2008 Red Hat <mjg@redhat.com>
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining
6  * a copy of this software and associated documentation files (the
7  * "Software"), to deal in the Software without restriction, including
8  * without limitation the rights to use, copy, modify, merge, publish,
9  * distribute, sub license, and/or sell copies of the Software, and to
10  * permit persons to whom the Software is furnished to do so, subject to
11  * the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the
14  * next paragraph) shall be included in all copies or substantial
15  * portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20  * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE
21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24  * SOFTWARE.
25  *
26  */
27 
28 #include <linux/acpi.h>
29 #include <linux/dmi.h>
30 #include <linux/firmware.h>
31 #include <acpi/video.h>
32 
33 #include "display/intel_panel.h"
34 
35 #include "i915_drv.h"
36 #include "intel_acpi.h"
37 #include "intel_display_types.h"
38 #include "intel_opregion.h"
39 
40 #define OPREGION_HEADER_OFFSET 0
41 #define OPREGION_ACPI_OFFSET   0x100
42 #define   ACPI_CLID 0x01ac /* current lid state indicator */
43 #define   ACPI_CDCK 0x01b0 /* current docking state indicator */
44 #define OPREGION_SWSCI_OFFSET  0x200
45 #define OPREGION_ASLE_OFFSET   0x300
46 #define OPREGION_VBT_OFFSET    0x400
47 #define OPREGION_ASLE_EXT_OFFSET	0x1C00
48 
49 #define OPREGION_SIGNATURE "IntelGraphicsMem"
50 #define MBOX_ACPI      (1<<0)
51 #define MBOX_SWSCI     (1<<1)
52 #define MBOX_ASLE      (1<<2)
53 #define MBOX_ASLE_EXT  (1<<4)
54 
55 struct opregion_header {
56 	u8 signature[16];
57 	u32 size;
58 	struct {
59 		u8 rsvd;
60 		u8 revision;
61 		u8 minor;
62 		u8 major;
63 	}  __packed over;
64 	u8 bios_ver[32];
65 	u8 vbios_ver[16];
66 	u8 driver_ver[16];
67 	u32 mboxes;
68 	u32 driver_model;
69 	u32 pcon;
70 	u8 dver[32];
71 	u8 rsvd[124];
72 } __packed;
73 
74 /* OpRegion mailbox #1: public ACPI methods */
75 struct opregion_acpi {
76 	u32 drdy;       /* driver readiness */
77 	u32 csts;       /* notification status */
78 	u32 cevt;       /* current event */
79 	u8 rsvd1[20];
80 	u32 didl[8];    /* supported display devices ID list */
81 	u32 cpdl[8];    /* currently presented display list */
82 	u32 cadl[8];    /* currently active display list */
83 	u32 nadl[8];    /* next active devices list */
84 	u32 aslp;       /* ASL sleep time-out */
85 	u32 tidx;       /* toggle table index */
86 	u32 chpd;       /* current hotplug enable indicator */
87 	u32 clid;       /* current lid state*/
88 	u32 cdck;       /* current docking state */
89 	u32 sxsw;       /* Sx state resume */
90 	u32 evts;       /* ASL supported events */
91 	u32 cnot;       /* current OS notification */
92 	u32 nrdy;       /* driver status */
93 	u32 did2[7];	/* extended supported display devices ID list */
94 	u32 cpd2[7];	/* extended attached display devices list */
95 	u8 rsvd2[4];
96 } __packed;
97 
98 /* OpRegion mailbox #2: SWSCI */
99 struct opregion_swsci {
100 	u32 scic;       /* SWSCI command|status|data */
101 	u32 parm;       /* command parameters */
102 	u32 dslp;       /* driver sleep time-out */
103 	u8 rsvd[244];
104 } __packed;
105 
106 /* OpRegion mailbox #3: ASLE */
107 struct opregion_asle {
108 	u32 ardy;       /* driver readiness */
109 	u32 aslc;       /* ASLE interrupt command */
110 	u32 tche;       /* technology enabled indicator */
111 	u32 alsi;       /* current ALS illuminance reading */
112 	u32 bclp;       /* backlight brightness to set */
113 	u32 pfit;       /* panel fitting state */
114 	u32 cblv;       /* current brightness level */
115 	u16 bclm[20];   /* backlight level duty cycle mapping table */
116 	u32 cpfm;       /* current panel fitting mode */
117 	u32 epfm;       /* enabled panel fitting modes */
118 	u8 plut[74];    /* panel LUT and identifier */
119 	u32 pfmb;       /* PWM freq and min brightness */
120 	u32 cddv;       /* color correction default values */
121 	u32 pcft;       /* power conservation features */
122 	u32 srot;       /* supported rotation angles */
123 	u32 iuer;       /* IUER events */
124 	u64 fdss;
125 	u32 fdsp;
126 	u32 stat;
127 	u64 rvda;	/* Physical (2.0) or relative from opregion (2.1+)
128 			 * address of raw VBT data. */
129 	u32 rvds;	/* Size of raw vbt data */
130 	u8 rsvd[58];
131 } __packed;
132 
133 /* OpRegion mailbox #5: ASLE ext */
134 struct opregion_asle_ext {
135 	u32 phed;	/* Panel Header */
136 	u8 bddc[256];	/* Panel EDID */
137 	u8 rsvd[764];
138 } __packed;
139 
140 /* Driver readiness indicator */
141 #define ASLE_ARDY_READY		(1 << 0)
142 #define ASLE_ARDY_NOT_READY	(0 << 0)
143 
144 /* ASLE Interrupt Command (ASLC) bits */
145 #define ASLC_SET_ALS_ILLUM		(1 << 0)
146 #define ASLC_SET_BACKLIGHT		(1 << 1)
147 #define ASLC_SET_PFIT			(1 << 2)
148 #define ASLC_SET_PWM_FREQ		(1 << 3)
149 #define ASLC_SUPPORTED_ROTATION_ANGLES	(1 << 4)
150 #define ASLC_BUTTON_ARRAY		(1 << 5)
151 #define ASLC_CONVERTIBLE_INDICATOR	(1 << 6)
152 #define ASLC_DOCKING_INDICATOR		(1 << 7)
153 #define ASLC_ISCT_STATE_CHANGE		(1 << 8)
154 #define ASLC_REQ_MSK			0x1ff
155 /* response bits */
156 #define ASLC_ALS_ILLUM_FAILED		(1 << 10)
157 #define ASLC_BACKLIGHT_FAILED		(1 << 12)
158 #define ASLC_PFIT_FAILED		(1 << 14)
159 #define ASLC_PWM_FREQ_FAILED		(1 << 16)
160 #define ASLC_ROTATION_ANGLES_FAILED	(1 << 18)
161 #define ASLC_BUTTON_ARRAY_FAILED	(1 << 20)
162 #define ASLC_CONVERTIBLE_FAILED		(1 << 22)
163 #define ASLC_DOCKING_FAILED		(1 << 24)
164 #define ASLC_ISCT_STATE_FAILED		(1 << 26)
165 
166 /* Technology enabled indicator */
167 #define ASLE_TCHE_ALS_EN	(1 << 0)
168 #define ASLE_TCHE_BLC_EN	(1 << 1)
169 #define ASLE_TCHE_PFIT_EN	(1 << 2)
170 #define ASLE_TCHE_PFMB_EN	(1 << 3)
171 
172 /* ASLE backlight brightness to set */
173 #define ASLE_BCLP_VALID                (1<<31)
174 #define ASLE_BCLP_MSK          (~(1<<31))
175 
176 /* ASLE panel fitting request */
177 #define ASLE_PFIT_VALID         (1<<31)
178 #define ASLE_PFIT_CENTER (1<<0)
179 #define ASLE_PFIT_STRETCH_TEXT (1<<1)
180 #define ASLE_PFIT_STRETCH_GFX (1<<2)
181 
182 /* PWM frequency and minimum brightness */
183 #define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
184 #define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
185 #define ASLE_PFMB_PWM_MASK (0x7ffffe00)
186 #define ASLE_PFMB_PWM_VALID (1<<31)
187 
188 #define ASLE_CBLV_VALID         (1<<31)
189 
190 /* IUER */
191 #define ASLE_IUER_DOCKING		(1 << 7)
192 #define ASLE_IUER_CONVERTIBLE		(1 << 6)
193 #define ASLE_IUER_ROTATION_LOCK_BTN	(1 << 4)
194 #define ASLE_IUER_VOLUME_DOWN_BTN	(1 << 3)
195 #define ASLE_IUER_VOLUME_UP_BTN		(1 << 2)
196 #define ASLE_IUER_WINDOWS_BTN		(1 << 1)
197 #define ASLE_IUER_POWER_BTN		(1 << 0)
198 
199 /* Software System Control Interrupt (SWSCI) */
200 #define SWSCI_SCIC_INDICATOR		(1 << 0)
201 #define SWSCI_SCIC_MAIN_FUNCTION_SHIFT	1
202 #define SWSCI_SCIC_MAIN_FUNCTION_MASK	(0xf << 1)
203 #define SWSCI_SCIC_SUB_FUNCTION_SHIFT	8
204 #define SWSCI_SCIC_SUB_FUNCTION_MASK	(0xff << 8)
205 #define SWSCI_SCIC_EXIT_PARAMETER_SHIFT	8
206 #define SWSCI_SCIC_EXIT_PARAMETER_MASK	(0xff << 8)
207 #define SWSCI_SCIC_EXIT_STATUS_SHIFT	5
208 #define SWSCI_SCIC_EXIT_STATUS_MASK	(7 << 5)
209 #define SWSCI_SCIC_EXIT_STATUS_SUCCESS	1
210 
211 #define SWSCI_FUNCTION_CODE(main, sub) \
212 	((main) << SWSCI_SCIC_MAIN_FUNCTION_SHIFT | \
213 	 (sub) << SWSCI_SCIC_SUB_FUNCTION_SHIFT)
214 
215 /* SWSCI: Get BIOS Data (GBDA) */
216 #define SWSCI_GBDA			4
217 #define SWSCI_GBDA_SUPPORTED_CALLS	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 0)
218 #define SWSCI_GBDA_REQUESTED_CALLBACKS	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 1)
219 #define SWSCI_GBDA_BOOT_DISPLAY_PREF	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 4)
220 #define SWSCI_GBDA_PANEL_DETAILS	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 5)
221 #define SWSCI_GBDA_TV_STANDARD		SWSCI_FUNCTION_CODE(SWSCI_GBDA, 6)
222 #define SWSCI_GBDA_INTERNAL_GRAPHICS	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 7)
223 #define SWSCI_GBDA_SPREAD_SPECTRUM	SWSCI_FUNCTION_CODE(SWSCI_GBDA, 10)
224 
225 /* SWSCI: System BIOS Callbacks (SBCB) */
226 #define SWSCI_SBCB			6
227 #define SWSCI_SBCB_SUPPORTED_CALLBACKS	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 0)
228 #define SWSCI_SBCB_INIT_COMPLETION	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 1)
229 #define SWSCI_SBCB_PRE_HIRES_SET_MODE	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 3)
230 #define SWSCI_SBCB_POST_HIRES_SET_MODE	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 4)
231 #define SWSCI_SBCB_DISPLAY_SWITCH	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 5)
232 #define SWSCI_SBCB_SET_TV_FORMAT	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 6)
233 #define SWSCI_SBCB_ADAPTER_POWER_STATE	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 7)
234 #define SWSCI_SBCB_DISPLAY_POWER_STATE	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 8)
235 #define SWSCI_SBCB_SET_BOOT_DISPLAY	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 9)
236 #define SWSCI_SBCB_SET_PANEL_DETAILS	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 10)
237 #define SWSCI_SBCB_SET_INTERNAL_GFX	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 11)
238 #define SWSCI_SBCB_POST_HIRES_TO_DOS_FS	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 16)
239 #define SWSCI_SBCB_SUSPEND_RESUME	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 17)
240 #define SWSCI_SBCB_SET_SPREAD_SPECTRUM	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 18)
241 #define SWSCI_SBCB_POST_VBE_PM		SWSCI_FUNCTION_CODE(SWSCI_SBCB, 19)
242 #define SWSCI_SBCB_ENABLE_DISABLE_AUDIO	SWSCI_FUNCTION_CODE(SWSCI_SBCB, 21)
243 
244 #define MAX_DSLP	1500
245 
246 static int swsci(struct drm_i915_private *dev_priv,
247 		 u32 function, u32 parm, u32 *parm_out)
248 {
249 	struct opregion_swsci *swsci = dev_priv->opregion.swsci;
250 	struct pci_dev *pdev = to_pci_dev(dev_priv->drm.dev);
251 	u32 main_function, sub_function, scic;
252 	u16 swsci_val;
253 	u32 dslp;
254 
255 	if (!swsci)
256 		return -ENODEV;
257 
258 	main_function = (function & SWSCI_SCIC_MAIN_FUNCTION_MASK) >>
259 		SWSCI_SCIC_MAIN_FUNCTION_SHIFT;
260 	sub_function = (function & SWSCI_SCIC_SUB_FUNCTION_MASK) >>
261 		SWSCI_SCIC_SUB_FUNCTION_SHIFT;
262 
263 	/* Check if we can call the function. See swsci_setup for details. */
264 	if (main_function == SWSCI_SBCB) {
265 		if ((dev_priv->opregion.swsci_sbcb_sub_functions &
266 		     (1 << sub_function)) == 0)
267 			return -EINVAL;
268 	} else if (main_function == SWSCI_GBDA) {
269 		if ((dev_priv->opregion.swsci_gbda_sub_functions &
270 		     (1 << sub_function)) == 0)
271 			return -EINVAL;
272 	}
273 
274 	/* Driver sleep timeout in ms. */
275 	dslp = swsci->dslp;
276 	if (!dslp) {
277 		/* The spec says 2ms should be the default, but it's too small
278 		 * for some machines. */
279 		dslp = 50;
280 	} else if (dslp > MAX_DSLP) {
281 		/* Hey bios, trust must be earned. */
282 		DRM_INFO_ONCE("ACPI BIOS requests an excessive sleep of %u ms, "
283 			      "using %u ms instead\n", dslp, MAX_DSLP);
284 		dslp = MAX_DSLP;
285 	}
286 
287 	/* The spec tells us to do this, but we are the only user... */
288 	scic = swsci->scic;
289 	if (scic & SWSCI_SCIC_INDICATOR) {
290 		drm_dbg(&dev_priv->drm, "SWSCI request already in progress\n");
291 		return -EBUSY;
292 	}
293 
294 	scic = function | SWSCI_SCIC_INDICATOR;
295 
296 	swsci->parm = parm;
297 	swsci->scic = scic;
298 
299 	/* Ensure SCI event is selected and event trigger is cleared. */
300 	pci_read_config_word(pdev, SWSCI, &swsci_val);
301 	if (!(swsci_val & SWSCI_SCISEL) || (swsci_val & SWSCI_GSSCIE)) {
302 		swsci_val |= SWSCI_SCISEL;
303 		swsci_val &= ~SWSCI_GSSCIE;
304 		pci_write_config_word(pdev, SWSCI, swsci_val);
305 	}
306 
307 	/* Use event trigger to tell bios to check the mail. */
308 	swsci_val |= SWSCI_GSSCIE;
309 	pci_write_config_word(pdev, SWSCI, swsci_val);
310 
311 	/* Poll for the result. */
312 #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0)
313 	if (wait_for(C, dslp)) {
314 		drm_dbg(&dev_priv->drm, "SWSCI request timed out\n");
315 		return -ETIMEDOUT;
316 	}
317 
318 	scic = (scic & SWSCI_SCIC_EXIT_STATUS_MASK) >>
319 		SWSCI_SCIC_EXIT_STATUS_SHIFT;
320 
321 	/* Note: scic == 0 is an error! */
322 	if (scic != SWSCI_SCIC_EXIT_STATUS_SUCCESS) {
323 		drm_dbg(&dev_priv->drm, "SWSCI request error %u\n", scic);
324 		return -EIO;
325 	}
326 
327 	if (parm_out)
328 		*parm_out = swsci->parm;
329 
330 	return 0;
331 
332 #undef C
333 }
334 
335 #define DISPLAY_TYPE_CRT			0
336 #define DISPLAY_TYPE_TV				1
337 #define DISPLAY_TYPE_EXTERNAL_FLAT_PANEL	2
338 #define DISPLAY_TYPE_INTERNAL_FLAT_PANEL	3
339 
340 int intel_opregion_notify_encoder(struct intel_encoder *intel_encoder,
341 				  bool enable)
342 {
343 	struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev);
344 	u32 parm = 0;
345 	u32 type = 0;
346 	u32 port;
347 
348 	/* don't care about old stuff for now */
349 	if (!HAS_DDI(dev_priv))
350 		return 0;
351 
352 	if (intel_encoder->type == INTEL_OUTPUT_DSI)
353 		port = 0;
354 	else
355 		port = intel_encoder->port;
356 
357 	if (port == PORT_E)  {
358 		port = 0;
359 	} else {
360 		parm |= 1 << port;
361 		port++;
362 	}
363 
364 	if (!enable)
365 		parm |= 4 << 8;
366 
367 	switch (intel_encoder->type) {
368 	case INTEL_OUTPUT_ANALOG:
369 		type = DISPLAY_TYPE_CRT;
370 		break;
371 	case INTEL_OUTPUT_DDI:
372 	case INTEL_OUTPUT_DP:
373 	case INTEL_OUTPUT_HDMI:
374 	case INTEL_OUTPUT_DP_MST:
375 		type = DISPLAY_TYPE_EXTERNAL_FLAT_PANEL;
376 		break;
377 	case INTEL_OUTPUT_EDP:
378 	case INTEL_OUTPUT_DSI:
379 		type = DISPLAY_TYPE_INTERNAL_FLAT_PANEL;
380 		break;
381 	default:
382 		drm_WARN_ONCE(&dev_priv->drm, 1,
383 			      "unsupported intel_encoder type %d\n",
384 			      intel_encoder->type);
385 		return -EINVAL;
386 	}
387 
388 	parm |= type << (16 + port * 3);
389 
390 	return swsci(dev_priv, SWSCI_SBCB_DISPLAY_POWER_STATE, parm, NULL);
391 }
392 
393 static const struct {
394 	pci_power_t pci_power_state;
395 	u32 parm;
396 } power_state_map[] = {
397 	{ PCI_D0,	0x00 },
398 	{ PCI_D1,	0x01 },
399 	{ PCI_D2,	0x02 },
400 	{ PCI_D3hot,	0x04 },
401 	{ PCI_D3cold,	0x04 },
402 };
403 
404 int intel_opregion_notify_adapter(struct drm_i915_private *dev_priv,
405 				  pci_power_t state)
406 {
407 	int i;
408 
409 	if (!HAS_DDI(dev_priv))
410 		return 0;
411 
412 	for (i = 0; i < ARRAY_SIZE(power_state_map); i++) {
413 		if (state == power_state_map[i].pci_power_state)
414 			return swsci(dev_priv, SWSCI_SBCB_ADAPTER_POWER_STATE,
415 				     power_state_map[i].parm, NULL);
416 	}
417 
418 	return -EINVAL;
419 }
420 
421 static u32 asle_set_backlight(struct drm_i915_private *dev_priv, u32 bclp)
422 {
423 	struct intel_connector *connector;
424 	struct drm_connector_list_iter conn_iter;
425 	struct opregion_asle *asle = dev_priv->opregion.asle;
426 	struct drm_device *dev = &dev_priv->drm;
427 
428 	drm_dbg(&dev_priv->drm, "bclp = 0x%08x\n", bclp);
429 
430 	if (acpi_video_get_backlight_type() == acpi_backlight_native) {
431 		drm_dbg_kms(&dev_priv->drm,
432 			    "opregion backlight request ignored\n");
433 		return 0;
434 	}
435 
436 	if (!(bclp & ASLE_BCLP_VALID))
437 		return ASLC_BACKLIGHT_FAILED;
438 
439 	bclp &= ASLE_BCLP_MSK;
440 	if (bclp > 255)
441 		return ASLC_BACKLIGHT_FAILED;
442 
443 	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
444 
445 	/*
446 	 * Update backlight on all connectors that support backlight (usually
447 	 * only one).
448 	 */
449 	drm_dbg_kms(&dev_priv->drm, "updating opregion backlight %d/255\n",
450 		    bclp);
451 	drm_connector_list_iter_begin(dev, &conn_iter);
452 	for_each_intel_connector_iter(connector, &conn_iter)
453 		intel_panel_set_backlight_acpi(connector->base.state, bclp, 255);
454 	drm_connector_list_iter_end(&conn_iter);
455 	asle->cblv = DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID;
456 
457 	drm_modeset_unlock(&dev->mode_config.connection_mutex);
458 
459 
460 	return 0;
461 }
462 
463 static u32 asle_set_als_illum(struct drm_i915_private *dev_priv, u32 alsi)
464 {
465 	/* alsi is the current ALS reading in lux. 0 indicates below sensor
466 	   range, 0xffff indicates above sensor range. 1-0xfffe are valid */
467 	drm_dbg(&dev_priv->drm, "Illum is not supported\n");
468 	return ASLC_ALS_ILLUM_FAILED;
469 }
470 
471 static u32 asle_set_pwm_freq(struct drm_i915_private *dev_priv, u32 pfmb)
472 {
473 	drm_dbg(&dev_priv->drm, "PWM freq is not supported\n");
474 	return ASLC_PWM_FREQ_FAILED;
475 }
476 
477 static u32 asle_set_pfit(struct drm_i915_private *dev_priv, u32 pfit)
478 {
479 	/* Panel fitting is currently controlled by the X code, so this is a
480 	   noop until modesetting support works fully */
481 	drm_dbg(&dev_priv->drm, "Pfit is not supported\n");
482 	return ASLC_PFIT_FAILED;
483 }
484 
485 static u32 asle_set_supported_rotation_angles(struct drm_i915_private *dev_priv, u32 srot)
486 {
487 	drm_dbg(&dev_priv->drm, "SROT is not supported\n");
488 	return ASLC_ROTATION_ANGLES_FAILED;
489 }
490 
491 static u32 asle_set_button_array(struct drm_i915_private *dev_priv, u32 iuer)
492 {
493 	if (!iuer)
494 		drm_dbg(&dev_priv->drm,
495 			"Button array event is not supported (nothing)\n");
496 	if (iuer & ASLE_IUER_ROTATION_LOCK_BTN)
497 		drm_dbg(&dev_priv->drm,
498 			"Button array event is not supported (rotation lock)\n");
499 	if (iuer & ASLE_IUER_VOLUME_DOWN_BTN)
500 		drm_dbg(&dev_priv->drm,
501 			"Button array event is not supported (volume down)\n");
502 	if (iuer & ASLE_IUER_VOLUME_UP_BTN)
503 		drm_dbg(&dev_priv->drm,
504 			"Button array event is not supported (volume up)\n");
505 	if (iuer & ASLE_IUER_WINDOWS_BTN)
506 		drm_dbg(&dev_priv->drm,
507 			"Button array event is not supported (windows)\n");
508 	if (iuer & ASLE_IUER_POWER_BTN)
509 		drm_dbg(&dev_priv->drm,
510 			"Button array event is not supported (power)\n");
511 
512 	return ASLC_BUTTON_ARRAY_FAILED;
513 }
514 
515 static u32 asle_set_convertible(struct drm_i915_private *dev_priv, u32 iuer)
516 {
517 	if (iuer & ASLE_IUER_CONVERTIBLE)
518 		drm_dbg(&dev_priv->drm,
519 			"Convertible is not supported (clamshell)\n");
520 	else
521 		drm_dbg(&dev_priv->drm,
522 			"Convertible is not supported (slate)\n");
523 
524 	return ASLC_CONVERTIBLE_FAILED;
525 }
526 
527 static u32 asle_set_docking(struct drm_i915_private *dev_priv, u32 iuer)
528 {
529 	if (iuer & ASLE_IUER_DOCKING)
530 		drm_dbg(&dev_priv->drm, "Docking is not supported (docked)\n");
531 	else
532 		drm_dbg(&dev_priv->drm,
533 			"Docking is not supported (undocked)\n");
534 
535 	return ASLC_DOCKING_FAILED;
536 }
537 
538 static u32 asle_isct_state(struct drm_i915_private *dev_priv)
539 {
540 	drm_dbg(&dev_priv->drm, "ISCT is not supported\n");
541 	return ASLC_ISCT_STATE_FAILED;
542 }
543 
544 static void asle_work(struct work_struct *work)
545 {
546 	struct intel_opregion *opregion =
547 		container_of(work, struct intel_opregion, asle_work);
548 	struct drm_i915_private *dev_priv =
549 		container_of(opregion, struct drm_i915_private, opregion);
550 	struct opregion_asle *asle = dev_priv->opregion.asle;
551 	u32 aslc_stat = 0;
552 	u32 aslc_req;
553 
554 	if (!asle)
555 		return;
556 
557 	aslc_req = asle->aslc;
558 
559 	if (!(aslc_req & ASLC_REQ_MSK)) {
560 		drm_dbg(&dev_priv->drm,
561 			"No request on ASLC interrupt 0x%08x\n", aslc_req);
562 		return;
563 	}
564 
565 	if (aslc_req & ASLC_SET_ALS_ILLUM)
566 		aslc_stat |= asle_set_als_illum(dev_priv, asle->alsi);
567 
568 	if (aslc_req & ASLC_SET_BACKLIGHT)
569 		aslc_stat |= asle_set_backlight(dev_priv, asle->bclp);
570 
571 	if (aslc_req & ASLC_SET_PFIT)
572 		aslc_stat |= asle_set_pfit(dev_priv, asle->pfit);
573 
574 	if (aslc_req & ASLC_SET_PWM_FREQ)
575 		aslc_stat |= asle_set_pwm_freq(dev_priv, asle->pfmb);
576 
577 	if (aslc_req & ASLC_SUPPORTED_ROTATION_ANGLES)
578 		aslc_stat |= asle_set_supported_rotation_angles(dev_priv,
579 							asle->srot);
580 
581 	if (aslc_req & ASLC_BUTTON_ARRAY)
582 		aslc_stat |= asle_set_button_array(dev_priv, asle->iuer);
583 
584 	if (aslc_req & ASLC_CONVERTIBLE_INDICATOR)
585 		aslc_stat |= asle_set_convertible(dev_priv, asle->iuer);
586 
587 	if (aslc_req & ASLC_DOCKING_INDICATOR)
588 		aslc_stat |= asle_set_docking(dev_priv, asle->iuer);
589 
590 	if (aslc_req & ASLC_ISCT_STATE_CHANGE)
591 		aslc_stat |= asle_isct_state(dev_priv);
592 
593 	asle->aslc = aslc_stat;
594 }
595 
596 void intel_opregion_asle_intr(struct drm_i915_private *dev_priv)
597 {
598 	if (dev_priv->opregion.asle)
599 		schedule_work(&dev_priv->opregion.asle_work);
600 }
601 
602 #define ACPI_EV_DISPLAY_SWITCH (1<<0)
603 #define ACPI_EV_LID            (1<<1)
604 #define ACPI_EV_DOCK           (1<<2)
605 
606 /*
607  * The only video events relevant to opregion are 0x80. These indicate either a
608  * docking event, lid switch or display switch request. In Linux, these are
609  * handled by the dock, button and video drivers.
610  */
611 static int intel_opregion_video_event(struct notifier_block *nb,
612 				      unsigned long val, void *data)
613 {
614 	struct intel_opregion *opregion = container_of(nb, struct intel_opregion,
615 						       acpi_notifier);
616 	struct acpi_bus_event *event = data;
617 	struct opregion_acpi *acpi;
618 	int ret = NOTIFY_OK;
619 
620 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
621 		return NOTIFY_DONE;
622 
623 	acpi = opregion->acpi;
624 
625 	if (event->type == 0x80 && ((acpi->cevt & 1) == 0))
626 		ret = NOTIFY_BAD;
627 
628 	acpi->csts = 0;
629 
630 	return ret;
631 }
632 
633 /*
634  * Initialise the DIDL field in opregion. This passes a list of devices to
635  * the firmware. Values are defined by section B.4.2 of the ACPI specification
636  * (version 3)
637  */
638 
639 static void set_did(struct intel_opregion *opregion, int i, u32 val)
640 {
641 	if (i < ARRAY_SIZE(opregion->acpi->didl)) {
642 		opregion->acpi->didl[i] = val;
643 	} else {
644 		i -= ARRAY_SIZE(opregion->acpi->didl);
645 
646 		if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2)))
647 			return;
648 
649 		opregion->acpi->did2[i] = val;
650 	}
651 }
652 
653 static void intel_didl_outputs(struct drm_i915_private *dev_priv)
654 {
655 	struct intel_opregion *opregion = &dev_priv->opregion;
656 	struct intel_connector *connector;
657 	struct drm_connector_list_iter conn_iter;
658 	int i = 0, max_outputs;
659 
660 	/*
661 	 * In theory, did2, the extended didl, gets added at opregion version
662 	 * 3.0. In practice, however, we're supposed to set it for earlier
663 	 * versions as well, since a BIOS that doesn't understand did2 should
664 	 * not look at it anyway. Use a variable so we can tweak this if a need
665 	 * arises later.
666 	 */
667 	max_outputs = ARRAY_SIZE(opregion->acpi->didl) +
668 		ARRAY_SIZE(opregion->acpi->did2);
669 
670 	intel_acpi_device_id_update(dev_priv);
671 
672 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
673 	for_each_intel_connector_iter(connector, &conn_iter) {
674 		if (i < max_outputs)
675 			set_did(opregion, i, connector->acpi_device_id);
676 		i++;
677 	}
678 	drm_connector_list_iter_end(&conn_iter);
679 
680 	drm_dbg_kms(&dev_priv->drm, "%d outputs detected\n", i);
681 
682 	if (i > max_outputs)
683 		drm_err(&dev_priv->drm,
684 			"More than %d outputs in connector list\n",
685 			max_outputs);
686 
687 	/* If fewer than max outputs, the list must be null terminated */
688 	if (i < max_outputs)
689 		set_did(opregion, i, 0);
690 }
691 
692 static void intel_setup_cadls(struct drm_i915_private *dev_priv)
693 {
694 	struct intel_opregion *opregion = &dev_priv->opregion;
695 	struct intel_connector *connector;
696 	struct drm_connector_list_iter conn_iter;
697 	int i = 0;
698 
699 	/*
700 	 * Initialize the CADL field from the connector device ids. This is
701 	 * essentially the same as copying from the DIDL. Technically, this is
702 	 * not always correct as display outputs may exist, but not active. This
703 	 * initialization is necessary for some Clevo laptops that check this
704 	 * field before processing the brightness and display switching hotkeys.
705 	 *
706 	 * Note that internal panels should be at the front of the connector
707 	 * list already, ensuring they're not left out.
708 	 */
709 	drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
710 	for_each_intel_connector_iter(connector, &conn_iter) {
711 		if (i >= ARRAY_SIZE(opregion->acpi->cadl))
712 			break;
713 		opregion->acpi->cadl[i++] = connector->acpi_device_id;
714 	}
715 	drm_connector_list_iter_end(&conn_iter);
716 
717 	/* If fewer than 8 active devices, the list must be null terminated */
718 	if (i < ARRAY_SIZE(opregion->acpi->cadl))
719 		opregion->acpi->cadl[i] = 0;
720 }
721 
722 static void swsci_setup(struct drm_i915_private *dev_priv)
723 {
724 	struct intel_opregion *opregion = &dev_priv->opregion;
725 	bool requested_callbacks = false;
726 	u32 tmp;
727 
728 	/* Sub-function code 0 is okay, let's allow them. */
729 	opregion->swsci_gbda_sub_functions = 1;
730 	opregion->swsci_sbcb_sub_functions = 1;
731 
732 	/* We use GBDA to ask for supported GBDA calls. */
733 	if (swsci(dev_priv, SWSCI_GBDA_SUPPORTED_CALLS, 0, &tmp) == 0) {
734 		/* make the bits match the sub-function codes */
735 		tmp <<= 1;
736 		opregion->swsci_gbda_sub_functions |= tmp;
737 	}
738 
739 	/*
740 	 * We also use GBDA to ask for _requested_ SBCB callbacks. The driver
741 	 * must not call interfaces that are not specifically requested by the
742 	 * bios.
743 	 */
744 	if (swsci(dev_priv, SWSCI_GBDA_REQUESTED_CALLBACKS, 0, &tmp) == 0) {
745 		/* here, the bits already match sub-function codes */
746 		opregion->swsci_sbcb_sub_functions |= tmp;
747 		requested_callbacks = true;
748 	}
749 
750 	/*
751 	 * But we use SBCB to ask for _supported_ SBCB calls. This does not mean
752 	 * the callback is _requested_. But we still can't call interfaces that
753 	 * are not requested.
754 	 */
755 	if (swsci(dev_priv, SWSCI_SBCB_SUPPORTED_CALLBACKS, 0, &tmp) == 0) {
756 		/* make the bits match the sub-function codes */
757 		u32 low = tmp & 0x7ff;
758 		u32 high = tmp & ~0xfff; /* bit 11 is reserved */
759 		tmp = (high << 4) | (low << 1) | 1;
760 
761 		/* best guess what to do with supported wrt requested */
762 		if (requested_callbacks) {
763 			u32 req = opregion->swsci_sbcb_sub_functions;
764 			if ((req & tmp) != req)
765 				drm_dbg(&dev_priv->drm,
766 					"SWSCI BIOS requested (%08x) SBCB callbacks that are not supported (%08x)\n",
767 					req, tmp);
768 			/* XXX: for now, trust the requested callbacks */
769 			/* opregion->swsci_sbcb_sub_functions &= tmp; */
770 		} else {
771 			opregion->swsci_sbcb_sub_functions |= tmp;
772 		}
773 	}
774 
775 	drm_dbg(&dev_priv->drm,
776 		"SWSCI GBDA callbacks %08x, SBCB callbacks %08x\n",
777 		opregion->swsci_gbda_sub_functions,
778 		opregion->swsci_sbcb_sub_functions);
779 }
780 
781 static int intel_no_opregion_vbt_callback(const struct dmi_system_id *id)
782 {
783 	DRM_DEBUG_KMS("Falling back to manually reading VBT from "
784 		      "VBIOS ROM for %s\n", id->ident);
785 	return 1;
786 }
787 
788 static const struct dmi_system_id intel_no_opregion_vbt[] = {
789 	{
790 		.callback = intel_no_opregion_vbt_callback,
791 		.ident = "ThinkCentre A57",
792 		.matches = {
793 			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
794 			DMI_MATCH(DMI_PRODUCT_NAME, "97027RG"),
795 		},
796 	},
797 	{ }
798 };
799 
800 static int intel_load_vbt_firmware(struct drm_i915_private *dev_priv)
801 {
802 	struct intel_opregion *opregion = &dev_priv->opregion;
803 	const struct firmware *fw = NULL;
804 	const char *name = dev_priv->params.vbt_firmware;
805 	int ret;
806 
807 	if (!name || !*name)
808 		return -ENOENT;
809 
810 	ret = request_firmware(&fw, name, dev_priv->drm.dev);
811 	if (ret) {
812 		drm_err(&dev_priv->drm,
813 			"Requesting VBT firmware \"%s\" failed (%d)\n",
814 			name, ret);
815 		return ret;
816 	}
817 
818 	if (intel_bios_is_valid_vbt(fw->data, fw->size)) {
819 		opregion->vbt_firmware = kmemdup(fw->data, fw->size, GFP_KERNEL);
820 		if (opregion->vbt_firmware) {
821 			drm_dbg_kms(&dev_priv->drm,
822 				    "Found valid VBT firmware \"%s\"\n", name);
823 			opregion->vbt = opregion->vbt_firmware;
824 			opregion->vbt_size = fw->size;
825 			ret = 0;
826 		} else {
827 			ret = -ENOMEM;
828 		}
829 	} else {
830 		drm_dbg_kms(&dev_priv->drm, "Invalid VBT firmware \"%s\"\n",
831 			    name);
832 		ret = -EINVAL;
833 	}
834 
835 	release_firmware(fw);
836 
837 	return ret;
838 }
839 
840 int intel_opregion_setup(struct drm_i915_private *dev_priv)
841 {
842 	struct intel_opregion *opregion = &dev_priv->opregion;
843 	struct pci_dev *pdev = to_pci_dev(dev_priv->drm.dev);
844 	u32 asls, mboxes;
845 	char buf[sizeof(OPREGION_SIGNATURE)];
846 	int err = 0;
847 	void *base;
848 	const void *vbt;
849 	u32 vbt_size;
850 
851 	BUILD_BUG_ON(sizeof(struct opregion_header) != 0x100);
852 	BUILD_BUG_ON(sizeof(struct opregion_acpi) != 0x100);
853 	BUILD_BUG_ON(sizeof(struct opregion_swsci) != 0x100);
854 	BUILD_BUG_ON(sizeof(struct opregion_asle) != 0x100);
855 	BUILD_BUG_ON(sizeof(struct opregion_asle_ext) != 0x400);
856 
857 	pci_read_config_dword(pdev, ASLS, &asls);
858 	drm_dbg(&dev_priv->drm, "graphic opregion physical addr: 0x%x\n",
859 		asls);
860 	if (asls == 0) {
861 		drm_dbg(&dev_priv->drm, "ACPI OpRegion not supported!\n");
862 		return -ENOTSUPP;
863 	}
864 
865 	INIT_WORK(&opregion->asle_work, asle_work);
866 
867 	base = memremap(asls, OPREGION_SIZE, MEMREMAP_WB);
868 	if (!base)
869 		return -ENOMEM;
870 
871 	memcpy(buf, base, sizeof(buf));
872 
873 	if (memcmp(buf, OPREGION_SIGNATURE, 16)) {
874 		drm_dbg(&dev_priv->drm, "opregion signature mismatch\n");
875 		err = -EINVAL;
876 		goto err_out;
877 	}
878 	opregion->header = base;
879 	opregion->lid_state = base + ACPI_CLID;
880 
881 	drm_dbg(&dev_priv->drm, "ACPI OpRegion version %u.%u.%u\n",
882 		opregion->header->over.major,
883 		opregion->header->over.minor,
884 		opregion->header->over.revision);
885 
886 	mboxes = opregion->header->mboxes;
887 	if (mboxes & MBOX_ACPI) {
888 		drm_dbg(&dev_priv->drm, "Public ACPI methods supported\n");
889 		opregion->acpi = base + OPREGION_ACPI_OFFSET;
890 		/*
891 		 * Indicate we handle monitor hotplug events ourselves so we do
892 		 * not need ACPI notifications for them. Disabling these avoids
893 		 * triggering the AML code doing the notifation, which may be
894 		 * broken as Windows also seems to disable these.
895 		 */
896 		opregion->acpi->chpd = 1;
897 	}
898 
899 	if (mboxes & MBOX_SWSCI) {
900 		drm_dbg(&dev_priv->drm, "SWSCI supported\n");
901 		opregion->swsci = base + OPREGION_SWSCI_OFFSET;
902 		swsci_setup(dev_priv);
903 	}
904 
905 	if (mboxes & MBOX_ASLE) {
906 		drm_dbg(&dev_priv->drm, "ASLE supported\n");
907 		opregion->asle = base + OPREGION_ASLE_OFFSET;
908 
909 		opregion->asle->ardy = ASLE_ARDY_NOT_READY;
910 	}
911 
912 	if (mboxes & MBOX_ASLE_EXT)
913 		drm_dbg(&dev_priv->drm, "ASLE extension supported\n");
914 
915 	if (intel_load_vbt_firmware(dev_priv) == 0)
916 		goto out;
917 
918 	if (dmi_check_system(intel_no_opregion_vbt))
919 		goto out;
920 
921 	if (opregion->header->over.major >= 2 && opregion->asle &&
922 	    opregion->asle->rvda && opregion->asle->rvds) {
923 		resource_size_t rvda = opregion->asle->rvda;
924 
925 		/*
926 		 * opregion 2.0: rvda is the physical VBT address.
927 		 *
928 		 * opregion 2.1+: rvda is unsigned, relative offset from
929 		 * opregion base, and should never point within opregion.
930 		 */
931 		if (opregion->header->over.major > 2 ||
932 		    opregion->header->over.minor >= 1) {
933 			drm_WARN_ON(&dev_priv->drm, rvda < OPREGION_SIZE);
934 
935 			rvda += asls;
936 		}
937 
938 		opregion->rvda = memremap(rvda, opregion->asle->rvds,
939 					  MEMREMAP_WB);
940 
941 		vbt = opregion->rvda;
942 		vbt_size = opregion->asle->rvds;
943 		if (intel_bios_is_valid_vbt(vbt, vbt_size)) {
944 			drm_dbg_kms(&dev_priv->drm,
945 				    "Found valid VBT in ACPI OpRegion (RVDA)\n");
946 			opregion->vbt = vbt;
947 			opregion->vbt_size = vbt_size;
948 			goto out;
949 		} else {
950 			drm_dbg_kms(&dev_priv->drm,
951 				    "Invalid VBT in ACPI OpRegion (RVDA)\n");
952 			memunmap(opregion->rvda);
953 			opregion->rvda = NULL;
954 		}
955 	}
956 
957 	vbt = base + OPREGION_VBT_OFFSET;
958 	/*
959 	 * The VBT specification says that if the ASLE ext mailbox is not used
960 	 * its area is reserved, but on some CHT boards the VBT extends into the
961 	 * ASLE ext area. Allow this even though it is against the spec, so we
962 	 * do not end up rejecting the VBT on those boards (and end up not
963 	 * finding the LCD panel because of this).
964 	 */
965 	vbt_size = (mboxes & MBOX_ASLE_EXT) ?
966 		OPREGION_ASLE_EXT_OFFSET : OPREGION_SIZE;
967 	vbt_size -= OPREGION_VBT_OFFSET;
968 	if (intel_bios_is_valid_vbt(vbt, vbt_size)) {
969 		drm_dbg_kms(&dev_priv->drm,
970 			    "Found valid VBT in ACPI OpRegion (Mailbox #4)\n");
971 		opregion->vbt = vbt;
972 		opregion->vbt_size = vbt_size;
973 	} else {
974 		drm_dbg_kms(&dev_priv->drm,
975 			    "Invalid VBT in ACPI OpRegion (Mailbox #4)\n");
976 	}
977 
978 out:
979 	return 0;
980 
981 err_out:
982 	memunmap(base);
983 	return err;
984 }
985 
986 static int intel_use_opregion_panel_type_callback(const struct dmi_system_id *id)
987 {
988 	DRM_INFO("Using panel type from OpRegion on %s\n", id->ident);
989 	return 1;
990 }
991 
992 static const struct dmi_system_id intel_use_opregion_panel_type[] = {
993 	{
994 		.callback = intel_use_opregion_panel_type_callback,
995 		.ident = "Conrac GmbH IX45GM2",
996 		.matches = {DMI_MATCH(DMI_SYS_VENDOR, "Conrac GmbH"),
997 			    DMI_MATCH(DMI_PRODUCT_NAME, "IX45GM2"),
998 		},
999 	},
1000 	{ }
1001 };
1002 
1003 int
1004 intel_opregion_get_panel_type(struct drm_i915_private *dev_priv)
1005 {
1006 	u32 panel_details;
1007 	int ret;
1008 
1009 	ret = swsci(dev_priv, SWSCI_GBDA_PANEL_DETAILS, 0x0, &panel_details);
1010 	if (ret)
1011 		return ret;
1012 
1013 	ret = (panel_details >> 8) & 0xff;
1014 	if (ret > 0x10) {
1015 		drm_dbg_kms(&dev_priv->drm,
1016 			    "Invalid OpRegion panel type 0x%x\n", ret);
1017 		return -EINVAL;
1018 	}
1019 
1020 	/* fall back to VBT panel type? */
1021 	if (ret == 0x0) {
1022 		drm_dbg_kms(&dev_priv->drm, "No panel type in OpRegion\n");
1023 		return -ENODEV;
1024 	}
1025 
1026 	/*
1027 	 * So far we know that some machined must use it, others must not use it.
1028 	 * There doesn't seem to be any way to determine which way to go, except
1029 	 * via a quirk list :(
1030 	 */
1031 	if (!dmi_check_system(intel_use_opregion_panel_type)) {
1032 		drm_dbg_kms(&dev_priv->drm,
1033 			    "Ignoring OpRegion panel type (%d)\n", ret - 1);
1034 		return -ENODEV;
1035 	}
1036 
1037 	return ret - 1;
1038 }
1039 
1040 void intel_opregion_register(struct drm_i915_private *i915)
1041 {
1042 	struct intel_opregion *opregion = &i915->opregion;
1043 
1044 	if (!opregion->header)
1045 		return;
1046 
1047 	if (opregion->acpi) {
1048 		opregion->acpi_notifier.notifier_call =
1049 			intel_opregion_video_event;
1050 		register_acpi_notifier(&opregion->acpi_notifier);
1051 	}
1052 
1053 	intel_opregion_resume(i915);
1054 }
1055 
1056 void intel_opregion_resume(struct drm_i915_private *i915)
1057 {
1058 	struct intel_opregion *opregion = &i915->opregion;
1059 
1060 	if (!opregion->header)
1061 		return;
1062 
1063 	if (opregion->acpi) {
1064 		intel_didl_outputs(i915);
1065 		intel_setup_cadls(i915);
1066 
1067 		/*
1068 		 * Notify BIOS we are ready to handle ACPI video ext notifs.
1069 		 * Right now, all the events are handled by the ACPI video
1070 		 * module. We don't actually need to do anything with them.
1071 		 */
1072 		opregion->acpi->csts = 0;
1073 		opregion->acpi->drdy = 1;
1074 	}
1075 
1076 	if (opregion->asle) {
1077 		opregion->asle->tche = ASLE_TCHE_BLC_EN;
1078 		opregion->asle->ardy = ASLE_ARDY_READY;
1079 	}
1080 
1081 	intel_opregion_notify_adapter(i915, PCI_D0);
1082 }
1083 
1084 void intel_opregion_suspend(struct drm_i915_private *i915, pci_power_t state)
1085 {
1086 	struct intel_opregion *opregion = &i915->opregion;
1087 
1088 	if (!opregion->header)
1089 		return;
1090 
1091 	intel_opregion_notify_adapter(i915, state);
1092 
1093 	if (opregion->asle)
1094 		opregion->asle->ardy = ASLE_ARDY_NOT_READY;
1095 
1096 	cancel_work_sync(&i915->opregion.asle_work);
1097 
1098 	if (opregion->acpi)
1099 		opregion->acpi->drdy = 0;
1100 }
1101 
1102 void intel_opregion_unregister(struct drm_i915_private *i915)
1103 {
1104 	struct intel_opregion *opregion = &i915->opregion;
1105 
1106 	intel_opregion_suspend(i915, PCI_D1);
1107 
1108 	if (!opregion->header)
1109 		return;
1110 
1111 	if (opregion->acpi_notifier.notifier_call) {
1112 		unregister_acpi_notifier(&opregion->acpi_notifier);
1113 		opregion->acpi_notifier.notifier_call = NULL;
1114 	}
1115 
1116 	/* just clear all opregion memory pointers now */
1117 	memunmap(opregion->header);
1118 	if (opregion->rvda) {
1119 		memunmap(opregion->rvda);
1120 		opregion->rvda = NULL;
1121 	}
1122 	if (opregion->vbt_firmware) {
1123 		kfree(opregion->vbt_firmware);
1124 		opregion->vbt_firmware = NULL;
1125 	}
1126 	opregion->header = NULL;
1127 	opregion->acpi = NULL;
1128 	opregion->swsci = NULL;
1129 	opregion->asle = NULL;
1130 	opregion->vbt = NULL;
1131 	opregion->lid_state = NULL;
1132 }
1133