[mirror_ubuntu-bionic-kernel.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/apple-gmux.h>
#include <linux/backlight.h>
#include <linux/idr.h>

#include "nouveau_drv.h"
#include "nouveau_reg.h"
#include "nouveau_encoder.h"

static struct ida bl_ida;
#define BL_NAME_SIZE 15 // 12 for name + 2 for digits + 1 for '\0'

struct backlight_connector {
	struct list_head head;
	int id;
};

static bool
nouveau_get_backlight_name(char backlight_name[BL_NAME_SIZE], struct backlight_connector
		*connector)
{
	const int nb = ida_simple_get(&bl_ida, 0, 0, GFP_KERNEL);
	if (nb < 0 || nb >= 100)
		return false;
	if (nb > 0)
		snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight%d", nb);
	else
		snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight");
	connector->id = nb;
	return true;
}

static int
nv40_get_intensity(struct backlight_device *bd)
{
	struct nouveau_drm *drm = bl_get_data(bd);
	struct nvif_object *device = &drm->client.device.object;
	int val = (nvif_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 nvif_object *device = &drm->client.device.object;
	int val = bd->props.brightness;
	int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);

	nvif_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 nvif_object *device = &drm->client.device.object;
	struct backlight_properties props;
	struct backlight_device *bd;
	struct backlight_connector bl_connector;
	char backlight_name[BL_NAME_SIZE];

	if (!(nvif_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;
	if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
		NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
		return 0;
	}
	bd = backlight_device_register(backlight_name , connector->kdev, drm,
				       &nv40_bl_ops, &props);

	if (IS_ERR(bd)) {
		if (bl_connector.id > 0)
			ida_simple_remove(&bl_ida, bl_connector.id);
		return PTR_ERR(bd);
	}
	list_add(&bl_connector.head, &drm->bl_connectors);
	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 nvif_object *device = &drm->client.device.object;
	int or = nv_encoder->or;
	u32 div = 1025;
	u32 val;

	val  = nvif_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 nvif_object *device = &drm->client.device.object;
	int or = nv_encoder->or;
	u32 div = 1025;
	u32 val = (bd->props.brightness * div) / 100;

	nvif_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 nvif_object *device = &drm->client.device.object;
	int or = nv_encoder->or;
	u32 div, val;

	div  = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
	val  = nvif_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 nvif_object *device = &drm->client.device.object;
	int or = nv_encoder->or;
	u32 div, val;

	div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
	val = (bd->props.brightness * div) / 100;
	if (div) {
		nvif_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 nvif_object *device = &drm->client.device.object;
	struct nouveau_encoder *nv_encoder;
	struct backlight_properties props;
	struct backlight_device *bd;
	const struct backlight_ops *ops;
	struct backlight_connector bl_connector;
	char backlight_name[BL_NAME_SIZE];

	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 (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
		return 0;

	if (drm->client.device.info.chipset <= 0xa0 ||
	    drm->client.device.info.chipset == 0xaa ||
	    drm->client.device.info.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;
	if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
		NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
		return 0;
	}
	bd = backlight_device_register(backlight_name , connector->kdev,
				       nv_encoder, ops, &props);

	if (IS_ERR(bd)) {
		if (bl_connector.id > 0)
			ida_simple_remove(&bl_ida, bl_connector.id);
		return PTR_ERR(bd);
	}

	list_add(&bl_connector.head, &drm->bl_connectors);
	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 nvif_device *device = &drm->client.device;
	struct drm_connector *connector;

	INIT_LIST_HEAD(&drm->bl_connectors);

	if (apple_gmux_present()) {
		NV_INFO(drm, "Apple GMUX detected: not registering Nouveau backlight interface\n");
		return 0;
	}

	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->info.family) {
		case NV_DEVICE_INFO_V0_CURIE:
			return nv40_backlight_init(connector);
		case NV_DEVICE_INFO_V0_TESLA:
		case NV_DEVICE_INFO_V0_FERMI:
		case NV_DEVICE_INFO_V0_KEPLER:
		case NV_DEVICE_INFO_V0_MAXWELL:
			return nv50_backlight_init(connector);
		default:
			break;
		}
	}


	return 0;
}

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

	list_for_each_entry(connector, &drm->bl_connectors, head) {
		if (connector->id >= 0)
			ida_simple_remove(&bl_ida, connector->id);
	}

	if (drm->backlight) {
		backlight_device_unregister(drm->backlight);
		drm->backlight = NULL;
	}
}

void
nouveau_backlight_ctor(void)
{
	ida_init(&bl_ida);
}

void
nouveau_backlight_dtor(void)
{
	ida_destroy(&bl_ida);
}
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
b53ac1ee	33	#include <linux/apple-gmux.h>
6ee73861	34	#include <linux/backlight.h>
db1a0ae2	35	#include <linux/idr.h>
6ee73861	36
4dc28134	37	#include "nouveau_drv.h"
6ee73861	38	#include "nouveau_reg.h"
10b461e4	39	#include "nouveau_encoder.h"
6ee73861	40
db1a0ae2 PM	41	static struct ida bl_ida;
	42	#define BL_NAME_SIZE 15 // 12 for name + 2 for digits + 1 for '\0'
	43
	44	struct backlight_connector {
	45	struct list_head head;
	46	int id;
	47	};
	48
	49	static bool
	50	nouveau_get_backlight_name(char backlight_name[BL_NAME_SIZE], struct backlight_connector
	51	*connector)
	52	{
	53	const int nb = ida_simple_get(&bl_ida, 0, 0, GFP_KERNEL);
	54	if (nb < 0 \|\| nb >= 100)
	55	return false;
	56	if (nb > 0)
	57	snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight%d", nb);
	58	else
	59	snprintf(backlight_name, BL_NAME_SIZE, "nv_backlight");
	60	connector->id = nb;
	61	return true;
	62	}
	63
73076481 BS	64	static int
73076481 BS	65	nv40_get_intensity(struct backlight_device *bd)
6ee73861	66	{
51a3d342	67	struct nouveau_drm *drm = bl_get_data(bd);
1167c6bc	68	struct nvif_object *device = &drm->client.device.object;
db2bec18	69	int val = (nvif_rd32(device, NV40_PMC_BACKLIGHT) &
51a3d342	70	NV40_PMC_BACKLIGHT_MASK) >> 16;
6ee73861 BS	71
	72	return val;
	73	}
	74
73076481 BS	75	static int
73076481 BS	76	nv40_set_intensity(struct backlight_device *bd)
6ee73861	77	{
51a3d342	78	struct nouveau_drm *drm = bl_get_data(bd);
1167c6bc	79	struct nvif_object *device = &drm->client.device.object;
6ee73861	80	int val = bd->props.brightness;
db2bec18	81	int reg = nvif_rd32(device, NV40_PMC_BACKLIGHT);
6ee73861	82
db2bec18	83	nvif_wr32(device, NV40_PMC_BACKLIGHT,
6ee73861 BS	84	(val << 16) \| (reg & ~NV40_PMC_BACKLIGHT_MASK));
	85
	86	return 0;
	87	}
	88
acc2472e	89	static const struct backlight_ops nv40_bl_ops = {
6ee73861 BS	90	.options = BL_CORE_SUSPENDRESUME,
	91	.get_brightness = nv40_get_intensity,
	92	.update_status = nv40_set_intensity,
	93	};
	94
73076481 BS	95	static int
73076481 BS	96	nv40_backlight_init(struct drm_connector *connector)
6ee73861	97	{
77145f1c	98	struct nouveau_drm *drm = nouveau_drm(connector->dev);
1167c6bc	99	struct nvif_object *device = &drm->client.device.object;
7eae3efa	100	struct backlight_properties props;
6ee73861	101	struct backlight_device *bd;
db1a0ae2 PM	102	struct backlight_connector bl_connector;
db1a0ae2 PM	103	char backlight_name[BL_NAME_SIZE];
6ee73861	104
db2bec18	105	if (!(nvif_rd32(device, NV40_PMC_BACKLIGHT) & NV40_PMC_BACKLIGHT_MASK))
6ee73861 BS	106	return 0;
6ee73861 BS	107
a19a6ee6	108	memset(&props, 0, sizeof(struct backlight_properties));
bb7ca747	109	props.type = BACKLIGHT_RAW;
a19a6ee6	110	props.max_brightness = 31;
db1a0ae2 PM	111	if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
	112	NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
	113	return 0;
	114	}
	115	bd = backlight_device_register(backlight_name , connector->kdev, drm,
a19a6ee6	116	&nv40_bl_ops, &props);
db1a0ae2 PM	117
	118	if (IS_ERR(bd)) {
	119	if (bl_connector.id > 0)
	120	ida_simple_remove(&bl_ida, bl_connector.id);
b795016c	121	return PTR_ERR(bd);
db1a0ae2 PM	122	}
db1a0ae2 PM	123	list_add(&bl_connector.head, &drm->bl_connectors);
51a3d342	124	drm->backlight = bd;
6ee73861 BS	125	bd->props.brightness = nv40_get_intensity(bd);
	126	backlight_update_status(bd);
	127
	128	return 0;
	129	}
	130
73076481 BS	131	static int
	132	nv50_get_intensity(struct backlight_device *bd)
	133	{
10b461e4	134	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	135	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
1167c6bc	136	struct nvif_object *device = &drm->client.device.object;
10b461e4	137	int or = nv_encoder->or;
09461459 BS	138	u32 div = 1025;
09461459 BS	139	u32 val;
73076481	140
db2bec18	141	val = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
5024c54b	142	val &= NV50_PDISP_SOR_PWM_CTL_VAL;
09461459	143	return ((val * 100) + (div / 2)) / div;
73076481 BS	144	}
	145
	146	static int
	147	nv50_set_intensity(struct backlight_device *bd)
	148	{
10b461e4	149	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	150	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
1167c6bc	151	struct nvif_object *device = &drm->client.device.object;
10b461e4	152	int or = nv_encoder->or;
09461459 BS	153	u32 div = 1025;
09461459 BS	154	u32 val = (bd->props.brightness * div) / 100;
73076481	155
db2bec18	156	nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or),
51a3d342	157	NV50_PDISP_SOR_PWM_CTL_NEW \| val);
73076481 BS	158	return 0;
	159	}
	160
	161	static const struct backlight_ops nv50_bl_ops = {
	162	.options = BL_CORE_SUSPENDRESUME,
	163	.get_brightness = nv50_get_intensity,
	164	.update_status = nv50_set_intensity,
	165	};
	166
5024c54b BS	167	static int
	168	nva3_get_intensity(struct backlight_device *bd)
	169	{
	170	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	171	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
1167c6bc	172	struct nvif_object *device = &drm->client.device.object;
5024c54b BS	173	int or = nv_encoder->or;
	174	u32 div, val;
	175
db2bec18 BS	176	div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
db2bec18 BS	177	val = nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(or));
5024c54b BS	178	val &= NVA3_PDISP_SOR_PWM_CTL_VAL;
	179	if (div && div >= val)
	180	return ((val * 100) + (div / 2)) / div;
	181
	182	return 100;
	183	}
	184
	185	static int
	186	nva3_set_intensity(struct backlight_device *bd)
	187	{
	188	struct nouveau_encoder *nv_encoder = bl_get_data(bd);
77145f1c	189	struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
1167c6bc	190	struct nvif_object *device = &drm->client.device.object;
5024c54b BS	191	int or = nv_encoder->or;
	192	u32 div, val;
	193
db2bec18	194	div = nvif_rd32(device, NV50_PDISP_SOR_PWM_DIV(or));
5024c54b BS	195	val = (bd->props.brightness * div) / 100;
5024c54b BS	196	if (div) {
db2bec18	197	nvif_wr32(device, NV50_PDISP_SOR_PWM_CTL(or), val \|
51a3d342 BS	198	NV50_PDISP_SOR_PWM_CTL_NEW \|
51a3d342 BS	199	NVA3_PDISP_SOR_PWM_CTL_UNK);
5024c54b BS	200	return 0;
	201	}
	202
	203	return -EINVAL;
	204	}
	205
	206	static const struct backlight_ops nva3_bl_ops = {
	207	.options = BL_CORE_SUSPENDRESUME,
	208	.get_brightness = nva3_get_intensity,
	209	.update_status = nva3_set_intensity,
	210	};
	211
73076481 BS	212	static int
73076481 BS	213	nv50_backlight_init(struct drm_connector *connector)
6ee73861	214	{
77145f1c	215	struct nouveau_drm *drm = nouveau_drm(connector->dev);
1167c6bc	216	struct nvif_object *device = &drm->client.device.object;
10b461e4	217	struct nouveau_encoder *nv_encoder;
7eae3efa	218	struct backlight_properties props;
6ee73861	219	struct backlight_device *bd;
5024c54b	220	const struct backlight_ops *ops;
db1a0ae2 PM	221	struct backlight_connector bl_connector;
db1a0ae2 PM	222	char backlight_name[BL_NAME_SIZE];
10b461e4	223
cb75d97e	224	nv_encoder = find_encoder(connector, DCB_OUTPUT_LVDS);
10b461e4	225	if (!nv_encoder) {
cb75d97e	226	nv_encoder = find_encoder(connector, DCB_OUTPUT_DP);
10b461e4 BS	227	if (!nv_encoder)
	228	return -ENODEV;
	229	}
	230
db2bec18	231	if (!nvif_rd32(device, NV50_PDISP_SOR_PWM_CTL(nv_encoder->or)))
6ee73861 BS	232	return 0;
6ee73861 BS	233
1167c6bc BS	234	if (drm->client.device.info.chipset <= 0xa0 \|\|
	235	drm->client.device.info.chipset == 0xaa \|\|
	236	drm->client.device.info.chipset == 0xac)
5024c54b BS	237	ops = &nv50_bl_ops;
	238	else
	239	ops = &nva3_bl_ops;
	240
a19a6ee6	241	memset(&props, 0, sizeof(struct backlight_properties));
bb7ca747	242	props.type = BACKLIGHT_RAW;
09461459	243	props.max_brightness = 100;
db1a0ae2 PM	244	if (!nouveau_get_backlight_name(backlight_name, &bl_connector)) {
	245	NV_ERROR(drm, "Failed to retrieve a unique name for the backlight interface\n");
	246	return 0;
	247	}
	248	bd = backlight_device_register(backlight_name , connector->kdev,
5024c54b	249	nv_encoder, ops, &props);
db1a0ae2 PM	250
	251	if (IS_ERR(bd)) {
	252	if (bl_connector.id > 0)
	253	ida_simple_remove(&bl_ida, bl_connector.id);
6ee73861	254	return PTR_ERR(bd);
db1a0ae2	255	}
6ee73861	256
db1a0ae2	257	list_add(&bl_connector.head, &drm->bl_connectors);
51a3d342	258	drm->backlight = bd;
5024c54b	259	bd->props.brightness = bd->ops->get_brightness(bd);
6ee73861 BS	260	backlight_update_status(bd);
	261	return 0;
	262	}
	263
73076481	264	int
10b461e4	265	nouveau_backlight_init(struct drm_device *dev)
6ee73861	266	{
77145f1c	267	struct nouveau_drm *drm = nouveau_drm(dev);
1167c6bc	268	struct nvif_device *device = &drm->client.device;
10b461e4	269	struct drm_connector *connector;
6ee73861	270
78d3c5de LW	271	INIT_LIST_HEAD(&drm->bl_connectors);
78d3c5de LW	272
b53ac1ee PM	273	if (apple_gmux_present()) {
	274	NV_INFO(drm, "Apple GMUX detected: not registering Nouveau backlight interface\n");
	275	return 0;
	276	}
	277
10b461e4 BS	278	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
	279	if (connector->connector_type != DRM_MODE_CONNECTOR_LVDS &&
	280	connector->connector_type != DRM_MODE_CONNECTOR_eDP)
	281	continue;
	282
967e7bde BS	283	switch (device->info.family) {
967e7bde BS	284	case NV_DEVICE_INFO_V0_CURIE:
10b461e4	285	return nv40_backlight_init(connector);
967e7bde BS	286	case NV_DEVICE_INFO_V0_TESLA:
	287	case NV_DEVICE_INFO_V0_FERMI:
	288	case NV_DEVICE_INFO_V0_KEPLER:
bbe1f94a	289	case NV_DEVICE_INFO_V0_MAXWELL:
10b461e4 BS	290	return nv50_backlight_init(connector);
	291	default:
	292	break;
	293	}
6ee73861 BS	294	}
6ee73861 BS	295
10b461e4	296
6ee73861 BS	297	return 0;
	298	}
	299
73076481	300	void
10b461e4	301	nouveau_backlight_exit(struct drm_device *dev)
6ee73861	302	{
77145f1c	303	struct nouveau_drm *drm = nouveau_drm(dev);
db1a0ae2 PM	304	struct backlight_connector *connector;
	305
	306	list_for_each_entry(connector, &drm->bl_connectors, head) {
	307	if (connector->id >= 0)
	308	ida_simple_remove(&bl_ida, connector->id);
	309	}
6ee73861	310
51a3d342 BS	311	if (drm->backlight) {
	312	backlight_device_unregister(drm->backlight);
	313	drm->backlight = NULL;
6ee73861 BS	314	}
6ee73861 BS	315	}
db1a0ae2 PM	316
	317	void
	318	nouveau_backlight_ctor(void)
	319	{
	320	ida_init(&bl_ida);
	321	}
	322
	323	void
	324	nouveau_backlight_dtor(void)
	325	{
	326	ida_destroy(&bl_ida);
	327	}