[Nouveau] [PATCH 1/1] nouveau_hwmon: migrate to hwmon_device_register_with_info
Oscar Salvador
osalvador.vilardaga at gmail.com
Wed Apr 12 07:19:25 UTC 2017
Sorry for that. I'll split the patch and I'll come again ;)
El dia 11/04/2017 22:12, "Karol Herbst" <karolherbst at gmail.com> va escriure:
thanks for the work, but could you please split that patch?
It looks like you are doing several things at once and it isn't really
easy to review like this. And it isn't bisectable.
If there are clean ups here, please do it in a seperate patch. I
highly doubt that it all has to be done within one single big patch.
2017-04-11 18:54 GMT+02:00 Oscar Salvador <osalvador.vilardaga at gmail.com>:
> Hi,
>
> this patch replaces the old hwmon_device_register with the new
> hwmon_device_register_with_info.
> I've tested it on my laptop with a GeForceGT 425M and it doesn't break
anything.
>
>
> --- linux/drivers/gpu/drm/nouveau/nouveau_hwmon.c.orig 2017-04-11
18:27:15.477623009 +0200
> +++ linux/drivers/gpu/drm/nouveau/nouveau_hwmon.c 2017-04-11
18:45:41.918688215 +0200
> @@ -1,5 +1,6 @@
> /*
> - * Copyright 2010 Red Hat Inc.
> + * Copyright 2010 Red Hat Inc. (Ben Skeggs)
> + * Copyright 2017 Oscar Salvador
> *
> * Permission is hereby granted, free of charge, to any person obtaining
a
> * copy of this software and associated documentation files (the
"Software"),
> @@ -19,7 +20,6 @@
> * 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
> @@ -38,21 +38,17 @@
> #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)
> +static int
> +nouveau_hwmon_show_temp(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> int temp = nvkm_therm_temp_get(therm);
>
> if (temp < 0)
> return temp;
>
> - return snprintf(buf, PAGE_SIZE, "%d\n", temp * 1000);
> + return (temp * 1000);
> }
> -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,
> @@ -60,7 +56,7 @@ nouveau_hwmon_show_temp1_auto_point1_pwm
> {
> return snprintf(buf, PAGE_SIZE, "%d\n", 100);
> }
> -static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, S_IRUGO,
> +static SENSOR_DEVICE_ATTR(temp1_auto_point1_pwm, 0444,
> nouveau_hwmon_show_temp1_auto_point1_pwm, NULL,
0);
>
> static ssize_t
> @@ -92,7 +88,7 @@ nouveau_hwmon_set_temp1_auto_point1_temp
>
> return count;
> }
> -static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IRUGO | S_IWUSR,
> +static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, 0644,
> nouveau_hwmon_temp1_auto_point1_temp,
> nouveau_hwmon_set_temp1_auto_point1_temp, 0);
>
> @@ -125,319 +121,176 @@ nouveau_hwmon_set_temp1_auto_point1_temp
>
> return count;
> }
> -static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, S_IRUGO | S_IWUSR,
> +static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp_hyst, 0644,
> 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)
> +static int
> +nouveau_hwmon_max_temp(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK) *
1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_max_temp(struct device *d, struct device_attribute *a,
> - const char *buf, size_t
count)
> +
> +static int
> +nouveau_hwmon_set_max_temp(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.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;
> + therm->attr_set(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK, val / 1000);
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_max_temp_hyst(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_DOWN_CLK_HYST)
> + * 1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_max_temp_hyst(struct device *d, struct
device_attribute *a,
> - const char *buf, size_t
count)
> +
> +static int
> +nouveau_hwmon_set_max_temp_hyst(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.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;
> + val / 1000);
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_critical_temp(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL) *
1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_critical_temp(struct device *d, struct
device_attribute *a,
> - const char
*buf,
> - size_t
count)
> +
> +static int
> +nouveau_hwmon_set_critical_temp(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - long value;
> -
> - if (kstrtol(buf, 10, &value) == -EINVAL)
> - return count;
>
> - therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL, value /
1000);
> + therm->attr_set(therm, NVKM_THERM_ATTR_THRS_CRITICAL, val / 1000);
>
> - return count;
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_critical_temp_hyst(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_CRITICAL_HYST)
> + * 1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_critical_temp_hyst(struct device *d,
> - struct device_attribute *a,
> - const char *buf,
> - size_t count)
> +
> +static int
> +nouveau_hwmon_set_critical_temp_hyst(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.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;
> + val / 1000);
> + return val;
> }
> -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)
> +
> +static int
> +nouveau_hwmon_emergency_temp(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN) *
1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_emergency_temp(struct device *d, struct
device_attribute *a,
> - const char
*buf,
> - size_t
count)
> +
> +static int
> +nouveau_hwmon_set_emergency_temp(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - long value;
> -
> - if (kstrtol(buf, 10, &value) == -EINVAL)
> - return count;
> -
> - therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN, value /
1000);
>
> - return count;
> + therm->attr_set(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN, val / 1000);
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_emergency_temp_hyst(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
> - therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST) *
1000);
> + return (therm->attr_get(therm, NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST)
> + * 1000);
> }
> -static ssize_t
> -nouveau_hwmon_set_emergency_temp_hyst(struct device *d,
> - struct device_attribute *a,
> - const char *buf,
> - size_t count)
> +
> +static int
> +nouveau_hwmon_set_emergency_temp_hyst(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.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;
> -}
> -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");
> + val / 1000);
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_show_update_rate(struct nouveau_drm *drm)
> {
> - return sprintf(buf, "1000\n");
> + return 1000;
> }
> -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)
> +static int
> +nouveau_hwmon_show_fan1_input(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
>
> - return snprintf(buf, PAGE_SIZE, "%d\n",
nvkm_therm_fan_sense(therm));
> + return nvkm_therm_fan_sense(therm);
> }
> -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)
> +static int
> +nouveau_hwmon_get_pwm1_enable(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - int ret;
>
> - ret = therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MODE);
> - if (ret < 0)
> - return ret;
> -
> - return sprintf(buf, "%i\n", ret);
> + return therm->attr_get(therm, NVKM_THERM_ATTR_FAN_MODE);
> }
>
> -static ssize_t
> -nouveau_hwmon_set_pwm1_enable(struct device *d, struct device_attribute
*a,
> - const char *buf, size_t count)
> +static int
> +nouveau_hwmon_set_pwm1_enable(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - long value;
> int ret;
>
> - ret = kstrtol(buf, 10, &value);
> + ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MODE, val);
> if (ret)
> return ret;
> -
> - ret = therm->attr_set(therm, NVKM_THERM_ATTR_FAN_MODE, value);
> - if (ret)
> - return ret;
> - else
> - return count;
> + return val;
> }
> -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)
> +static int
> +nouveau_hwmon_get_pwm1(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - int ret;
>
> - ret = therm->fan_get(therm);
> - if (ret < 0)
> - return ret;
> -
> - return sprintf(buf, "%i\n", ret);
> + return therm->fan_get(therm);
> }
>
> -static ssize_t
> -nouveau_hwmon_set_pwm1(struct device *d, struct device_attribute *a,
> - const char *buf, size_t count)
> +static int
> +nouveau_hwmon_set_pwm1(struct nouveau_drm *drm, long val)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> int ret = -ENODEV;
> - long value;
>
> - if (kstrtol(buf, 10, &value) == -EINVAL)
> - return -EINVAL;
> -
> - ret = therm->fan_set(therm, value);
> + ret = therm->fan_set(therm, val);
> if (ret)
> return ret;
> -
> - return count;
> + return val;
> }
>
> -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 device_attribute *a, char *buf)
> {
> struct drm_device *dev = dev_get_drvdata(d);
> struct nouveau_drm *drm = nouveau_drm(dev);
> @@ -453,7 +306,7 @@ nouveau_hwmon_get_pwm1_min(struct device
>
> static ssize_t
> nouveau_hwmon_set_pwm1_min(struct device *d, struct device_attribute *a,
> - const char *buf, size_t count)
> + const char *buf, size_t count)
> {
> struct drm_device *dev = dev_get_drvdata(d);
> struct nouveau_drm *drm = nouveau_drm(dev);
> @@ -471,13 +324,13 @@ nouveau_hwmon_set_pwm1_min(struct device
> return count;
> }
>
> -static SENSOR_DEVICE_ATTR(pwm1_min, S_IRUGO | S_IWUSR,
> - nouveau_hwmon_get_pwm1_min,
> - nouveau_hwmon_set_pwm1_min, 0);
> +static SENSOR_DEVICE_ATTR(pwm1_min, 0644,
> + 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 device_attribute *a, char *buf)
> {
> struct drm_device *dev = dev_get_drvdata(d);
> struct nouveau_drm *drm = nouveau_drm(dev);
> @@ -493,7 +346,7 @@ nouveau_hwmon_get_pwm1_max(struct device
>
> static ssize_t
> nouveau_hwmon_set_pwm1_max(struct device *d, struct device_attribute *a,
> - const char *buf, size_t count)
> + const char *buf, size_t count)
> {
> struct drm_device *dev = dev_get_drvdata(d);
> struct nouveau_drm *drm = nouveau_drm(dev);
> @@ -511,16 +364,13 @@ nouveau_hwmon_set_pwm1_max(struct device
> return count;
> }
>
> -static SENSOR_DEVICE_ATTR(pwm1_max, S_IRUGO | S_IWUSR,
> - nouveau_hwmon_get_pwm1_max,
> - nouveau_hwmon_set_pwm1_max, 0);
> +static SENSOR_DEVICE_ATTR(pwm1_max, 0644,
> + 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)
> +static int
> +nouveau_hwmon_get_in0_input(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
> int ret;
>
> @@ -528,169 +378,524 @@ nouveau_hwmon_get_in0_input(struct devic
> if (ret < 0)
> return ret;
>
> - return sprintf(buf, "%i\n", ret / 1000);
> + return (ret / 1000);
> }
>
> -static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO,
> - nouveau_hwmon_get_in0_input, NULL, 0);
> -
> -static ssize_t
> -nouveau_hwmon_get_in0_min(struct device *d,
> - struct device_attribute *a, char *buf)
> +static int
> +nouveau_hwmon_get_in0_min(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
>
> if (!volt || !volt->min_uv)
> return -ENODEV;
>
> - return sprintf(buf, "%i\n", volt->min_uv / 1000);
> + return (volt->min_uv / 1000);
> }
>
> -static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO,
> - nouveau_hwmon_get_in0_min, NULL, 0);
> -
> -static ssize_t
> -nouveau_hwmon_get_in0_max(struct device *d,
> - struct device_attribute *a, char *buf)
> +static int
> +nouveau_hwmon_get_in0_max(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
>
> if (!volt || !volt->max_uv)
> return -ENODEV;
>
> - return sprintf(buf, "%i\n", volt->max_uv / 1000);
> + return (volt->max_uv / 1000);
> }
>
> -static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO,
> - nouveau_hwmon_get_in0_max, NULL, 0);
> -
> -static ssize_t
> -nouveau_hwmon_get_in0_label(struct device *d,
> - struct device_attribute *a, char *buf)
> +static int
> +nouveau_hwmon_get_power1_input(struct nouveau_drm *drm)
> {
> - return sprintf(buf, "GPU core\n");
> -}
> -
> -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->client.
device);
> int result = nvkm_iccsense_read_all(iccsense);
>
> - if (result < 0)
> - return result;
> -
> - return sprintf(buf, "%i\n", result);
> + return result;
> }
>
> -static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO,
> - nouveau_hwmon_get_power1_input, NULL, 0);
> -
> -static ssize_t
> -nouveau_hwmon_get_power1_max(struct device *d, struct device_attribute
*a,
> - char *buf)
> +static int
> +nouveau_hwmon_get_power1_max(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.
device);
> - return sprintf(buf, "%i\n", iccsense->power_w_max);
> -}
>
> -static SENSOR_DEVICE_ATTR(power1_max, S_IRUGO,
> - nouveau_hwmon_get_power1_max, NULL, 0);
> + return iccsense->power_w_max;
> +}
>
> -static ssize_t
> -nouveau_hwmon_get_power1_crit(struct device *d, struct device_attribute
*a,
> - char *buf)
> +static int
> +nouveau_hwmon_get_power1_crit(struct nouveau_drm *drm)
> {
> - struct drm_device *dev = dev_get_drvdata(d);
> - struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.
device);
> - return sprintf(buf, "%i\n", iccsense->power_w_crit);
> -}
>
> -static SENSOR_DEVICE_ATTR(power1_crit, S_IRUGO,
> - nouveau_hwmon_get_power1_crit, NULL, 0);
> + return iccsense->power_w_crit;
> +}
>
> -static struct attribute *hwmon_default_attributes[] = {
> - &sensor_dev_attr_name.dev_attr.attr,
> - &sensor_dev_attr_update_rate.dev_attr.attr,
> +static struct attribute *pwm_fan_sensor_attrs[] = {
> + &sensor_dev_attr_pwm1_min.dev_attr.attr,
> + &sensor_dev_attr_pwm1_max.dev_attr.attr,
> NULL
> };
> -static struct attribute *hwmon_temp_attributes[] = {
> - &sensor_dev_attr_temp1_input.dev_attr.attr,
> +ATTRIBUTE_GROUPS(pwm_fan_sensor);
> +
> +static struct attribute *temp1_auto_point_sensor_attrs[] = {
> &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
> +ATTRIBUTE_GROUPS(temp1_auto_point_sensor);
> +
> +#define N_ATTR_GROUPS 3
> +
> +static const u32 nouveau_config_chip[] = {
> + HWMON_C_UPDATE_INTERVAL,
> + 0
> };
> -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 const u32 nouveau_config_in[] = {
> + HWMON_I_INPUT | HWMON_I_MIN | HWMON_I_MAX | HWMON_I_LABEL,
> + 0
> };
>
> -static struct attribute *hwmon_in0_attributes[] = {
> - &sensor_dev_attr_in0_input.dev_attr.attr,
> - &sensor_dev_attr_in0_min.dev_attr.attr,
> - &sensor_dev_attr_in0_max.dev_attr.attr,
> - &sensor_dev_attr_in0_label.dev_attr.attr,
> - NULL
> +static const u32 nouveau_config_temp[] = {
> + HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
> + HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_EMERGENCY |
> + HWMON_T_EMERGENCY_HYST,
> + 0
> };
>
> -static struct attribute *hwmon_power_attributes[] = {
> - &sensor_dev_attr_power1_input.dev_attr.attr,
> - NULL
> +static const u32 nouveau_config_fan[] = {
> + HWMON_F_INPUT,
> + 0
> };
>
> -static struct attribute *hwmon_power_caps_attributes[] = {
> - &sensor_dev_attr_power1_max.dev_attr.attr,
> - &sensor_dev_attr_power1_crit.dev_attr.attr,
> - NULL
> +static const u32 nouveau_config_pwm[] = {
> + HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
> + 0
> };
>
> -static const struct attribute_group hwmon_default_attrgroup = {
> - .attrs = hwmon_default_attributes,
> +static const u32 nouveau_config_power[] = {
> + HWMON_P_INPUT | HWMON_P_CAP_MAX | HWMON_P_CRIT,
> + 0
> };
> -static const struct attribute_group hwmon_temp_attrgroup = {
> - .attrs = hwmon_temp_attributes,
> +
> +static const struct hwmon_channel_info nouveau_chip = {
> + .type = hwmon_chip,
> + .config = nouveau_config_chip,
> };
> -static const struct attribute_group hwmon_fan_rpm_attrgroup = {
> - .attrs = hwmon_fan_rpm_attributes,
> +
> +static const struct hwmon_channel_info nouveau_temp = {
> + .type = hwmon_temp,
> + .config = nouveau_config_temp,
> };
> -static const struct attribute_group hwmon_pwm_fan_attrgroup = {
> - .attrs = hwmon_pwm_fan_attributes,
> +
> +static const struct hwmon_channel_info nouveau_fan = {
> + .type = hwmon_fan,
> + .config = nouveau_config_fan,
> };
> -static const struct attribute_group hwmon_in0_attrgroup = {
> - .attrs = hwmon_in0_attributes,
> +
> +static const struct hwmon_channel_info nouveau_in = {
> + .type = hwmon_in,
> + .config = nouveau_config_in,
> +};
> +
> +static const struct hwmon_channel_info nouveau_pwm = {
> + .type = hwmon_pwm,
> + .config = nouveau_config_pwm,
> };
> -static const struct attribute_group hwmon_power_attrgroup = {
> - .attrs = hwmon_power_attributes,
> +
> +static const struct hwmon_channel_info nouveau_power = {
> + .type = hwmon_power,
> + .config = nouveau_config_power,
> };
> -static const struct attribute_group hwmon_power_caps_attrgroup = {
> - .attrs = hwmon_power_caps_attributes,
> +
> +static const struct hwmon_channel_info *nouveau_info[] = {
> + &nouveau_chip,
> + &nouveau_temp,
> + &nouveau_fan,
> + &nouveau_in,
> + &nouveau_pwm,
> + &nouveau_power,
> + NULL
> +};
> +
> +static umode_t
> +nouveau_chip_is_visible(const void *data, u32 attr, int channel)
> +{
> + switch (attr) {
> + case hwmon_chip_update_interval:
> + return 0444;
> + default:
> + return 0;
> + }
> +}
> +
> +static umode_t
> +nouveau_power_is_visible(const void *data, u32 attr, int channel)
> +{
> + struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
> + struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.
device);
> +
> + switch (attr) {
> + case hwmon_power_input:
> + if (iccsense && iccsense->data_valid &&
> + !list_empty(&iccsense->rails))
> + return 0444;
> + case hwmon_power_max:
> + case hwmon_power_crit:
> + if (iccsense->power_w_max && iccsense->power_w_crit)
> + return 0444;
> + default:
> + return 0;
> + }
> +
> +}
> +
> +static umode_t
> +nouveau_temp_is_visible(const void *data, u32 attr, int channel)
> +{
> + struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
> + struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> +
> + if (therm && therm->attr_get && therm->attr_set)
> + if (nvkm_therm_temp_get(therm) < 0)
> + return 0;
> +
> + switch (attr) {
> + case hwmon_temp_input:
> + return 0444;
> + case hwmon_temp_max:
> + case hwmon_temp_max_hyst:
> + case hwmon_temp_crit:
> + case hwmon_temp_crit_hyst:
> + case hwmon_temp_emergency:
> + case hwmon_temp_emergency_hyst:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static umode_t
> +nouveau_pwm_is_visible(const void *data, u32 attr, int channel)
> +{
> + struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
> + struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> +
> + if (therm && therm->attr_get)
> + if (therm->fan_get && therm->fan_get(therm) < 0)
> + return 0;
> +
> + switch (attr) {
> + case hwmon_pwm_enable:
> + case hwmon_pwm_input:
> + return 0644;
> + default:
> + return 0;
> + }
> +}
> +
> +static umode_t
> +nouveau_input_is_visible(const void *data, u32 attr, int channel)
> +{
> + struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
> + struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
> +
> + if (!volt || nvkm_volt_get(volt) < 0)
> + return 0;
> +
> + switch (attr) {
> + case hwmon_in_input:
> + case hwmon_in_label:
> + case hwmon_in_min:
> + case hwmon_in_max:
> + return 0444;
> + default:
> + return 0;
> + }
> +}
> +
> +static umode_t
> +nouveau_fan_is_visible(const void *data, u32 attr, int channel)
> +{
> + struct nouveau_drm *drm = nouveau_drm((struct drm_device *)data);
> + struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> +
> + if (!therm || !therm->attr_get || nvkm_therm_fan_sense(therm) < 0)
> + return 0;
> +
> + switch (attr) {
> + case hwmon_fan_input:
> + return 0444;
> + default:
> + return 0;
> + }
> +}
> +
> +static int
> +nouveau_chip_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_chip_update_interval:
> + *val = nouveau_hwmon_show_update_rate(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_temp_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_temp_input:
> + *val = nouveau_hwmon_show_temp(drm);
> + break;
> + case hwmon_temp_max:
> + *val = nouveau_hwmon_max_temp(drm);
> + break;
> + case hwmon_temp_max_hyst:
> + *val = nouveau_hwmon_max_temp_hyst(drm);
> + break;
> + case hwmon_temp_crit:
> + *val = nouveau_hwmon_critical_temp(drm);
> + break;
> + case hwmon_temp_crit_hyst:
> + *val = nouveau_hwmon_critical_temp_hyst(drm);
> + break;
> + case hwmon_temp_emergency:
> + *val = nouveau_hwmon_emergency_temp(drm);
> + break;
> + case hwmon_temp_emergency_hyst:
> + *val = nouveau_hwmon_emergency_temp_hyst(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_fan_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_fan_input:
> + *val = nouveau_hwmon_show_fan1_input(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_in_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_in_input:
> + *val = nouveau_hwmon_get_in0_input(drm);
> + break;
> + case hwmon_in_min:
> + *val = nouveau_hwmon_get_in0_min(drm);
> + break;
> + case hwmon_in_max:
> + *val = nouveau_hwmon_get_in0_max(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_pwm_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_pwm_enable:
> + *val = nouveau_hwmon_get_pwm1_enable(drm);
> + break;
> + case hwmon_pwm_input:
> + *val = nouveau_hwmon_get_pwm1(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_power_read(struct device *dev, u32 attr, int channel, long *val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_power_input:
> + *val = nouveau_hwmon_get_power1_input(drm);
> + break;
> + case hwmon_power_max:
> + *val = nouveau_hwmon_get_power1_max(drm);
> + break;
> + case hwmon_power_crit:
> + *val = nouveau_hwmon_get_power1_crit(drm);
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_temp_write(struct device *dev, u32 attr, int channel, long val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_temp_max:
> + nouveau_hwmon_set_max_temp(drm, val);
> + break;
> + case hwmon_temp_max_hyst:
> + nouveau_hwmon_set_max_temp_hyst(drm, val);
> + break;
> + case hwmon_temp_crit:
> + nouveau_hwmon_set_critical_temp(drm, val);
> + break;
> + case hwmon_temp_crit_hyst:
> + nouveau_hwmon_set_critical_temp_hyst(drm, val);
> + break;
> + case hwmon_temp_emergency:
> + nouveau_hwmon_set_emergency_temp(drm, val);
> + break;
> + case hwmon_temp_emergency_hyst:
> + nouveau_hwmon_set_emergency_temp_hyst(drm, val);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static int
> +nouveau_pwm_write(struct device *dev, u32 attr, int channel, long val)
> +{
> + struct drm_device *drm_dev = dev_get_drvdata(dev);
> + struct nouveau_drm *drm = nouveau_drm(drm_dev);
> +
> + switch (attr) {
> + case hwmon_pwm_input:
> + nouveau_hwmon_set_pwm1(drm, val);
> + break;
> + case hwmon_pwm_enable:
> + nouveau_hwmon_set_pwm1_enable(drm, val);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static umode_t
> +nouveau_is_visible(const void *data, enum hwmon_sensor_types type, u32
attr,
> + int
channel)
> +{
> + switch (type) {
> + case hwmon_chip:
> + return nouveau_chip_is_visible(data, attr, channel);
> + case hwmon_temp:
> + return nouveau_temp_is_visible(data, attr, channel);
> + case hwmon_fan:
> + return nouveau_fan_is_visible(data, attr, channel);
> + case hwmon_in:
> + return nouveau_input_is_visible(data, attr, channel);
> + case hwmon_pwm:
> + return nouveau_pwm_is_visible(data, attr, channel);
> + case hwmon_power:
> + return nouveau_power_is_visible(data, attr, channel);
> + default:
> + return 0;
> + }
> +}
> +
> +
> +static char *input_label = "GPU core";
> +
> +static int
> +nouveau_read_string(struct device *dev, enum hwmon_sensor_types type,
u32 attr,
> + int channel, char **buf)
> +{
> + if (type == hwmon_in && attr == hwmon_in_label) {
> + *buf = input_label;
> + return 0;
> + }
> +
> + return -EOPNOTSUPP;
> +}
> +
> +static int
> +nouveau_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
> + int channel, long *val)
> +{
> + switch (type) {
> + case hwmon_chip:
> + return nouveau_chip_read(dev, attr, channel, val);
> + case hwmon_temp:
> + return nouveau_temp_read(dev, attr, channel, val);
> + case hwmon_fan:
> + return nouveau_fan_read(dev, attr, channel, val);
> + case hwmon_in:
> + return nouveau_in_read(dev, attr, channel, val);
> + case hwmon_pwm:
> + return nouveau_pwm_read(dev, attr, channel, val);
> + case hwmon_power:
> + return nouveau_power_read(dev, attr, channel, val);
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static int
> +nouveau_write(struct device *dev, enum hwmon_sensor_types type, u32 attr,
> + int channel, long val)
> +{
> + switch (type) {
> + case hwmon_temp:
> + return nouveau_temp_write(dev, attr, channel, val);
> + case hwmon_pwm:
> + return nouveau_pwm_write(dev, attr, channel, val);
> + default:
> + return -EOPNOTSUPP;
> + }
> +}
> +
> +static const struct hwmon_ops nouveau_hwmon_ops = {
> + .is_visible = nouveau_is_visible,
> + .read = nouveau_read,
> + .read_string = nouveau_read_string,
> + .write = nouveau_write,
> +};
> +
> +static const struct hwmon_chip_info nouveau_chip_info = {
> + .ops = &nouveau_hwmon_ops,
> + .info = nouveau_info,
> };
> #endif
>
> @@ -700,90 +905,36 @@ nouveau_hwmon_init(struct drm_device *de
> #if defined(CONFIG_HWMON) || (defined(MODULE) &&
defined(CONFIG_HWMON_MODULE))
> struct nouveau_drm *drm = nouveau_drm(dev);
> struct nvkm_therm *therm = nvxx_therm(&drm->client.device);
> - struct nvkm_volt *volt = nvxx_volt(&drm->client.device);
> - struct nvkm_iccsense *iccsense = nvxx_iccsense(&drm->client.
device);
> struct nouveau_hwmon *hwmon;
> struct device *hwmon_dev;
> + const struct attribute_group *special_groups[N_ATTR_GROUPS];
> int ret = 0;
> + int i = 0;
>
> hwmon = drm->hwmon = kzalloc(sizeof(*hwmon), GFP_KERNEL);
> if (!hwmon)
> return -ENOMEM;
> hwmon->dev = dev;
>
> - hwmon_dev = hwmon_device_register(dev->dev);
> + if (therm && therm->attr_get && therm->attr_set) {
> + if (nvkm_therm_temp_get(therm) >= 0)
> + special_groups[i++] = &temp1_auto_point_sensor_
group;
> + if (therm->fan_get && therm->fan_get(therm) >= 0)
> + special_groups[i++] = &pwm_fan_sensor_group;
> + }
> +
> + special_groups[i] = 0;
> + hwmon_dev = hwmon_device_register_with_info(dev->dev, "nouveau",
dev,
> + &nouveau_chip_info,
special_groups);
> +
> 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;
> -
> - if (iccsense->power_w_max && iccsense->power_w_crit) {
> - ret = sysfs_create_group(&hwmon_dev->kobj,
> -
&hwmon_power_caps_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
> @@ -795,17 +946,8 @@ nouveau_hwmon_fini(struct drm_device *de
> #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);
> - sysfs_remove_group(&hwmon->hwmon->kobj,
&hwmon_power_caps_attrgroup);
> -
> + if (hwmon->hwmon)
> hwmon_device_unregister(hwmon->hwmon);
> - }
>
> nouveau_drm(dev)->hwmon = NULL;
> kfree(hwmon);
> _______________________________________________
> Nouveau mailing list
> Nouveau at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/nouveau
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.freedesktop.org/archives/dri-devel/attachments/20170412/6fde56bc/attachment-0001.html>
More information about the dri-devel
mailing list