Release 4.7 drivers/gpu/drm/nouveau/nouveau_hwmon.c

Directory: drivers/gpu/drm/nouveau
/*
 * Copyright 2010 Red Hat 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: Ben Skeggs
 */

#ifdef CONFIG_ACPI
#include <linux/acpi.h>
#endif
#include <linux/power_supply.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>

#include <drm/drmP.h>

#include "nouveau_drv.h"
#include "nouveau_hwmon.h"

#include <nvkm/subdev/iccsense.h>
#include <nvkm/subdev/volt.h>

#if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))

static ssize_t

nouveau_hwmon_show_temp(struct device *d, struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int temp = nvkm_therm_temp_get(therm);

	if (temp < 0)
		return temp;

	return snprintf(buf, PAGE_SIZE, "%d\n", temp * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 75 89.29% 11 84.62%
martin peres martin peres 9 10.71% 2 15.38%
Total 84 100.00% 13 100.00%

static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, nouveau_hwmon_show_temp,
						  NULL, 0);


static ssize_t

nouveau_hwmon_show_temp1_auto_point1_pwm(struct device *d,
					 struct device_attribute *a, char *buf)
{
	return snprintf(buf, PAGE_SIZE, "%d\n", 100);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 32 100.00% 3 100.00%
Total 32 100.00% 3 100.00%

static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO,
			  nouveau_hwmon_show_temp1_auto_point1_pwm, NULL, 0);


static ssize_t

nouveau_hwmon_temp1_auto_point1_temp(struct device *d,
				     struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	      therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 74 100.00% 10 100.00%
Total 74 100.00% 10 100.00%


static ssize_t

nouveau_hwmon_set_temp1_auto_point1_temp(struct device *d,
					 struct device_attribute *a,
					 const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST,
			value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 87 92.55% 8 80.00%
martin peres martin peres 7 7.45% 2 20.00%
Total 94 100.00% 10 100.00%

static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_temp1_auto_point1_temp,
			  nouveau_hwmon_set_temp1_auto_point1_temp, 0);


static ssize_t

nouveau_hwmon_temp1_auto_point1_temp_hyst(struct device *d,
					  struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	 therm->attr_get(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 74 100.00% 9 100.00%
Total 74 100.00% 9 100.00%


static ssize_t

nouveau_hwmon_set_temp1_auto_point1_temp_hyst(struct device *d,
					      struct device_attribute *a,
					      const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_FAN_BOOST_HYST,
			value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 94 100.00% 10 100.00%
Total 94 100.00% 10 100.00%

static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_temp1_auto_point1_temp_hyst,
			  nouveau_hwmon_set_temp1_auto_point1_temp_hyst, 0);


static ssize_t

nouveau_hwmon_max_temp(struct device *d, struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	       therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 73 98.65% 9 90.00%
martin peres martin peres 1 1.35% 1 10.00%
Total 74 100.00% 10 100.00%


static ssize_t

nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a,
						const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK, value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 91 96.81% 9 90.00%
martin peres martin peres 3 3.19% 1 10.00%
Total 94 100.00% 10 100.00%

static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, nouveau_hwmon_max_temp,
						  nouveau_hwmon_set_max_temp,
						  0);


static ssize_t

nouveau_hwmon_max_temp_hyst(struct device *d, struct device_attribute *a,
			    char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	  therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 68 91.89% 8 88.89%
martin peres martin peres 6 8.11% 1 11.11%
Total 74 100.00% 9 100.00%


static ssize_t

nouveau_hwmon_set_max_temp_hyst(struct device *d, struct device_attribute *a,
						const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST,
			value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 85 90.43% 11 84.62%
martin peres martin peres 9 9.57% 2 15.38%
Total 94 100.00% 13 100.00%

static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_max_temp_hyst,
			  nouveau_hwmon_set_max_temp_hyst, 0);


static ssize_t

nouveau_hwmon_critical_temp(struct device *d, struct device_attribute *a,
							char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	       therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 71 95.95% 8 88.89%
martin peres martin peres 3 4.05% 1 11.11%
Total 74 100.00% 9 100.00%


static ssize_t

nouveau_hwmon_set_critical_temp(struct device *d, struct device_attribute *a,
							    const char *buf,
								size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL, value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 92 97.87% 8 88.89%
francisco jerez francisco jerez 2 2.13% 1 11.11%
Total 94 100.00% 9 100.00%

static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR,
						nouveau_hwmon_critical_temp,
						nouveau_hwmon_set_critical_temp,
						0);


static ssize_t

nouveau_hwmon_critical_temp_hyst(struct device *d, struct device_attribute *a,
							char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	  therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 71 95.95% 9 90.00%
martin peres martin peres 3 4.05% 1 10.00%
Total 74 100.00% 10 100.00%


static ssize_t

nouveau_hwmon_set_critical_temp_hyst(struct device *d,
				     struct device_attribute *a,
				     const char *buf,
				     size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST,
			value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 94 100.00% 12 100.00%
Total 94 100.00% 12 100.00%

static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_critical_temp_hyst,
			  nouveau_hwmon_set_critical_temp_hyst, 0);

static ssize_t

nouveau_hwmon_emergency_temp(struct device *d, struct device_attribute *a,
							char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	       therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 72 97.30% 8 88.89%
francisco jerez francisco jerez 2 2.70% 1 11.11%
Total 74 100.00% 9 100.00%


static ssize_t

nouveau_hwmon_set_emergency_temp(struct device *d, struct device_attribute *a,
							    const char *buf,
								size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN, value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 93 98.94% 8 88.89%
martin peres martin peres 1 1.06% 1 11.11%
Total 94 100.00% 9 100.00%

static SENSOR_DEVICE_ATTR(temp1_emergency, S_IRUGO | S_IWUSR,
					nouveau_hwmon_emergency_temp,
					nouveau_hwmon_set_emergency_temp,
					0);


static ssize_t

nouveau_hwmon_emergency_temp_hyst(struct device *d, struct device_attribute *a,
							char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n",
	  therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST) * 1000);
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 74 100.00% 7 100.00%
Total 74 100.00% 7 100.00%


static ssize_t

nouveau_hwmon_set_emergency_temp_hyst(struct device *d,
				      struct device_attribute *a,
				      const char *buf,
				      size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return count;

	therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST,
			value / 1000);

	return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 76 80.85% 8 72.73%
martin peres martin peres 18 19.15% 3 27.27%
Total 94 100.00% 11 100.00%

static SENSOR_DEVICE_ATTR(temp1_emergency_hyst, S_IRUGO | S_IWUSR,
					nouveau_hwmon_emergency_temp_hyst,
					nouveau_hwmon_set_emergency_temp_hyst,
					0);



static ssize_t nouveau_hwmon_show_name(struct device *dev,
				      struct device_attribute *attr,
				      char *buf)
{
	return sprintf(buf, "nouveau\n");
}
Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 18 64.29% 1 33.33%
ben skeggs ben skeggs 10 35.71% 2 66.67%
Total 28 100.00% 3 100.00%

static SENSOR_DEVICE_ATTR(name, S_IRUGO, nouveau_hwmon_show_name, NULL, 0);



static ssize_t nouveau_hwmon_show_update_rate(struct device *dev,
				      struct device_attribute *attr,
				      char *buf)
{
	return sprintf(buf, "1000\n");
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 25 89.29% 1 50.00%
martin peres martin peres 3 10.71% 1 50.00%
Total 28 100.00% 2 100.00%

static SENSOR_DEVICE_ATTR(update_rate, S_IRUGO,
						nouveau_hwmon_show_update_rate,
						NULL, 0);


static ssize_t

nouveau_hwmon_show_fan1_input(struct device *d, struct device_attribute *attr,
			      char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);

	return snprintf(buf, PAGE_SIZE, "%d\n", nvkm_therm_fan_sense(therm));
}
Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 62 91.18% 1 16.67%
ben skeggs ben skeggs 6 8.82% 5 83.33%
Total 68 100.00% 6 100.00%

static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, nouveau_hwmon_show_fan1_input,
			  NULL, 0);

 
static ssize_t

nouveau_hwmon_get_pwm1_enable(struct device *d,
			   struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int ret;

	ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MODE);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", ret);
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 51 59.30% 1 16.67%
ben skeggs ben skeggs 35 40.70% 5 83.33%
Total 86 100.00% 6 100.00%


static ssize_t

nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute *a,
			   const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;
	int ret;

	ret = kstrtol(buf, 10, &value);
	if (ret)
		return ret;

	ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MODE, value);
	if (ret)
		return ret;
	else
		return count;
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 77 72.64% 5 71.43%
martin peres martin peres 21 19.81% 1 14.29%
jingoo han jingoo han 8 7.55% 1 14.29%
Total 106 100.00% 7 100.00%

static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_get_pwm1_enable,
			  nouveau_hwmon_set_pwm1_enable, 0);


static ssize_t

nouveau_hwmon_get_pwm1(struct device *d, struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int ret;

	ret = therm->fan_get(therm);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", ret);
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 56 66.67% 1 20.00%
ben skeggs ben skeggs 28 33.33% 4 80.00%
Total 84 100.00% 5 100.00%


static ssize_t

nouveau_hwmon_set_pwm1(struct device *d, struct device_attribute *a,
		       const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int ret = -ENODEV;
	long value;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return -EINVAL;

	ret = therm->fan_set(therm, value);
	if (ret)
		return ret;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 84 79.25% 1 20.00%
ben skeggs ben skeggs 22 20.75% 4 80.00%
Total 106 100.00% 5 100.00%

static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_get_pwm1,
			  nouveau_hwmon_set_pwm1, 0);


static ssize_t

nouveau_hwmon_get_pwm1_min(struct device *d,
			   struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int ret;

	ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MIN_DUTY);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", ret);
}

Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 56 65.12% 7 70.00%
martin peres martin peres 30 34.88% 3 30.00%
Total 86 100.00% 10 100.00%


static ssize_t

nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a,
			   const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;
	int ret;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return -EINVAL;

	ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MIN_DUTY, value);
	if (ret < 0)
		return ret;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 85 79.44% 1 16.67%
ben skeggs ben skeggs 22 20.56% 5 83.33%
Total 107 100.00% 6 100.00%

static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_get_pwm1_min,
			  nouveau_hwmon_set_pwm1_min, 0);


static ssize_t

nouveau_hwmon_get_pwm1_max(struct device *d,
			   struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	int ret;

	ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MAX_DUTY);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", ret);
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 58 67.44% 1 16.67%
ben skeggs ben skeggs 28 32.56% 5 83.33%
Total 86 100.00% 6 100.00%


static ssize_t

nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a,
			   const char *buf, size_t count)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	long value;
	int ret;

	if (kstrtol(buf, 10, &value) == -EINVAL)
		return -EINVAL;

	ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MAX_DUTY, value);
	if (ret < 0)
		return ret;

	return count;
}

Contributors
Person Tokens Prop Commits CommitProp
martin peres martin peres 86 80.37% 1 16.67%
ben skeggs ben skeggs 21 19.63% 5 83.33%
Total 107 100.00% 6 100.00%

static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO | S_IWUSR,
			  nouveau_hwmon_get_pwm1_max,
			  nouveau_hwmon_set_pwm1_max, 0);


static ssize_t

nouveau_hwmon_get_in0_input(struct device *d,
			    struct device_attribute *a, char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_volt *volt = nvxx_volt(&drm->device);
	int ret;

	ret = nvkm_volt_get(volt);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%i\n", ret / 1000);
}

Contributors
Person Tokens Prop Commits CommitProp
karol herbst karol herbst 84 100.00% 1 100.00%
Total 84 100.00% 1 100.00%

static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO,
			  nouveau_hwmon_get_in0_input, NULL, 0);


static ssize_t

nouveau_hwmon_get_in0_label(struct device *d,
			    struct device_attribute *a, char *buf)
{
	return sprintf(buf, "GPU core\n");
}

Contributors
Person Tokens Prop Commits CommitProp
karol herbst karol herbst 28 100.00% 1 100.00%
Total 28 100.00% 1 100.00%

static SENSOR_DEVICE_ATTR(in0_label, S_IRUGO,
			  nouveau_hwmon_get_in0_label, NULL, 0);


static ssize_t

nouveau_hwmon_get_power1_input(struct device *d, struct device_attribute *a,
			       char *buf)
{
	struct drm_device *dev = dev_get_drvdata(d);
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->device);
	int result = nvkm_iccsense_read_all(iccsense);

	if (result < 0)
		return result;

	return sprintf(buf, "%i\n", result);
}

Contributors
Person Tokens Prop Commits CommitProp
karol herbst karol herbst 80 100.00% 1 100.00%
Total 80 100.00% 1 100.00%

static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO,
			  nouveau_hwmon_get_power1_input, NULL, 0);


static struct attribute *hwmon_default_attributes[] = {
	&sensor_dev_attr_name.dev_attr.attr,
	&sensor_dev_attr_update_rate.dev_attr.attr,
	NULL
};

static struct attribute *hwmon_temp_attributes[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp1_auto_point1_pwm.dev_attr.attr,
	&sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
	&sensor_dev_attr_temp1_auto_point1_temp_hyst.dev_attr.attr,
	&sensor_dev_attr_temp1_max.dev_attr.attr,
	&sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
	&sensor_dev_attr_temp1_crit.dev_attr.attr,
	&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
	&sensor_dev_attr_temp1_emergency.dev_attr.attr,
	&sensor_dev_attr_temp1_emergency_hyst.dev_attr.attr,
	NULL
};

static struct attribute *hwmon_fan_rpm_attributes[] = {
	&sensor_dev_attr_fan1_input.dev_attr.attr,
	NULL
};

static struct attribute *hwmon_pwm_fan_attributes[] = {
	&sensor_dev_attr_pwm1_enable.dev_attr.attr,
	&sensor_dev_attr_pwm1.dev_attr.attr,
	&sensor_dev_attr_pwm1_min.dev_attr.attr,
	&sensor_dev_attr_pwm1_max.dev_attr.attr,
	NULL
};


static struct attribute *hwmon_in0_attributes[] = {
	&sensor_dev_attr_in0_input.dev_attr.attr,
	&sensor_dev_attr_in0_label.dev_attr.attr,
	NULL
};


static struct attribute *hwmon_power_attributes[] = {
	&sensor_dev_attr_power1_input.dev_attr.attr,
	NULL
};


static const struct attribute_group hwmon_default_attrgroup = {
	.attrs = hwmon_default_attributes,
};

static const struct attribute_group hwmon_temp_attrgroup = {
	.attrs = hwmon_temp_attributes,
};

static const struct attribute_group hwmon_fan_rpm_attrgroup = {
	.attrs = hwmon_fan_rpm_attributes,
};

static const struct attribute_group hwmon_pwm_fan_attrgroup = {
	.attrs = hwmon_pwm_fan_attributes,
};

static const struct attribute_group hwmon_in0_attrgroup = {
	.attrs = hwmon_in0_attributes,
};

static const struct attribute_group hwmon_power_attrgroup = {
	.attrs = hwmon_power_attributes,
};
#endif


int

nouveau_hwmon_init(struct drm_device *dev)
{
#if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
	struct nouveau_drm *drm = nouveau_drm(dev);
	struct nvkm_therm *therm = nvxx_therm(&drm->device);
	struct nvkm_volt *volt = nvxx_volt(&drm->device);
	struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->device);
	struct nouveau_hwmon *hwmon;
	struct device *hwmon_dev;
	int ret = 0;

	hwmon = drm->hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL);
	if (!hwmon)
		return -ENOMEM;
	hwmon->dev = dev;

	hwmon_dev = hwmon_device_register(dev->dev);
	if (IS_ERR(hwmon_dev)) {
		ret = PTR_ERR(hwmon_dev);
		NV_ERROR(drm, "Unable to register hwmon device: %d\n", ret);
		return ret;
	}
	dev_set_drvdata(hwmon_dev, dev);

	/* set the default attributes */
	ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_default_attrgroup);
	if (ret)
		goto error;

	if (therm && therm->attr_get && therm->attr_set) {
		/* if the card has a working thermal sensor */
		if (nvkm_therm_temp_get(therm) >= 0) {
			ret = sysfs_create_group(&hwmon_dev->kobj, &hwmon_temp_attrgroup);
			if (ret)
				goto error;
		}

		/* if the card has a pwm fan */
		/*XXX: incorrect, need better detection for this, some boards have
                 *     the gpio entries for pwm fan control even when there's no
                 *     actual fan connected to it... therm table? */
		if (therm->fan_get && therm->fan_get(therm) >= 0) {
			ret = sysfs_create_group(&hwmon_dev->kobj,
						 &hwmon_pwm_fan_attrgroup);
			if (ret)
				goto error;
		}
	}

	/* if the card can read the fan rpm */
	if (therm && nvkm_therm_fan_sense(therm) >= 0) {
		ret = sysfs_create_group(&hwmon_dev->kobj,
					 &hwmon_fan_rpm_attrgroup);
		if (ret)
			goto error;
	}

	if (volt && nvkm_volt_get(volt) >= 0) {
		ret = sysfs_create_group(&hwmon_dev->kobj,
					 &hwmon_in0_attrgroup);

		if (ret)
			goto error;
	}

	if (iccsense && iccsense->data_valid && !list_empty(&iccsense->rails)) {
		ret = sysfs_create_group(&hwmon_dev->kobj,
					 &hwmon_power_attrgroup);
		if (ret)
			goto error;
	}

	hwmon->hwmon = hwmon_dev;

	return 0;

error:
	NV_ERROR(drm, "Unable to create some hwmon sysfs files: %d\n", ret);
	hwmon_device_unregister(hwmon_dev);
	hwmon->hwmon = NULL;
	return ret;
#else
	return 0;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 255 60.57% 10 58.82%
karol herbst karol herbst 115 27.32% 4 23.53%
martin peres martin peres 50 11.88% 2 11.76%
roy spliet roy spliet 1 0.24% 1 5.88%
Total 421 100.00% 17 100.00%


void

nouveau_hwmon_fini(struct drm_device *dev)
{
#if defined(CONFIG_HWMON) || (defined(MODULE) && defined(CONFIG_HWMON_MODULE))
	struct nouveau_hwmon *hwmon = nouveau_hwmon(dev);

	if (hwmon->hwmon) {
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_default_attrgroup);
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_temp_attrgroup);
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_pwm_fan_attrgroup);
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_fan_rpm_attrgroup);
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_in0_attrgroup);
		sysfs_remove_group(&hwmon->hwmon->kobj, &hwmon_power_attrgroup);

		hwmon_device_unregister(hwmon->hwmon);
	}

	nouveau_drm(dev)->hwmon = NULL;
	kfree(hwmon);
#endif
}
Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 98 66.67% 6 60.00%
karol herbst karol herbst 26 17.69% 2 20.00%
martin peres martin peres 20 13.61% 1 10.00%
roy spliet roy spliet 3 2.04% 1 10.00%
Total 147 100.00% 10 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
ben skeggs ben skeggs 2496 66.51% 26 59.09%
martin peres martin peres 788 21.00% 9 20.45%
karol herbst karol herbst 450 11.99% 4 9.09%
jingoo han jingoo han 8 0.21% 1 2.27%
francisco jerez francisco jerez 6 0.16% 2 4.55%
roy spliet roy spliet 4 0.11% 1 2.27%
linus torvalds linus torvalds 1 0.03% 1 2.27%
Total 3753 100.00% 44 100.00%
  Directory: drivers/gpu/drm/nouveau

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
ben skeggs	ben skeggs	75	89.29%	11	84.62%
martin peres	martin peres	9	10.71%	2	15.38%
	Total	84	100.00%	13	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/gpu/drm/nouveau/nouveau_hwmon.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
