[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / nouveau / nouveau_temp.c

/*
 * Copyright 2010 PathScale inc.
 *
 * 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 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 HOLDER(S) OR AUTHOR(S) 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: Martin Peres
 */

#include <linux/module.h>

#include "drmP.h"

#include "nouveau_drv.h"
#include "nouveau_pm.h"

static void
nouveau_temp_vbios_parse(struct drm_device *dev, u8 *temp)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
	struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;
	int i, headerlen, recordlen, entries;

	if (!temp) {
		NV_DEBUG(dev, "temperature table pointer invalid\n");
		return;
	}

	/* Set the default sensor's contants */
	sensor->offset_constant = 0;
	sensor->offset_mult = 0;
	sensor->offset_div = 1;
	sensor->slope_mult = 1;
	sensor->slope_div = 1;

	/* Set the default temperature thresholds */
	temps->critical = 110;
	temps->down_clock = 100;
	temps->fan_boost = 90;

	/* Set the default range for the pwm fan */
	pm->fan.min_duty = 30;
	pm->fan.max_duty = 100;

	/* Set the known default values to setup the temperature sensor */
	if (dev_priv->card_type >= NV_40) {
		switch (dev_priv->chipset) {
		case 0x43:
			sensor->offset_mult = 32060;
			sensor->offset_div = 1000;
			sensor->slope_mult = 792;
			sensor->slope_div = 1000;
			break;

		case 0x44:
		case 0x47:
		case 0x4a:
			sensor->offset_mult = 27839;
			sensor->offset_div = 1000;
			sensor->slope_mult = 780;
			sensor->slope_div = 1000;
			break;

		case 0x46:
			sensor->offset_mult = -24775;
			sensor->offset_div = 100;
			sensor->slope_mult = 467;
			sensor->slope_div = 10000;
			break;

		case 0x49:
			sensor->offset_mult = -25051;
			sensor->offset_div = 100;
			sensor->slope_mult = 458;
			sensor->slope_div = 10000;
			break;

		case 0x4b:
			sensor->offset_mult = -24088;
			sensor->offset_div = 100;
			sensor->slope_mult = 442;
			sensor->slope_div = 10000;
			break;

		case 0x50:
			sensor->offset_mult = -22749;
			sensor->offset_div = 100;
			sensor->slope_mult = 431;
			sensor->slope_div = 10000;
			break;

		case 0x67:
			sensor->offset_mult = -26149;
			sensor->offset_div = 100;
			sensor->slope_mult = 484;
			sensor->slope_div = 10000;
			break;
		}
	}

	headerlen = temp[1];
	recordlen = temp[2];
	entries = temp[3];
	temp = temp + headerlen;

	/* Read the entries from the table */
	for (i = 0; i < entries; i++) {
		s16 value = ROM16(temp[1]);

		switch (temp[0]) {
		case 0x01:
			if ((value & 0x8f) == 0)
				sensor->offset_constant = (value >> 9) & 0x7f;
			break;

		case 0x04:
			if ((value & 0xf00f) == 0xa000) /* core */
				temps->critical = (value&0x0ff0) >> 4;
			break;

		case 0x07:
			if ((value & 0xf00f) == 0xa000) /* core */
				temps->down_clock = (value&0x0ff0) >> 4;
			break;

		case 0x08:
			if ((value & 0xf00f) == 0xa000) /* core */
				temps->fan_boost = (value&0x0ff0) >> 4;
			break;

		case 0x10:
			sensor->offset_mult = value;
			break;

		case 0x11:
			sensor->offset_div = value;
			break;

		case 0x12:
			sensor->slope_mult = value;
			break;

		case 0x13:
			sensor->slope_div = value;
			break;
		case 0x22:
			pm->fan.min_duty = value & 0xff;
			pm->fan.max_duty = (value & 0xff00) >> 8;
			break;
		}
		temp += recordlen;
	}

	nouveau_temp_safety_checks(dev);

	/* check the fan min/max settings */
	if (pm->fan.min_duty < 10)
		pm->fan.min_duty = 10;
	if (pm->fan.max_duty > 100)
		pm->fan.max_duty = 100;
	if (pm->fan.max_duty < pm->fan.min_duty)
		pm->fan.max_duty = pm->fan.min_duty;
}

static int
nv40_sensor_setup(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
	s32 offset = sensor->offset_mult / sensor->offset_div;
	s32 sensor_calibration;

	/* set up the sensors */
	sensor_calibration = 120 - offset - sensor->offset_constant;
	sensor_calibration = sensor_calibration * sensor->slope_div /
				sensor->slope_mult;

	if (dev_priv->chipset >= 0x46)
		sensor_calibration |= 0x80000000;
	else
		sensor_calibration |= 0x10000000;

	nv_wr32(dev, 0x0015b0, sensor_calibration);

	/* Wait for the sensor to update */
	msleep(5);

	/* read */
	return nv_rd32(dev, 0x0015b4) & 0x1fff;
}

int
nv40_temp_get(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
	int offset = sensor->offset_mult / sensor->offset_div;
	int core_temp;

	if (dev_priv->card_type >= NV_50) {
		core_temp = nv_rd32(dev, 0x20008);
	} else {
		core_temp = nv_rd32(dev, 0x0015b4) & 0x1fff;
		/* Setup the sensor if the temperature is 0 */
		if (core_temp == 0)
			core_temp = nv40_sensor_setup(dev);
	}

	core_temp = core_temp * sensor->slope_mult / sensor->slope_div;
	core_temp = core_temp + offset + sensor->offset_constant;

	return core_temp;
}

int
nv84_temp_get(struct drm_device *dev)
{
	return nv_rd32(dev, 0x20400);
}

void
nouveau_temp_safety_checks(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;

	if (temps->critical > 120)
		temps->critical = 120;
	else if (temps->critical < 80)
		temps->critical = 80;

	if (temps->down_clock > 110)
		temps->down_clock = 110;
	else if (temps->down_clock < 60)
		temps->down_clock = 60;

	if (temps->fan_boost > 100)
		temps->fan_boost = 100;
	else if (temps->fan_boost < 40)
		temps->fan_boost = 40;
}

static bool
probe_monitoring_device(struct nouveau_i2c_chan *i2c,
			struct i2c_board_info *info)
{
	struct i2c_client *client;

	request_module("%s%s", I2C_MODULE_PREFIX, info->type);

	client = i2c_new_device(&i2c->adapter, info);
	if (!client)
		return false;

	if (!client->driver || client->driver->detect(client, info)) {
		i2c_unregister_device(client);
		return false;
	}

	return true;
}

static void
nouveau_temp_probe_i2c(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct dcb_table *dcb = &dev_priv->vbios.dcb;
	struct i2c_board_info info[] = {
		{ I2C_BOARD_INFO("w83l785ts", 0x2d) },
		{ I2C_BOARD_INFO("w83781d", 0x2d) },
		{ I2C_BOARD_INFO("adt7473", 0x2e) },
		{ I2C_BOARD_INFO("f75375", 0x2e) },
		{ I2C_BOARD_INFO("lm99", 0x4c) },
		{ }
	};
	int idx = (dcb->version >= 0x40 ?
		   dcb->i2c_default_indices & 0xf : 2);

	nouveau_i2c_identify(dev, "monitoring device", info,
			     probe_monitoring_device, idx);
}

void
nouveau_temp_init(struct drm_device *dev)
{
	struct drm_nouveau_private *dev_priv = dev->dev_private;
	struct nvbios *bios = &dev_priv->vbios;
	struct bit_entry P;
	u8 *temp = NULL;

	if (bios->type == NVBIOS_BIT) {
		if (bit_table(dev, 'P', &P))
			return;

		if (P.version == 1)
			temp = ROMPTR(bios, P.data[12]);
		else if (P.version == 2)
			temp = ROMPTR(bios, P.data[16]);
		else
			NV_WARN(dev, "unknown temp for BIT P %d\n", P.version);

		nouveau_temp_vbios_parse(dev, temp);
	}

	nouveau_temp_probe_i2c(dev);
}

void
nouveau_temp_fini(struct drm_device *dev)
{

}
Commit	Line	Data
34e9d85a MP	1	/*
	2	* Copyright 2010 PathScale inc.
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice shall be included in
	12	* all copies or substantial portions of the Software.
	13	*
	14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	17	* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
	18	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	19	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	20	* OTHER DEALINGS IN THE SOFTWARE.
	21	*
	22	* Authors: Martin Peres
	23	*/
	24
e0cd3608 PG	25	#include <linux/module.h>
e0cd3608 PG	26
34e9d85a MP	27	#include "drmP.h"
	28
	29	#include "nouveau_drv.h"
	30	#include "nouveau_pm.h"
	31
5c4abd09	32	static void
34e9d85a MP	33	nouveau_temp_vbios_parse(struct drm_device dev, u8 temp)
	34	{
	35	struct drm_nouveau_private *dev_priv = dev->dev_private;
	36	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	37	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
	38	struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;
	39	int i, headerlen, recordlen, entries;
	40
	41	if (!temp) {
	42	NV_DEBUG(dev, "temperature table pointer invalid\n");
	43	return;
	44	}
	45
	46	/* Set the default sensor's contants */
	47	sensor->offset_constant = 0;
40ce4279	48	sensor->offset_mult = 0;
34e9d85a MP	49	sensor->offset_div = 1;
	50	sensor->slope_mult = 1;
	51	sensor->slope_div = 1;
	52
	53	/* Set the default temperature thresholds */
	54	temps->critical = 110;
	55	temps->down_clock = 100;
	56	temps->fan_boost = 90;
	57
11b7d895 MP	58	/* Set the default range for the pwm fan */
	59	pm->fan.min_duty = 30;
	60	pm->fan.max_duty = 100;
	61
34e9d85a MP	62	/* Set the known default values to setup the temperature sensor */
	63	if (dev_priv->card_type >= NV_40) {
	64	switch (dev_priv->chipset) {
	65	case 0x43:
	66	sensor->offset_mult = 32060;
	67	sensor->offset_div = 1000;
	68	sensor->slope_mult = 792;
	69	sensor->slope_div = 1000;
	70	break;
	71
	72	case 0x44:
	73	case 0x47:
d34ec507	74	case 0x4a:
34e9d85a MP	75	sensor->offset_mult = 27839;
	76	sensor->offset_div = 1000;
	77	sensor->slope_mult = 780;
	78	sensor->slope_div = 1000;
	79	break;
	80
	81	case 0x46:
	82	sensor->offset_mult = -24775;
	83	sensor->offset_div = 100;
	84	sensor->slope_mult = 467;
	85	sensor->slope_div = 10000;
	86	break;
	87
	88	case 0x49:
	89	sensor->offset_mult = -25051;
	90	sensor->offset_div = 100;
	91	sensor->slope_mult = 458;
	92	sensor->slope_div = 10000;
	93	break;
	94
	95	case 0x4b:
	96	sensor->offset_mult = -24088;
	97	sensor->offset_div = 100;
	98	sensor->slope_mult = 442;
	99	sensor->slope_div = 10000;
	100	break;
	101
	102	case 0x50:
	103	sensor->offset_mult = -22749;
	104	sensor->offset_div = 100;
	105	sensor->slope_mult = 431;
	106	sensor->slope_div = 10000;
	107	break;
6d13e9c1 EV	108
	109	case 0x67:
	110	sensor->offset_mult = -26149;
	111	sensor->offset_div = 100;
	112	sensor->slope_mult = 484;
	113	sensor->slope_div = 10000;
	114	break;
34e9d85a MP	115	}
	116	}
	117
	118	headerlen = temp[1];
	119	recordlen = temp[2];
	120	entries = temp[3];
	121	temp = temp + headerlen;
	122
	123	/* Read the entries from the table */
	124	for (i = 0; i < entries; i++) {
40ce4279	125	s16 value = ROM16(temp[1]);
34e9d85a MP	126
	127	switch (temp[0]) {
	128	case 0x01:
67e1d4fb FJ	129	if ((value & 0x8f) == 0)
67e1d4fb FJ	130	sensor->offset_constant = (value >> 9) & 0x7f;
34e9d85a MP	131	break;
	132
	133	case 0x04:
	134	if ((value & 0xf00f) == 0xa000) /* core */
	135	temps->critical = (value&0x0ff0) >> 4;
	136	break;
	137
	138	case 0x07:
	139	if ((value & 0xf00f) == 0xa000) /* core */
	140	temps->down_clock = (value&0x0ff0) >> 4;
	141	break;
	142
	143	case 0x08:
	144	if ((value & 0xf00f) == 0xa000) /* core */
	145	temps->fan_boost = (value&0x0ff0) >> 4;
	146	break;
	147
	148	case 0x10:
	149	sensor->offset_mult = value;
	150	break;
	151
	152	case 0x11:
	153	sensor->offset_div = value;
	154	break;
	155
	156	case 0x12:
	157	sensor->slope_mult = value;
	158	break;
	159
	160	case 0x13:
	161	sensor->slope_div = value;
	162	break;
11b7d895 MP	163	case 0x22:
	164	pm->fan.min_duty = value & 0xff;
	165	pm->fan.max_duty = (value & 0xff00) >> 8;
	166	break;
34e9d85a MP	167	}
	168	temp += recordlen;
	169	}
	170
	171	nouveau_temp_safety_checks(dev);
11b7d895 MP	172
	173	/* check the fan min/max settings */
	174	if (pm->fan.min_duty < 10)
	175	pm->fan.min_duty = 10;
	176	if (pm->fan.max_duty > 100)
	177	pm->fan.max_duty = 100;
	178	if (pm->fan.max_duty < pm->fan.min_duty)
	179	pm->fan.max_duty = pm->fan.min_duty;
34e9d85a MP	180	}
34e9d85a MP	181
8155cac4 FJ	182	static int
8155cac4 FJ	183	nv40_sensor_setup(struct drm_device *dev)
34e9d85a MP	184	{
	185	struct drm_nouveau_private *dev_priv = dev->dev_private;
	186	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	187	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
40ce4279 EV	188	s32 offset = sensor->offset_mult / sensor->offset_div;
40ce4279 EV	189	s32 sensor_calibration;
34e9d85a MP	190
	191	/* set up the sensors */
	192	sensor_calibration = 120 - offset - sensor->offset_constant;
	193	sensor_calibration = sensor_calibration * sensor->slope_div /
	194	sensor->slope_mult;
	195
	196	if (dev_priv->chipset >= 0x46)
	197	sensor_calibration \|= 0x80000000;
	198	else
	199	sensor_calibration \|= 0x10000000;
	200
	201	nv_wr32(dev, 0x0015b0, sensor_calibration);
	202
	203	/* Wait for the sensor to update */
	204	msleep(5);
	205
	206	/* read */
4164743c	207	return nv_rd32(dev, 0x0015b4) & 0x1fff;
34e9d85a MP	208	}
34e9d85a MP	209
8155cac4 FJ	210	int
8155cac4 FJ	211	nv40_temp_get(struct drm_device *dev)
34e9d85a MP	212	{
	213	struct drm_nouveau_private *dev_priv = dev->dev_private;
	214	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	215	struct nouveau_pm_temp_sensor_constants *sensor = &pm->sensor_constants;
8155cac4 FJ	216	int offset = sensor->offset_mult / sensor->offset_div;
8155cac4 FJ	217	int core_temp;
34e9d85a	218
c1b60ece	219	if (dev_priv->card_type >= NV_50) {
8155cac4	220	core_temp = nv_rd32(dev, 0x20008);
34e9d85a	221	} else {
8155cac4 FJ	222	core_temp = nv_rd32(dev, 0x0015b4) & 0x1fff;
	223	/* Setup the sensor if the temperature is 0 */
	224	if (core_temp == 0)
	225	core_temp = nv40_sensor_setup(dev);
34e9d85a MP	226	}
34e9d85a MP	227
8155cac4 FJ	228	core_temp = core_temp * sensor->slope_mult / sensor->slope_div;
	229	core_temp = core_temp + offset + sensor->offset_constant;
	230
	231	return core_temp;
	232	}
	233
	234	int
	235	nv84_temp_get(struct drm_device *dev)
	236	{
	237	return nv_rd32(dev, 0x20400);
34e9d85a MP	238	}
	239
	240	void
	241	nouveau_temp_safety_checks(struct drm_device *dev)
	242	{
	243	struct drm_nouveau_private *dev_priv = dev->dev_private;
	244	struct nouveau_pm_engine *pm = &dev_priv->engine.pm;
	245	struct nouveau_pm_threshold_temp *temps = &pm->threshold_temp;
	246
	247	if (temps->critical > 120)
	248	temps->critical = 120;
	249	else if (temps->critical < 80)
	250	temps->critical = 80;
	251
	252	if (temps->down_clock > 110)
	253	temps->down_clock = 110;
	254	else if (temps->down_clock < 60)
	255	temps->down_clock = 60;
	256
	257	if (temps->fan_boost > 100)
	258	temps->fan_boost = 100;
	259	else if (temps->fan_boost < 40)
	260	temps->fan_boost = 40;
	261	}
	262
66146da0 FJ	263	static bool
	264	probe_monitoring_device(struct nouveau_i2c_chan *i2c,
	265	struct i2c_board_info *info)
	266	{
66146da0 FJ	267	struct i2c_client *client;
66146da0 FJ	268
f17811df	269	request_module("%s%s", I2C_MODULE_PREFIX, info->type);
66146da0 FJ	270
	271	client = i2c_new_device(&i2c->adapter, info);
	272	if (!client)
	273	return false;
	274
	275	if (!client->driver \|\| client->driver->detect(client, info)) {
	276	i2c_unregister_device(client);
	277	return false;
	278	}
	279
	280	return true;
	281	}
	282
	283	static void
	284	nouveau_temp_probe_i2c(struct drm_device *dev)
	285	{
	286	struct drm_nouveau_private *dev_priv = dev->dev_private;
	287	struct dcb_table *dcb = &dev_priv->vbios.dcb;
	288	struct i2c_board_info info[] = {
	289	{ I2C_BOARD_INFO("w83l785ts", 0x2d) },
	290	{ I2C_BOARD_INFO("w83781d", 0x2d) },
66146da0	291	{ I2C_BOARD_INFO("adt7473", 0x2e) },
b26e72fb	292	{ I2C_BOARD_INFO("f75375", 0x2e) },
66146da0 FJ	293	{ I2C_BOARD_INFO("lm99", 0x4c) },
	294	{ }
	295	};
	296	int idx = (dcb->version >= 0x40 ?
	297	dcb->i2c_default_indices & 0xf : 2);
	298
	299	nouveau_i2c_identify(dev, "monitoring device", info,
	300	probe_monitoring_device, idx);
	301	}
	302
34e9d85a MP	303	void
	304	nouveau_temp_init(struct drm_device *dev)
	305	{
	306	struct drm_nouveau_private *dev_priv = dev->dev_private;
	307	struct nvbios *bios = &dev_priv->vbios;
	308	struct bit_entry P;
	309	u8 *temp = NULL;
	310
	311	if (bios->type == NVBIOS_BIT) {
	312	if (bit_table(dev, 'P', &P))
	313	return;
	314
	315	if (P.version == 1)
	316	temp = ROMPTR(bios, P.data[12]);
	317	else if (P.version == 2)
	318	temp = ROMPTR(bios, P.data[16]);
	319	else
	320	NV_WARN(dev, "unknown temp for BIT P %d\n", P.version);
66146da0 FJ	321
66146da0 FJ	322	nouveau_temp_vbios_parse(dev, temp);
34e9d85a MP	323	}
34e9d85a MP	324
66146da0	325	nouveau_temp_probe_i2c(dev);
34e9d85a MP	326	}
	327
	328	void
	329	nouveau_temp_fini(struct drm_device *dev)
	330	{
	331
	332	}