[linux-2.6-block.git] / drivers / gpu / drm / i915 / intel_opregion.c

/*
 * Copyright 2008 Intel Corporation <hong.liu@intel.com>
 * Copyright 2008 Red Hat <mjg@redhat.com>
 *
 * 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, sub license, 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
 * NON-INFRINGEMENT.  IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS 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.
 *
 */

#include <linux/acpi.h>
#include <linux/acpi_io.h>
#include <acpi/video.h>

#include "drmP.h"
#include "i915_drm.h"
#include "i915_drv.h"
#include "intel_drv.h"

#define PCI_ASLE 0xe4
#define PCI_ASLS 0xfc

#define OPREGION_HEADER_OFFSET 0
#define OPREGION_ACPI_OFFSET   0x100
#define   ACPI_CLID 0x01ac /* current lid state indicator */
#define   ACPI_CDCK 0x01b0 /* current docking state indicator */
#define OPREGION_SWSCI_OFFSET  0x200
#define OPREGION_ASLE_OFFSET   0x300
#define OPREGION_VBT_OFFSET    0x400

#define OPREGION_SIGNATURE "IntelGraphicsMem"
#define MBOX_ACPI      (1<<0)
#define MBOX_SWSCI     (1<<1)
#define MBOX_ASLE      (1<<2)

struct opregion_header {
       u8 signature[16];
       u32 size;
       u32 opregion_ver;
       u8 bios_ver[32];
       u8 vbios_ver[16];
       u8 driver_ver[16];
       u32 mboxes;
       u8 reserved[164];
} __attribute__((packed));

/* OpRegion mailbox #1: public ACPI methods */
struct opregion_acpi {
       u32 drdy;       /* driver readiness */
       u32 csts;       /* notification status */
       u32 cevt;       /* current event */
       u8 rsvd1[20];
       u32 didl[8];    /* supported display devices ID list */
       u32 cpdl[8];    /* currently presented display list */
       u32 cadl[8];    /* currently active display list */
       u32 nadl[8];    /* next active devices list */
       u32 aslp;       /* ASL sleep time-out */
       u32 tidx;       /* toggle table index */
       u32 chpd;       /* current hotplug enable indicator */
       u32 clid;       /* current lid state*/
       u32 cdck;       /* current docking state */
       u32 sxsw;       /* Sx state resume */
       u32 evts;       /* ASL supported events */
       u32 cnot;       /* current OS notification */
       u32 nrdy;       /* driver status */
       u8 rsvd2[60];
} __attribute__((packed));

/* OpRegion mailbox #2: SWSCI */
struct opregion_swsci {
       u32 scic;       /* SWSCI command|status|data */
       u32 parm;       /* command parameters */
       u32 dslp;       /* driver sleep time-out */
       u8 rsvd[244];
} __attribute__((packed));

/* OpRegion mailbox #3: ASLE */
struct opregion_asle {
       u32 ardy;       /* driver readiness */
       u32 aslc;       /* ASLE interrupt command */
       u32 tche;       /* technology enabled indicator */
       u32 alsi;       /* current ALS illuminance reading */
       u32 bclp;       /* backlight brightness to set */
       u32 pfit;       /* panel fitting state */
       u32 cblv;       /* current brightness level */
       u16 bclm[20];   /* backlight level duty cycle mapping table */
       u32 cpfm;       /* current panel fitting mode */
       u32 epfm;       /* enabled panel fitting modes */
       u8 plut[74];    /* panel LUT and identifier */
       u32 pfmb;       /* PWM freq and min brightness */
       u8 rsvd[102];
} __attribute__((packed));

/* ASLE irq request bits */
#define ASLE_SET_ALS_ILLUM     (1 << 0)
#define ASLE_SET_BACKLIGHT     (1 << 1)
#define ASLE_SET_PFIT          (1 << 2)
#define ASLE_SET_PWM_FREQ      (1 << 3)
#define ASLE_REQ_MSK           0xf

/* response bits of ASLE irq request */
#define ASLE_ALS_ILLUM_FAILED	(1<<10)
#define ASLE_BACKLIGHT_FAILED	(1<<12)
#define ASLE_PFIT_FAILED	(1<<14)
#define ASLE_PWM_FREQ_FAILED	(1<<16)

/* ASLE backlight brightness to set */
#define ASLE_BCLP_VALID                (1<<31)
#define ASLE_BCLP_MSK          (~(1<<31))

/* ASLE panel fitting request */
#define ASLE_PFIT_VALID         (1<<31)
#define ASLE_PFIT_CENTER (1<<0)
#define ASLE_PFIT_STRETCH_TEXT (1<<1)
#define ASLE_PFIT_STRETCH_GFX (1<<2)

/* PWM frequency and minimum brightness */
#define ASLE_PFMB_BRIGHTNESS_MASK (0xff)
#define ASLE_PFMB_BRIGHTNESS_VALID (1<<8)
#define ASLE_PFMB_PWM_MASK (0x7ffffe00)
#define ASLE_PFMB_PWM_VALID (1<<31)

#define ASLE_CBLV_VALID         (1<<31)

#define ACPI_OTHER_OUTPUT (0<<8)
#define ACPI_VGA_OUTPUT (1<<8)
#define ACPI_TV_OUTPUT (2<<8)
#define ACPI_DIGITAL_OUTPUT (3<<8)
#define ACPI_LVDS_OUTPUT (4<<8)

#ifdef CONFIG_ACPI
static u32 asle_set_backlight(struct drm_device *dev, u32 bclp)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct opregion_asle *asle = dev_priv->opregion.asle;
	u32 max;

	if (!(bclp & ASLE_BCLP_VALID))
		return ASLE_BACKLIGHT_FAILED;

	bclp &= ASLE_BCLP_MSK;
	if (bclp > 255)
		return ASLE_BACKLIGHT_FAILED;

	max = intel_panel_get_max_backlight(dev);
	intel_panel_set_backlight(dev, bclp * max / 255);
	asle->cblv = (bclp*0x64)/0xff | ASLE_CBLV_VALID;

	return 0;
}

static u32 asle_set_als_illum(struct drm_device *dev, u32 alsi)
{
	/* alsi is the current ALS reading in lux. 0 indicates below sensor
	   range, 0xffff indicates above sensor range. 1-0xfffe are valid */
	return 0;
}

static u32 asle_set_pwm_freq(struct drm_device *dev, u32 pfmb)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	if (pfmb & ASLE_PFMB_PWM_VALID) {
		u32 blc_pwm_ctl = I915_READ(BLC_PWM_CTL);
		u32 pwm = pfmb & ASLE_PFMB_PWM_MASK;
		blc_pwm_ctl &= BACKLIGHT_DUTY_CYCLE_MASK;
		pwm = pwm >> 9;
		/* FIXME - what do we do with the PWM? */
	}
	return 0;
}

static u32 asle_set_pfit(struct drm_device *dev, u32 pfit)
{
	/* Panel fitting is currently controlled by the X code, so this is a
	   noop until modesetting support works fully */
	if (!(pfit & ASLE_PFIT_VALID))
		return ASLE_PFIT_FAILED;
	return 0;
}

void intel_opregion_asle_intr(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct opregion_asle *asle = dev_priv->opregion.asle;
	u32 asle_stat = 0;
	u32 asle_req;

	if (!asle)
		return;

	asle_req = asle->aslc & ASLE_REQ_MSK;

	if (!asle_req) {
		DRM_DEBUG_DRIVER("non asle set request??\n");
		return;
	}

	if (asle_req & ASLE_SET_ALS_ILLUM)
		asle_stat |= asle_set_als_illum(dev, asle->alsi);

	if (asle_req & ASLE_SET_BACKLIGHT)
		asle_stat |= asle_set_backlight(dev, asle->bclp);

	if (asle_req & ASLE_SET_PFIT)
		asle_stat |= asle_set_pfit(dev, asle->pfit);

	if (asle_req & ASLE_SET_PWM_FREQ)
		asle_stat |= asle_set_pwm_freq(dev, asle->pfmb);

	asle->aslc = asle_stat;
}

/* Only present on Ironlake+ */
void intel_opregion_gse_intr(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct opregion_asle *asle = dev_priv->opregion.asle;
	u32 asle_stat = 0;
	u32 asle_req;

	if (!asle)
		return;

	asle_req = asle->aslc & ASLE_REQ_MSK;

	if (!asle_req) {
		DRM_DEBUG_DRIVER("non asle set request??\n");
		return;
	}

	if (asle_req & ASLE_SET_ALS_ILLUM) {
		DRM_DEBUG_DRIVER("Illum is not supported\n");
		asle_stat |= ASLE_ALS_ILLUM_FAILED;
	}

	if (asle_req & ASLE_SET_BACKLIGHT)
		asle_stat |= asle_set_backlight(dev, asle->bclp);

	if (asle_req & ASLE_SET_PFIT) {
		DRM_DEBUG_DRIVER("Pfit is not supported\n");
		asle_stat |= ASLE_PFIT_FAILED;
	}

	if (asle_req & ASLE_SET_PWM_FREQ) {
		DRM_DEBUG_DRIVER("PWM freq is not supported\n");
		asle_stat |= ASLE_PWM_FREQ_FAILED;
	}

	asle->aslc = asle_stat;
}
#define ASLE_ALS_EN    (1<<0)
#define ASLE_BLC_EN    (1<<1)
#define ASLE_PFIT_EN   (1<<2)
#define ASLE_PFMB_EN   (1<<3)

void intel_opregion_enable_asle(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct opregion_asle *asle = dev_priv->opregion.asle;

	if (asle) {
		if (IS_MOBILE(dev))
			intel_enable_asle(dev);

		asle->tche = ASLE_ALS_EN | ASLE_BLC_EN | ASLE_PFIT_EN |
			ASLE_PFMB_EN;
		asle->ardy = 1;
	}
}

#define ACPI_EV_DISPLAY_SWITCH (1<<0)
#define ACPI_EV_LID            (1<<1)
#define ACPI_EV_DOCK           (1<<2)

static struct intel_opregion *system_opregion;

static int intel_opregion_video_event(struct notifier_block *nb,
				      unsigned long val, void *data)
{
	/* The only video events relevant to opregion are 0x80. These indicate
	   either a docking event, lid switch or display switch request. In
	   Linux, these are handled by the dock, button and video drivers.
	   We might want to fix the video driver to be opregion-aware in
	   future, but right now we just indicate to the firmware that the
	   request has been handled */

	struct opregion_acpi *acpi;

	if (!system_opregion)
		return NOTIFY_DONE;

	acpi = system_opregion->acpi;
	acpi->csts = 0;

	return NOTIFY_OK;
}

static struct notifier_block intel_opregion_notifier = {
	.notifier_call = intel_opregion_video_event,
};

/*
 * Initialise the DIDL field in opregion. This passes a list of devices to
 * the firmware. Values are defined by section B.4.2 of the ACPI specification
 * (version 3)
 */

static void intel_didl_outputs(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_opregion *opregion = &dev_priv->opregion;
	struct drm_connector *connector;
	acpi_handle handle;
	struct acpi_device *acpi_dev, *acpi_cdev, *acpi_video_bus = NULL;
	unsigned long long device_id;
	acpi_status status;
	int i = 0;

	handle = DEVICE_ACPI_HANDLE(&dev->pdev->dev);
	if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &acpi_dev)))
		return;

	if (acpi_is_video_device(acpi_dev))
		acpi_video_bus = acpi_dev;
	else {
		list_for_each_entry(acpi_cdev, &acpi_dev->children, node) {
			if (acpi_is_video_device(acpi_cdev)) {
				acpi_video_bus = acpi_cdev;
				break;
			}
		}
	}

	if (!acpi_video_bus) {
		printk(KERN_WARNING "No ACPI video bus found\n");
		return;
	}

	list_for_each_entry(acpi_cdev, &acpi_video_bus->children, node) {
		if (i >= 8) {
			dev_printk (KERN_ERR, &dev->pdev->dev,
				    "More than 8 outputs detected\n");
			return;
		}
		status =
			acpi_evaluate_integer(acpi_cdev->handle, "_ADR",
						NULL, &device_id);
		if (ACPI_SUCCESS(status)) {
			if (!device_id)
				goto blind_set;
			opregion->acpi->didl[i] = (u32)(device_id & 0x0f0f);
			i++;
		}
	}

end:
	/* If fewer than 8 outputs, the list must be null terminated */
	if (i < 8)
		opregion->acpi->didl[i] = 0;
	return;

blind_set:
	i = 0;
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		int output_type = ACPI_OTHER_OUTPUT;
		if (i >= 8) {
			dev_printk (KERN_ERR, &dev->pdev->dev,
				    "More than 8 outputs detected\n");
			return;
		}
		switch (connector->connector_type) {
		case DRM_MODE_CONNECTOR_VGA:
		case DRM_MODE_CONNECTOR_DVIA:
			output_type = ACPI_VGA_OUTPUT;
			break;
		case DRM_MODE_CONNECTOR_Composite:
		case DRM_MODE_CONNECTOR_SVIDEO:
		case DRM_MODE_CONNECTOR_Component:
		case DRM_MODE_CONNECTOR_9PinDIN:
			output_type = ACPI_TV_OUTPUT;
			break;
		case DRM_MODE_CONNECTOR_DVII:
		case DRM_MODE_CONNECTOR_DVID:
		case DRM_MODE_CONNECTOR_DisplayPort:
		case DRM_MODE_CONNECTOR_HDMIA:
		case DRM_MODE_CONNECTOR_HDMIB:
			output_type = ACPI_DIGITAL_OUTPUT;
			break;
		case DRM_MODE_CONNECTOR_LVDS:
			output_type = ACPI_LVDS_OUTPUT;
			break;
		}
		opregion->acpi->didl[i] |= (1<<31) | output_type | i;
		i++;
	}
	goto end;
}

void intel_opregion_init(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_opregion *opregion = &dev_priv->opregion;

	if (!opregion->header)
		return;

	if (opregion->acpi) {
		if (drm_core_check_feature(dev, DRIVER_MODESET))
			intel_didl_outputs(dev);

		/* Notify BIOS we are ready to handle ACPI video ext notifs.
		 * Right now, all the events are handled by the ACPI video module.
		 * We don't actually need to do anything with them. */
		opregion->acpi->csts = 0;
		opregion->acpi->drdy = 1;

		system_opregion = opregion;
		register_acpi_notifier(&intel_opregion_notifier);
	}

	if (opregion->asle)
		intel_opregion_enable_asle(dev);
}

void intel_opregion_fini(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_opregion *opregion = &dev_priv->opregion;

	if (!opregion->header)
		return;

	if (opregion->acpi) {
		opregion->acpi->drdy = 0;

		system_opregion = NULL;
		unregister_acpi_notifier(&intel_opregion_notifier);
	}

	/* just clear all opregion memory pointers now */
	iounmap(opregion->header);
	opregion->header = NULL;
	opregion->acpi = NULL;
	opregion->swsci = NULL;
	opregion->asle = NULL;
	opregion->vbt = NULL;
}
#endif

int intel_opregion_setup(struct drm_device *dev)
{
	struct drm_i915_private *dev_priv = dev->dev_private;
	struct intel_opregion *opregion = &dev_priv->opregion;
	void *base;
	u32 asls, mboxes;
	int err = 0;

	pci_read_config_dword(dev->pdev, PCI_ASLS, &asls);
	DRM_DEBUG_DRIVER("graphic opregion physical addr: 0x%x\n", asls);
	if (asls == 0) {
		DRM_DEBUG_DRIVER("ACPI OpRegion not supported!\n");
		return -ENOTSUPP;
	}

	base = acpi_os_ioremap(asls, OPREGION_SIZE);
	if (!base)
		return -ENOMEM;

	if (memcmp(base, OPREGION_SIGNATURE, 16)) {
		DRM_DEBUG_DRIVER("opregion signature mismatch\n");
		err = -EINVAL;
		goto err_out;
	}
	opregion->header = base;
	opregion->vbt = base + OPREGION_VBT_OFFSET;

	opregion->lid_state = base + ACPI_CLID;

	mboxes = opregion->header->mboxes;
	if (mboxes & MBOX_ACPI) {
		DRM_DEBUG_DRIVER("Public ACPI methods supported\n");
		opregion->acpi = base + OPREGION_ACPI_OFFSET;
	}

	if (mboxes & MBOX_SWSCI) {
		DRM_DEBUG_DRIVER("SWSCI supported\n");
		opregion->swsci = base + OPREGION_SWSCI_OFFSET;
	}
	if (mboxes & MBOX_ASLE) {
		DRM_DEBUG_DRIVER("ASLE supported\n");
		opregion->asle = base + OPREGION_ASLE_OFFSET;
	}

	return 0;

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