xref: /dragonfly/sys/dev/drm/i915/intel_opregion.c (revision 28a0299d) 
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  * $FreeBSD: src/sys/dev/drm2/i915/intel_opregion.c,v 1.1 2012/05/22 11:07:44 kib Exp $
27  */
28 
29 #include <drm/drmP.h>
30 #include <drm/i915_drm.h>
31 #include "i915_drv.h"
32 #include "intel_drv.h"
33 
34 #define PCI_ASLE 0xe4
35 #define PCI_ASLS 0xfc
36 
37 #define OPREGION_HEADER_OFFSET 0
38 #define OPREGION_ACPI_OFFSET   0x100
39 #define   ACPI_CLID 0x01ac /* current lid state indicator */
40 #define   ACPI_CDCK 0x01b0 /* current docking state indicator */
41 #define OPREGION_SWSCI_OFFSET  0x200
42 #define OPREGION_ASLE_OFFSET   0x300
43 #define OPREGION_VBT_OFFSET    0x400
44 
45 #define OPREGION_SIGNATURE "IntelGraphicsMem"
46 #define MBOX_ACPI      (1<<0)
47 #define MBOX_SWSCI     (1<<1)
48 #define MBOX_ASLE      (1<<2)
49 
50 struct opregion_header {
51 	u8 signature[16];
52 	u32 size;
53 	u32 opregion_ver;
54 	u8 bios_ver[32];
55 	u8 vbios_ver[16];
56 	u8 driver_ver[16];
57 	u32 mboxes;
58 	u8 reserved[164];
59 } __attribute__((packed));
60 
61 /* OpRegion mailbox #1: public ACPI methods */
62 struct opregion_acpi {
63 	u32 drdy;       /* driver readiness */
64 	u32 csts;       /* notification status */
65 	u32 cevt;       /* current event */
66 	u8 rsvd1[20];
67 	u32 didl[8];    /* supported display devices ID list */
68 	u32 cpdl[8];    /* currently presented display list */
69 	u32 cadl[8];    /* currently active display list */
70 	u32 nadl[8];    /* next active devices list */
71 	u32 aslp;       /* ASL sleep time-out */
72 	u32 tidx;       /* toggle table index */
73 	u32 chpd;       /* current hotplug enable indicator */
74 	u32 clid;       /* current lid state*/
75 	u32 cdck;       /* current docking state */
76 	u32 sxsw;       /* Sx state resume */
77 	u32 evts;       /* ASL supported events */
78 	u32 cnot;       /* current OS notification */
79 	u32 nrdy;       /* driver status */
80 	u8 rsvd2[60];
81 } __attribute__((packed));
82 
83 /* OpRegion mailbox #2: SWSCI */
84 struct opregion_swsci {
85 	u32 scic;       /* SWSCI command|status|data */
86 	u32 parm;       /* command parameters */
87 	u32 dslp;       /* driver sleep time-out */
88 	u8 rsvd[244];
89 } __attribute__((packed));
90 
91 /* OpRegion mailbox #3: ASLE */
92 struct opregion_asle {
93 	u32 ardy;       /* driver readiness */
94 	u32 aslc;       /* ASLE interrupt command */
95 	u32 tche;       /* technology enabled indicator */
96 	u32 alsi;       /* current ALS illuminance reading */
97 	u32 bclp;       /* backlight brightness to set */
98 	u32 pfit;       /* panel fitting state */
99 	u32 cblv;       /* current brightness level */
100 	u16 bclm[20];   /* backlight level duty cycle mapping table */
101 	u32 cpfm;       /* current panel fitting mode */
102 	u32 epfm;       /* enabled panel fitting modes */
103 	u8 plut[74];    /* panel LUT and identifier */
104 	u32 pfmb;       /* PWM freq and min brightness */
105 	u8 rsvd[102];
106 } __attribute__((packed));
107 
108 /* ASLE irq request bits */
109 #define ASLE_SET_ALS_ILLUM     (1 << 0)
110 #define ASLE_SET_BACKLIGHT     (1 << 1)
111 #define ASLE_SET_PFIT          (1 << 2)
112 #define ASLE_SET_PWM_FREQ      (1 << 3)
113 #define ASLE_REQ_MSK           0xf
114 
115 /* response bits of ASLE irq request */
116 #define ASLE_ALS_ILLUM_FAILED	(1<<10)
117 #define ASLE_BACKLIGHT_FAILED	(1<<12)
118 #define ASLE_PFIT_FAILED	(1<<14)
119 #define ASLE_PWM_FREQ_FAILED	(1<<16)
120 
121 /* ASLE backlight brightness to set */
122 #define ASLE_BCLP_VALID                (1<<31)
123 #define ASLE_BCLP_MSK          (~(1<<31))
124 
125 /* ASLE panel fitting request */
126 #define ASLE_PFIT_VALID         (1<<31)
127 #define ASLE_PFIT_CENTER (1<<0)
128 #define ASLE_PFIT_STRETCH_TEXT (1<<1)
129 #define ASLE_PFIT_STRETCH_GFX (1<<2)
130 
131 /* PWM frequency and minimum brightness */
132 #define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
133 #define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
134 #define ASLE_PFMB_PWM_MASK (0x7ffffe00)
135 #define ASLE_PFMB_PWM_VALID (1<<31)
136 
137 #define ASLE_CBLV_VALID         (1<<31)
138 
139 #define ACPI_OTHER_OUTPUT (0<<8)
140 #define ACPI_VGA_OUTPUT (1<<8)
141 #define ACPI_TV_OUTPUT (2<<8)
142 #define ACPI_DIGITAL_OUTPUT (3<<8)
143 #define ACPI_LVDS_OUTPUT (4<<8)
144 
145 #ifdef CONFIG_ACPI
146 static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
147 {
148 	struct drm_i915_private *dev_priv = dev->dev_private;
149 	struct opregion_asle *asle = dev_priv->opregion.asle;
150 	u32 max;
151 
152 	if (!(bclp & ASLE_BCLP_VALID))
153 		return ASLE_BACKLIGHT_FAILED;
154 
155 	bclp &= ASLE_BCLP_MSK;
156 	if (bclp > 255)
157 		return ASLE_BACKLIGHT_FAILED;
158 
159 	max = intel_panel_get_max_backlight(dev);
160 	intel_panel_set_backlight(dev, bclp * max / 255);
161 	asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;
162 
163 	return 0;
164 }
165 
166 static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
167 {
168 	/* alsi is the current ALS reading in lux. 0 indicates below sensor
169 	   range, 0xffff indicates above sensor range. 1-0xfffe are valid */
170 	return 0;
171 }
172 
173 static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
174 {
175 	struct drm_i915_private *dev_priv = dev->dev_private;
176 	if (pfmb & ASLE_PFMB_PWM_VALID) {
177 		u32 blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
178 		u32 pwm = pfmb & ASLE_PFMB_PWM_MASK;
179 		blc_pwm_ctl &= BACKLIGHT_DUTY_CYCLE_MASK;
180 		pwm = pwm >> 9;
181 		/* FIXME - what do we do with the PWM? */
182 	}
183 	return 0;
184 }
185 
186 static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
187 {
188 	/* Panel fitting is currently controlled by the X code, so this is a
189 	   noop until modesetting support works fully */
190 	if (!(pfit & ASLE_PFIT_VALID))
191 		return ASLE_PFIT_FAILED;
192 	return 0;
193 }
194 
195 void intel_opregion_asle_intr(struct drm_device *dev)
196 {
197 	struct drm_i915_private *dev_priv = dev->dev_private;
198 	struct opregion_asle *asle = dev_priv->opregion.asle;
199 	u32 asle_stat = 0;
200 	u32 asle_req;
201 
202 	if (!asle)
203 		return;
204 
205 	asle_req = asle->aslc & ASLE_REQ_MSK;
206 
207 	if (!asle_req) {
208 		DRM_DEBUG("non asle set request??\n");
209 		return;
210 	}
211 
212 	if (asle_req & ASLE_SET_ALS_ILLUM)
213 		asle_stat |= asle_set_als_illum(dev, asle->alsi);
214 
215 	if (asle_req & ASLE_SET_BACKLIGHT)
216 		asle_stat |= asle_set_backlight(dev, asle->bclp);
217 
218 	if (asle_req & ASLE_SET_PFIT)
219 		asle_stat |= asle_set_pfit(dev, asle->pfit);
220 
221 	if (asle_req & ASLE_SET_PWM_FREQ)
222 		asle_stat |= asle_set_pwm_freq(dev, asle->pfmb);
223 
224 	asle->aslc = asle_stat;
225 }
226 
227 void intel_opregion_gse_intr(struct drm_device *dev)
228 {
229 	struct drm_i915_private *dev_priv = dev->dev_private;
230 	struct opregion_asle *asle = dev_priv->opregion.asle;
231 	u32 asle_stat = 0;
232 	u32 asle_req;
233 
234 	if (!asle)
235 		return;
236 
237 	asle_req = asle->aslc & ASLE_REQ_MSK;
238 
239 	if (!asle_req) {
240 		DRM_DEBUG("non asle set request??\n");
241 		return;
242 	}
243 
244 	if (asle_req & ASLE_SET_ALS_ILLUM) {
245 		DRM_DEBUG("Illum is not supported\n");
246 		asle_stat |= ASLE_ALS_ILLUM_FAILED;
247 	}
248 
249 	if (asle_req & ASLE_SET_BACKLIGHT)
250 		asle_stat |= asle_set_backlight(dev, asle->bclp);
251 
252 	if (asle_req & ASLE_SET_PFIT) {
253 		DRM_DEBUG("Pfit is not supported\n");
254 		asle_stat |= ASLE_PFIT_FAILED;
255 	}
256 
257 	if (asle_req & ASLE_SET_PWM_FREQ) {
258 		DRM_DEBUG("PWM freq is not supported\n");
259 		asle_stat |= ASLE_PWM_FREQ_FAILED;
260 	}
261 
262 	asle->aslc = asle_stat;
263 }
264 #define ASLE_ALS_EN    (1<<0)
265 #define ASLE_BLC_EN    (1<<1)
266 #define ASLE_PFIT_EN   (1<<2)
267 #define ASLE_PFMB_EN   (1<<3)
268 
269 void intel_opregion_enable_asle(struct drm_device *dev)
270 {
271 	struct drm_i915_private *dev_priv = dev->dev_private;
272 	struct opregion_asle *asle = dev_priv->opregion.asle;
273 
274 	if (asle) {
275 		if (IS_MOBILE(dev))
276 			intel_enable_asle(dev);
277 
278 		asle->tche = ASLE_ALS_EN | ASLE_BLC_EN | ASLE_PFIT_EN |
279 			ASLE_PFMB_EN;
280 		asle->ardy = 1;
281 	}
282 }
283 
284 #define ACPI_EV_DISPLAY_SWITCH (1<<0)
285 #define ACPI_EV_LID            (1<<1)
286 #define ACPI_EV_DOCK           (1<<2)
287 
288 static struct intel_opregion *system_opregion;
289 
290 static int intel_opregion_video_event(struct notifier_block *nb,
291 				      unsigned long val, void *data)
292 {
293 	/* The only video events relevant to opregion are 0x80. These indicate
294 	   either a docking event, lid switch or display switch request. In
295 	   Linux, these are handled by the dock, button and video drivers.
296 	*/
297 	struct opregion_acpi *acpi;
298 	struct acpi_bus_event *event = data;
299 	int ret = NOTIFY_OK;
300 
301 	if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0)
302 		return NOTIFY_DONE;
303 
304 	if (!system_opregion)
305 		return NOTIFY_DONE;
306 
307 	acpi = system_opregion->acpi;
308 
309 	if (event->type == 0x80 && !(acpi->cevt & 0x1))
310 		ret = NOTIFY_BAD;
311 
312 	acpi->csts = 0;
313 
314 	return ret;
315 }
316 
317 static struct notifier_block intel_opregion_notifier = {
318 	.notifier_call = intel_opregion_video_event,
319 };
320 
321 /*
322  * Initialise the DIDL field in opregion. This passes a list of devices to
323  * the firmware. Values are defined by section B.4.2 of the ACPI specification
324  * (version 3)
325  */
326 
327 static void intel_didl_outputs(struct drm_device *dev)
328 {
329 	struct drm_i915_private *dev_priv = dev->dev_private;
330 	struct intel_opregion *opregion = &dev_priv->opregion;
331 	struct drm_connector *connector;
332 	acpi_handle handle;
333 	struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
334 	unsigned long long device_id;
335 	acpi_status status;
336 	int i = 0;
337 
338 	handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
339 	if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev)))
340 		return;
341 
342 	if (acpi_is_video_device(acpi_dev))
343 		acpi_video_bus = acpi_dev;
344 	else {
345 		list_for_each_entry(acpi_cdev, &acpi_dev->children, node) {
346 			if (acpi_is_video_device(acpi_cdev)) {
347 				acpi_video_bus = acpi_cdev;
348 				break;
349 			}
350 		}
351 	}
352 
353 	if (!acpi_video_bus) {
354 		printk(KERN_WARNING "No ACPI video bus found\n");
355 		return;
356 	}
357 
358 	list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
359 		if (i >= 8) {
360 			dev_printk(KERN_ERR, &dev->pdev->dev,
361 				    "More than 8 outputs detected\n");
362 			return;
363 		}
364 		status =
365 			acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
366 						NULL, &device_id);
367 		if (ACPI_SUCCESS(status)) {
368 			if (!device_id)
369 				goto blind_set;
370 			opregion->acpi->didl[i] = (u32)(device_id & 0x0f0f);
371 			i++;
372 		}
373 	}
374 
375 end:
376 	/* If fewer than 8 outputs, the list must be null terminated */
377 	if (i < 8)
378 		opregion->acpi->didl[i] = 0;
379 	return;
380 
381 blind_set:
382 	i = 0;
383 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
384 		int output_type = ACPI_OTHER_OUTPUT;
385 		if (i >= 8) {
386 			device_printf(dev->dev,
387 				    "More than 8 outputs detected\n");
388 			return;
389 		}
390 		switch (connector->connector_type) {
391 		case DRM_MODE_CONNECTOR_VGA:
392 		case DRM_MODE_CONNECTOR_DVIA:
393 			output_type = ACPI_VGA_OUTPUT;
394 			break;
395 		case DRM_MODE_CONNECTOR_Composite:
396 		case DRM_MODE_CONNECTOR_SVIDEO:
397 		case DRM_MODE_CONNECTOR_Component:
398 		case DRM_MODE_CONNECTOR_9PinDIN:
399 			output_type = ACPI_TV_OUTPUT;
400 			break;
401 		case DRM_MODE_CONNECTOR_DVII:
402 		case DRM_MODE_CONNECTOR_DVID:
403 		case DRM_MODE_CONNECTOR_DisplayPort:
404 		case DRM_MODE_CONNECTOR_HDMIA:
405 		case DRM_MODE_CONNECTOR_HDMIB:
406 			output_type = ACPI_DIGITAL_OUTPUT;
407 			break;
408 		case DRM_MODE_CONNECTOR_LVDS:
409 			output_type = ACPI_LVDS_OUTPUT;
410 			break;
411 		}
412 		opregion->acpi->didl[i] |= (1<<31) | output_type | i;
413 		i++;
414 	}
415 	goto end;
416 }
417 
418 void intel_opregion_init(struct drm_device *dev)
419 {
420 	struct drm_i915_private *dev_priv = dev->dev_private;
421 	struct intel_opregion *opregion = &dev_priv->opregion;
422 
423 	if (!opregion->header)
424 		return;
425 
426 	if (opregion->acpi) {
427 		if (drm_core_check_feature(dev, DRIVER_MODESET))
428 			intel_didl_outputs(dev);
429 
430 		/* Notify BIOS we are ready to handle ACPI video ext notifs.
431 		 * Right now, all the events are handled by the ACPI video module.
432 		 * We don't actually need to do anything with them. */
433 		opregion->acpi->csts = 0;
434 		opregion->acpi->drdy = 1;
435 
436 		system_opregion = opregion;
437 		register_acpi_notifier(&intel_opregion_notifier);
438 	}
439 
440 	if (opregion->asle)
441 		intel_opregion_enable_asle(dev);
442 }
443 
444 void intel_opregion_fini(struct drm_device *dev)
445 {
446 	struct drm_i915_private *dev_priv = dev->dev_private;
447 	struct intel_opregion *opregion = &dev_priv->opregion;
448 
449 	if (!opregion->header)
450 		return;
451 
452 	if (opregion->acpi) {
453 		opregion->acpi->drdy = 0;
454 
455 		system_opregion = NULL;
456 		unregister_acpi_notifier(&intel_opregion_notifier);
457 	}
458 
459 	/* just clear all opregion memory pointers now */
460 	iounmap(opregion->header);
461 	opregion->header = NULL;
462 	opregion->acpi = NULL;
463 	opregion->swsci = NULL;
464 	opregion->asle = NULL;
465 	opregion->vbt = NULL;
466 }
467 #else
468 int
469 intel_opregion_init(struct drm_device *dev)
470 {
471 
472 	return (0);
473 }
474 
475 void
476 intel_opregion_fini(struct drm_device *dev)
477 {
478 	struct drm_i915_private *dev_priv;
479 	struct intel_opregion *opregion;
480 
481 	dev_priv = dev->dev_private;
482 	opregion = &dev_priv->opregion;
483 
484 	if (opregion->header == NULL)
485 		return;
486 
487 	pmap_unmapdev((vm_offset_t)opregion->header, OPREGION_SIZE);
488 	opregion->header = NULL;
489 	opregion->acpi = NULL;
490 	opregion->swsci = NULL;
491 	opregion->asle = NULL;
492 	opregion->vbt = NULL;
493 }
494 #endif
495 
496 int intel_opregion_setup(struct drm_device *dev)
497 {
498 	struct drm_i915_private *dev_priv = dev->dev_private;
499 	struct intel_opregion *opregion = &dev_priv->opregion;
500 	char *base;
501 	u32 asls, mboxes;
502 	int err = 0;
503 
504 	asls = pci_read_config(dev->dev, PCI_ASLS, 4);
505 	DRM_DEBUG("graphic opregion physical addr: 0x%x\n", asls);
506 	if (asls == 0) {
507 		DRM_DEBUG("ACPI OpRegion not supported!\n");
508 		return -ENOTSUP;
509 	}
510 
511 	base = (void *)pmap_mapbios(asls, OPREGION_SIZE);
512 	if (!base)
513 		return -ENOMEM;
514 
515 	if (memcmp(base, OPREGION_SIGNATURE, 16)) {
516 		DRM_DEBUG("opregion signature mismatch\n");
517 		err = -EINVAL;
518 		goto err_out;
519 	}
520 	opregion->header = (struct opregion_header *)base;
521 	opregion->vbt = base + OPREGION_VBT_OFFSET;
522 
523 	opregion->lid_state = (u32 *)(base + ACPI_CLID);
524 
525 	mboxes = opregion->header->mboxes;
526 	if (mboxes & MBOX_ACPI) {
527 		DRM_DEBUG("Public ACPI methods supported\n");
528 		opregion->acpi = (struct opregion_acpi *)(base +
529 		    OPREGION_ACPI_OFFSET);
530 	}
531 
532 	if (mboxes & MBOX_SWSCI) {
533 		DRM_DEBUG("SWSCI supported\n");
534 		opregion->swsci = (struct opregion_swsci *)(base +
535 		    OPREGION_SWSCI_OFFSET);
536 	}
537 	if (mboxes & MBOX_ASLE) {
538 		DRM_DEBUG("ASLE supported\n");
539 		opregion->asle = (struct opregion_asle *)(base +
540 		    OPREGION_ASLE_OFFSET);
541 	}
542 
543 	return 0;
544 
545 err_out:
546 	pmap_unmapdev((vm_offset_t)base, OPREGION_SIZE);
547 	return err;
548 }
549