[deliverable/linux.git] / drivers / gpu / drm / nouveau / nouveau_backlight.c

/*
 * Copyright (C) 2009 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, sublicense, 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 NONINFRINGEMENT.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) 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.
 *
 */

/*
 * Authors:
 *  Matthew Garrett <mjg@redhat.com>
 *
 * Register locations derived from NVClock by Roderick Colenbrander
 */

#include <linux/backlight.h>
#include <linux/acpi.h>

#include "nouveau_drm.h"
#include "nouveau_reg.h"
#include "nouveau_encoder.h"

static int
nv40_get_intensity(struct backlight_device *bd)
{
	struct nouveau_drm *drm = bl_get_data(bd);
	struct nouveau_device *device = nv_device(drm->device);
	int val = (nv_rd32(device, NV40_PMC_BACKLIGHT) &
				   NV40_PMC_BACKLIGHT_MASK) >> 16;

	return val;
}

static int
nv40_set_intensity(struct backlight_device *bd)
{
	struct nouveau_drm *drm = bl_get_data(bd);
	struct nouveau_device *device = nv_device(drm->device);
	int val = bd->props.brightness;
	int reg = nv_rd32(device, NV40_PMC_BACKLIGHT);

	nv_wr32(device, NV40_PMC_BACKLIGHT,
		 (val << 16) | (reg & ~NV40_PMC_BACKLIGHT_MASK));

	return 0;
}

static const struct backlight_ops nv40_bl_ops = {
	.options = BL_CORE_SUSPENDRESUME,
	.get_brightness = nv40_get_intensity,
	.update_status = nv40_set_intensity,
};

static int
nv40_backlight_init(struct drm_connector *connector)
{
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
	struct nouveau_device *device = nv_device(drm->device);
	struct backlight_properties props;
	struct backlight_device *bd;

	if (!(nv_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
		return 0;

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = 31;
	bd = backlight_device_register("nv_backlight", &connector->kdev, drm,
				       &nv40_bl_ops, &props);
	if (IS_ERR(bd))
		return PTR_ERR(bd);
	drm->backlight = bd;
	bd->props.brightness = nv40_get_intensity(bd);
	backlight_update_status(bd);

	return 0;
}

static int
nv50_get_intensity(struct backlight_device *bd)
{
	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
	struct nouveau_device *device = nv_device(drm->device);
	int or = nv_encoder->or;
	u32 div = 1025;
	u32 val;

	val  = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
	val &= NV50_PDISP_SOR_PWM_CTL_VAL;
	return ((val * 100) + (div / 2)) / div;
}

static int
nv50_set_intensity(struct backlight_device *bd)
{
	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
	struct nouveau_device *device = nv_device(drm->device);
	int or = nv_encoder->or;
	u32 div = 1025;
	u32 val = (bd->props.brightness * div) / 100;

	nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
			NV50_PDISP_SOR_PWM_CTL_NEW | val);
	return 0;
}

static const struct backlight_ops nv50_bl_ops = {
	.options = BL_CORE_SUSPENDRESUME,
	.get_brightness = nv50_get_intensity,
	.update_status = nv50_set_intensity,
};

static int
nva3_get_intensity(struct backlight_device *bd)
{
	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
	struct nouveau_device *device = nv_device(drm->device);
	int or = nv_encoder->or;
	u32 div, val;

	div  = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
	val  = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
	val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
	if (div && div >= val)
		return ((val * 100) + (div / 2)) / div;

	return 100;
}

static int
nva3_set_intensity(struct backlight_device *bd)
{
	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
	struct nouveau_device *device = nv_device(drm->device);
	int or = nv_encoder->or;
	u32 div, val;

	div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
	val = (bd->props.brightness * div) / 100;
	if (div) {
		nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val |
				NV50_PDISP_SOR_PWM_CTL_NEW |
				NVA3_PDISP_SOR_PWM_CTL_UNK);
		return 0;
	}

	return -EINVAL;
}

static const struct backlight_ops nva3_bl_ops = {
	.options = BL_CORE_SUSPENDRESUME,
	.get_brightness = nva3_get_intensity,
	.update_status = nva3_set_intensity,
};

static int
nv50_backlight_init(struct drm_connector *connector)
{
	struct nouveau_drm *drm = nouveau_drm(connector->dev);
	struct nouveau_device *device = nv_device(drm->device);
	struct nouveau_encoder *nv_encoder;
	struct backlight_properties props;
	struct backlight_device *bd;
	const struct backlight_ops *ops;

	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
	if (!nv_encoder) {
		nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
		if (!nv_encoder)
			return -ENODEV;
	}

	if (!nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
		return 0;

	if (device->chipset <= 0xa0 ||
	    device->chipset == 0xaa ||
	    device->chipset == 0xac)
		ops = &nv50_bl_ops;
	else
		ops = &nva3_bl_ops;

	memset(&props, 0, sizeof(struct backlight_properties));
	props.type = BACKLIGHT_RAW;
	props.max_brightness = 100;
	bd = backlight_device_register("nv_backlight", &connector->kdev,
				       nv_encoder, ops, &props);
	if (IS_ERR(bd))
		return PTR_ERR(bd);

	drm->backlight = bd;
	bd->props.brightness = bd->ops->get_brightness(bd);
	backlight_update_status(bd);
	return 0;
}

int
nouveau_backlight_init(struct drm_device *dev)
{
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nouveau_device *device = nv_device(drm->device);
	struct drm_connector *connector;

#ifdef CONFIG_ACPI
	if (acpi_video_backlight_support()) {
		NV_INFO(drm, "ACPI backlight interface available, "
			     "not registering our own\n");
		return 0;
	}
#endif

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
		    connector->connector_type != DRM_MODE_CONNECTOR_eDP)
			continue;

		switch (device->card_type) {
		case NV_40:
			return nv40_backlight_init(connector);
		case NV_50:
		case NV_C0:
		case NV_D0:
		case NV_E0:
			return nv50_backlight_init(connector);
		default:
			break;
		}
	}


	return 0;
}

void
nouveau_backlight_exit(struct drm_device *dev)
{
	struct nouveau_drm *drm = nouveau_drm(dev);

	if (drm->backlight) {
		backlight_device_unregister(drm->backlight);
		drm->backlight = NULL;
	}
}
Commit	Line	Data
6ee73861 BS	1	/*
	2	* Copyright (C) 2009 Red Hat <mjg@redhat.com>
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining
	5	* a copy of this software and associated documentation files (the
	6	* "Software"), to deal in the Software without restriction, including
	7	* without limitation the rights to use, copy, modify, merge, publish,
	8	* distribute, sublicense, and/or sell copies of the Software, and to
	9	* permit persons to whom the Software is furnished to do so, subject to
	10	* the following conditions:
	11	*
	12	* The above copyright notice and this permission notice (including the
	13	* next paragraph) shall be included in all copies or substantial
	14	* portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	17	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	18	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	19	* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
	20	* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	21	* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	22	* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	23	*
	24	*/
	25
	26	/*
	27	* Authors:
	28	* Matthew Garrett <mjg@redhat.com>
	29	*
	30	* Register locations derived from NVClock by Roderick Colenbrander
	31	*/
	32
	33	#include <linux/backlight.h>
5bead799	34	#include <linux/acpi.h>
6ee73861	35
51a3d342	36	#include "nouveau_drm.h"
6ee73861	37	#include "nouveau_reg.h"
10b461e4	38	#include "nouveau_encoder.h"
6ee73861	39
73076481 BS	40	static int
73076481 BS	41	nv40_get_intensity(struct backlight_device *bd)
6ee73861	42	{
51a3d342 BS	43	struct nouveau_drm *drm = bl_get_data(bd);
	44	struct nouveau_device *device = nv_device(drm->device);
	45	int val = (nv_rd32(device, NV40_PMC_BACKLIGHT) &
	46	NV40_PMC_BACKLIGHT_MASK) >> 16;
6ee73861 BS	47
	48	return val;
	49	}
	50
73076481 BS	51	static int
73076481 BS	52	nv40_set_intensity(struct backlight_device *bd)
6ee73861	53	{
51a3d342 BS	54	struct nouveau_drm *drm = bl_get_data(bd);
51a3d342 BS	55	struct nouveau_device *device = nv_device(drm->device);
6ee73861	56	int val = bd->props.brightness;
51a3d342	57	int reg = nv_rd32(device, NV40_PMC_BACKLIGHT);
6ee73861	58
51a3d342	59	nv_wr32(device, NV40_PMC_BACKLIGHT,
6ee73861 BS	60	(val << 16) \| (reg & ~NV40_PMC_BACKLIGHT_MASK));
	61
	62	return 0;
	63	}
	64
acc2472e	65	static const struct backlight_ops nv40_bl_ops = {
6ee73861 BS	66	.options = BL_CORE_SUSPENDRESUME,
	67	.get_brightness = nv40_get_intensity,
	68	.update_status = nv40_set_intensity,
	69	};
	70
73076481 BS	71	static int
73076481 BS	72	nv40_backlight_init(struct drm_connector *connector)
6ee73861	73	{
77145f1c	74	struct nouveau_drm *drm = nouveau_drm(connector->dev);
51a3d342	75	struct nouveau_device *device = nv_device(drm->device);
7eae3efa	76	struct backlight_properties props;
6ee73861 BS	77	struct backlight_device *bd;
6ee73861 BS	78
51a3d342	79	if (!(nv_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
6ee73861 BS	80	return 0;
6ee73861 BS	81
a19a6ee6	82	memset(&props, 0, sizeof(struct backlight_properties));
bb7ca747	83	props.type = BACKLIGHT_RAW;
a19a6ee6	84	props.max_brightness = 31;
51a3d342	85	bd = backlight_device_register("nv_backlight", &connector->kdev, drm,
a19a6ee6	86	&nv40_bl_ops, &props);
b795016c MS	87	if (IS_ERR(bd))
b795016c MS	88	return PTR_ERR(bd);
51a3d342	89	drm->backlight = bd;
6ee73861 BS	90	bd->props.brightness = nv40_get_intensity(bd);
	91	backlight_update_status(bd);
	92
	93	return 0;
	94	}
	95
73076481 BS	96	static int
	97	nv50_get_intensity(struct backlight_device *bd)
	98	{
10b461e4	99	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	100	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
51a3d342	101	struct nouveau_device *device = nv_device(drm->device);
10b461e4	102	int or = nv_encoder->or;
09461459 BS	103	u32 div = 1025;
09461459 BS	104	u32 val;
73076481	105
51a3d342	106	val = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
5024c54b	107	val &= NV50_PDISP_SOR_PWM_CTL_VAL;
09461459	108	return ((val * 100) + (div / 2)) / div;
73076481 BS	109	}
	110
	111	static int
	112	nv50_set_intensity(struct backlight_device *bd)
	113	{
10b461e4	114	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	115	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
51a3d342	116	struct nouveau_device *device = nv_device(drm->device);
10b461e4	117	int or = nv_encoder->or;
09461459 BS	118	u32 div = 1025;
09461459 BS	119	u32 val = (bd->props.brightness * div) / 100;
73076481	120
51a3d342 BS	121	nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
51a3d342 BS	122	NV50_PDISP_SOR_PWM_CTL_NEW \| val);
73076481 BS	123	return 0;
	124	}
	125
	126	static const struct backlight_ops nv50_bl_ops = {
	127	.options = BL_CORE_SUSPENDRESUME,
	128	.get_brightness = nv50_get_intensity,
	129	.update_status = nv50_set_intensity,
	130	};
	131
5024c54b BS	132	static int
	133	nva3_get_intensity(struct backlight_device *bd)
	134	{
	135	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	136	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
51a3d342	137	struct nouveau_device *device = nv_device(drm->device);
5024c54b BS	138	int or = nv_encoder->or;
	139	u32 div, val;
	140
51a3d342 BS	141	div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
51a3d342 BS	142	val = nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
5024c54b BS	143	val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
	144	if (div && div >= val)
	145	return ((val * 100) + (div / 2)) / div;
	146
	147	return 100;
	148	}
	149
	150	static int
	151	nva3_set_intensity(struct backlight_device *bd)
	152	{
	153	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	154	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
51a3d342	155	struct nouveau_device *device = nv_device(drm->device);
5024c54b BS	156	int or = nv_encoder->or;
	157	u32 div, val;
	158
51a3d342	159	div = nv_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
5024c54b BS	160	val = (bd->props.brightness * div) / 100;
5024c54b BS	161	if (div) {
51a3d342 BS	162	nv_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val \|
	163	NV50_PDISP_SOR_PWM_CTL_NEW \|
	164	NVA3_PDISP_SOR_PWM_CTL_UNK);
5024c54b BS	165	return 0;
	166	}
	167
	168	return -EINVAL;
	169	}
	170
	171	static const struct backlight_ops nva3_bl_ops = {
	172	.options = BL_CORE_SUSPENDRESUME,
	173	.get_brightness = nva3_get_intensity,
	174	.update_status = nva3_set_intensity,
	175	};
	176
73076481 BS	177	static int
73076481 BS	178	nv50_backlight_init(struct drm_connector *connector)
6ee73861	179	{
77145f1c	180	struct nouveau_drm *drm = nouveau_drm(connector->dev);
51a3d342	181	struct nouveau_device *device = nv_device(drm->device);
10b461e4	182	struct nouveau_encoder *nv_encoder;
7eae3efa	183	struct backlight_properties props;
6ee73861	184	struct backlight_device *bd;
5024c54b	185	const struct backlight_ops *ops;
10b461e4	186
cb75d97e	187	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
10b461e4	188	if (!nv_encoder) {
cb75d97e	189	nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
10b461e4 BS	190	if (!nv_encoder)
	191	return -ENODEV;
	192	}
	193
51a3d342	194	if (!nv_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
6ee73861 BS	195	return 0;
6ee73861 BS	196
51a3d342 BS	197	if (device->chipset <= 0xa0 \|\|
	198	device->chipset == 0xaa \|\|
	199	device->chipset == 0xac)
5024c54b BS	200	ops = &nv50_bl_ops;
	201	else
	202	ops = &nva3_bl_ops;
	203
a19a6ee6	204	memset(&props, 0, sizeof(struct backlight_properties));
bb7ca747	205	props.type = BACKLIGHT_RAW;
09461459	206	props.max_brightness = 100;
10b461e4	207	bd = backlight_device_register("nv_backlight", &connector->kdev,
5024c54b	208	nv_encoder, ops, &props);
6ee73861 BS	209	if (IS_ERR(bd))
	210	return PTR_ERR(bd);
	211
51a3d342	212	drm->backlight = bd;
5024c54b	213	bd->props.brightness = bd->ops->get_brightness(bd);
6ee73861 BS	214	backlight_update_status(bd);
	215	return 0;
	216	}
	217
73076481	218	int
10b461e4	219	nouveau_backlight_init(struct drm_device *dev)
6ee73861	220	{
77145f1c	221	struct nouveau_drm *drm = nouveau_drm(dev);
51a3d342	222	struct nouveau_device *device = nv_device(drm->device);
10b461e4	223	struct drm_connector *connector;
6ee73861	224
5bead799 BS	225	#ifdef CONFIG_ACPI
5bead799 BS	226	if (acpi_video_backlight_support()) {
51a3d342	227	NV_INFO(drm, "ACPI backlight interface available, "
5bead799 BS	228	"not registering our own\n");
	229	return 0;
	230	}
	231	#endif
	232
10b461e4 BS	233	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
	234	if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
	235	connector->connector_type != DRM_MODE_CONNECTOR_eDP)
	236	continue;
	237
51a3d342	238	switch (device->card_type) {
10b461e4 BS	239	case NV_40:
	240	return nv40_backlight_init(connector);
	241	case NV_50:
cade2413 FS	242	case NV_C0:
	243	case NV_D0:
	244	case NV_E0:
10b461e4 BS	245	return nv50_backlight_init(connector);
	246	default:
	247	break;
	248	}
6ee73861 BS	249	}
6ee73861 BS	250
10b461e4	251
6ee73861 BS	252	return 0;
	253	}
	254
73076481	255	void
10b461e4	256	nouveau_backlight_exit(struct drm_device *dev)
6ee73861	257	{
77145f1c	258	struct nouveau_drm *drm = nouveau_drm(dev);
6ee73861	259
51a3d342 BS	260	if (drm->backlight) {
	261	backlight_device_unregister(drm->backlight);
	262	drm->backlight = NULL;
6ee73861 BS	263	}
6ee73861 BS	264	}