LCOV - code coverage report
Current view: top level - drivers/hwmon - hwmon.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 12 234 5.1 %
Date: 2022-04-01 14:17:54 Functions: 2 22 9.1 %
Branches: 2 150 1.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * hwmon.c - part of lm_sensors, Linux kernel modules for hardware monitoring
       4                 :            :  *
       5                 :            :  * This file defines the sysfs class "hwmon", for use by sensors drivers.
       6                 :            :  *
       7                 :            :  * Copyright (C) 2005 Mark M. Hoffman <mhoffman@lightlink.com>
       8                 :            :  */
       9                 :            : 
      10                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      11                 :            : 
      12                 :            : #include <linux/bitops.h>
      13                 :            : #include <linux/device.h>
      14                 :            : #include <linux/err.h>
      15                 :            : #include <linux/gfp.h>
      16                 :            : #include <linux/hwmon.h>
      17                 :            : #include <linux/idr.h>
      18                 :            : #include <linux/module.h>
      19                 :            : #include <linux/pci.h>
      20                 :            : #include <linux/slab.h>
      21                 :            : #include <linux/string.h>
      22                 :            : #include <linux/thermal.h>
      23                 :            : 
      24                 :            : #define CREATE_TRACE_POINTS
      25                 :            : #include <trace/events/hwmon.h>
      26                 :            : 
      27                 :            : #define HWMON_ID_PREFIX "hwmon"
      28                 :            : #define HWMON_ID_FORMAT HWMON_ID_PREFIX "%d"
      29                 :            : 
      30                 :            : struct hwmon_device {
      31                 :            :         const char *name;
      32                 :            :         struct device dev;
      33                 :            :         const struct hwmon_chip_info *chip;
      34                 :            : 
      35                 :            :         struct attribute_group group;
      36                 :            :         const struct attribute_group **groups;
      37                 :            : };
      38                 :            : 
      39                 :            : #define to_hwmon_device(d) container_of(d, struct hwmon_device, dev)
      40                 :            : 
      41                 :            : #define MAX_SYSFS_ATTR_NAME_LENGTH      32
      42                 :            : 
      43                 :            : struct hwmon_device_attribute {
      44                 :            :         struct device_attribute dev_attr;
      45                 :            :         const struct hwmon_ops *ops;
      46                 :            :         enum hwmon_sensor_types type;
      47                 :            :         u32 attr;
      48                 :            :         int index;
      49                 :            :         char name[MAX_SYSFS_ATTR_NAME_LENGTH];
      50                 :            : };
      51                 :            : 
      52                 :            : #define to_hwmon_attr(d) \
      53                 :            :         container_of(d, struct hwmon_device_attribute, dev_attr)
      54                 :            : #define to_dev_attr(a) container_of(a, struct device_attribute, attr)
      55                 :            : 
      56                 :            : /*
      57                 :            :  * Thermal zone information
      58                 :            :  * In addition to the reference to the hwmon device,
      59                 :            :  * also provides the sensor index.
      60                 :            :  */
      61                 :            : struct hwmon_thermal_data {
      62                 :            :         struct device *dev;             /* Reference to hwmon device */
      63                 :            :         int index;                      /* sensor index */
      64                 :            : };
      65                 :            : 
      66                 :            : static ssize_t
      67                 :          0 : name_show(struct device *dev, struct device_attribute *attr, char *buf)
      68                 :            : {
      69                 :          0 :         return sprintf(buf, "%s\n", to_hwmon_device(dev)->name);
      70                 :            : }
      71                 :            : static DEVICE_ATTR_RO(name);
      72                 :            : 
      73                 :            : static struct attribute *hwmon_dev_attrs[] = {
      74                 :            :         &dev_attr_name.attr,
      75                 :            :         NULL
      76                 :            : };
      77                 :            : 
      78                 :          0 : static umode_t hwmon_dev_name_is_visible(struct kobject *kobj,
      79                 :            :                                          struct attribute *attr, int n)
      80                 :            : {
      81                 :          0 :         struct device *dev = container_of(kobj, struct device, kobj);
      82                 :            : 
      83         [ #  # ]:          0 :         if (to_hwmon_device(dev)->name == NULL)
      84                 :            :                 return 0;
      85                 :            : 
      86                 :          0 :         return attr->mode;
      87                 :            : }
      88                 :            : 
      89                 :            : static const struct attribute_group hwmon_dev_attr_group = {
      90                 :            :         .attrs          = hwmon_dev_attrs,
      91                 :            :         .is_visible     = hwmon_dev_name_is_visible,
      92                 :            : };
      93                 :            : 
      94                 :            : static const struct attribute_group *hwmon_dev_attr_groups[] = {
      95                 :            :         &hwmon_dev_attr_group,
      96                 :            :         NULL
      97                 :            : };
      98                 :            : 
      99                 :          0 : static void hwmon_free_attrs(struct attribute **attrs)
     100                 :            : {
     101                 :          0 :         int i;
     102                 :            : 
     103         [ #  # ]:          0 :         for (i = 0; attrs[i]; i++) {
     104                 :          0 :                 struct device_attribute *dattr = to_dev_attr(attrs[i]);
     105                 :          0 :                 struct hwmon_device_attribute *hattr = to_hwmon_attr(dattr);
     106                 :            : 
     107                 :          0 :                 kfree(hattr);
     108                 :            :         }
     109                 :          0 :         kfree(attrs);
     110                 :          0 : }
     111                 :            : 
     112                 :          0 : static void hwmon_dev_release(struct device *dev)
     113                 :            : {
     114                 :          0 :         struct hwmon_device *hwdev = to_hwmon_device(dev);
     115                 :            : 
     116         [ #  # ]:          0 :         if (hwdev->group.attrs)
     117                 :          0 :                 hwmon_free_attrs(hwdev->group.attrs);
     118                 :          0 :         kfree(hwdev->groups);
     119                 :          0 :         kfree(hwdev);
     120                 :          0 : }
     121                 :            : 
     122                 :            : static struct class hwmon_class = {
     123                 :            :         .name = "hwmon",
     124                 :            :         .owner = THIS_MODULE,
     125                 :            :         .dev_groups = hwmon_dev_attr_groups,
     126                 :            :         .dev_release = hwmon_dev_release,
     127                 :            : };
     128                 :            : 
     129                 :            : static DEFINE_IDA(hwmon_ida);
     130                 :            : 
     131                 :            : /* Thermal zone handling */
     132                 :            : 
     133                 :            : /*
     134                 :            :  * The complex conditional is necessary to avoid a cyclic dependency
     135                 :            :  * between hwmon and thermal_sys modules.
     136                 :            :  */
     137                 :            : #ifdef CONFIG_THERMAL_OF
     138                 :            : static int hwmon_thermal_get_temp(void *data, int *temp)
     139                 :            : {
     140                 :            :         struct hwmon_thermal_data *tdata = data;
     141                 :            :         struct hwmon_device *hwdev = to_hwmon_device(tdata->dev);
     142                 :            :         int ret;
     143                 :            :         long t;
     144                 :            : 
     145                 :            :         ret = hwdev->chip->ops->read(tdata->dev, hwmon_temp, hwmon_temp_input,
     146                 :            :                                      tdata->index, &t);
     147                 :            :         if (ret < 0)
     148                 :            :                 return ret;
     149                 :            : 
     150                 :            :         *temp = t;
     151                 :            : 
     152                 :            :         return 0;
     153                 :            : }
     154                 :            : 
     155                 :            : static const struct thermal_zone_of_device_ops hwmon_thermal_ops = {
     156                 :            :         .get_temp = hwmon_thermal_get_temp,
     157                 :            : };
     158                 :            : 
     159                 :            : static int hwmon_thermal_add_sensor(struct device *dev, int index)
     160                 :            : {
     161                 :            :         struct hwmon_thermal_data *tdata;
     162                 :            :         struct thermal_zone_device *tzd;
     163                 :            : 
     164                 :            :         tdata = devm_kzalloc(dev, sizeof(*tdata), GFP_KERNEL);
     165                 :            :         if (!tdata)
     166                 :            :                 return -ENOMEM;
     167                 :            : 
     168                 :            :         tdata->dev = dev;
     169                 :            :         tdata->index = index;
     170                 :            : 
     171                 :            :         tzd = devm_thermal_zone_of_sensor_register(dev, index, tdata,
     172                 :            :                                                    &hwmon_thermal_ops);
     173                 :            :         /*
     174                 :            :          * If CONFIG_THERMAL_OF is disabled, this returns -ENODEV,
     175                 :            :          * so ignore that error but forward any other error.
     176                 :            :          */
     177                 :            :         if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV))
     178                 :            :                 return PTR_ERR(tzd);
     179                 :            : 
     180                 :            :         return 0;
     181                 :            : }
     182                 :            : #else
     183                 :            : static int hwmon_thermal_add_sensor(struct device *dev, int index)
     184                 :            : {
     185                 :            :         return 0;
     186                 :            : }
     187                 :            : #endif /* IS_REACHABLE(CONFIG_THERMAL) && ... */
     188                 :            : 
     189                 :          0 : static int hwmon_attr_base(enum hwmon_sensor_types type)
     190                 :            : {
     191                 :          0 :         if (type == hwmon_in || type == hwmon_intrusion)
     192                 :          0 :                 return 0;
     193                 :            :         return 1;
     194                 :            : }
     195                 :            : 
     196                 :            : /* sysfs attribute management */
     197                 :            : 
     198                 :          0 : static ssize_t hwmon_attr_show(struct device *dev,
     199                 :            :                                struct device_attribute *devattr, char *buf)
     200                 :            : {
     201                 :          0 :         struct hwmon_device_attribute *hattr = to_hwmon_attr(devattr);
     202                 :          0 :         long val;
     203                 :          0 :         int ret;
     204                 :            : 
     205                 :          0 :         ret = hattr->ops->read(dev, hattr->type, hattr->attr, hattr->index,
     206                 :            :                                &val);
     207         [ #  # ]:          0 :         if (ret < 0)
     208                 :          0 :                 return ret;
     209                 :            : 
     210                 :          0 :         trace_hwmon_attr_show(hattr->index + hwmon_attr_base(hattr->type),
     211         [ #  # ]:          0 :                               hattr->name, val);
     212                 :            : 
     213                 :          0 :         return sprintf(buf, "%ld\n", val);
     214                 :            : }
     215                 :            : 
     216                 :          0 : static ssize_t hwmon_attr_show_string(struct device *dev,
     217                 :            :                                       struct device_attribute *devattr,
     218                 :            :                                       char *buf)
     219                 :            : {
     220                 :          0 :         struct hwmon_device_attribute *hattr = to_hwmon_attr(devattr);
     221                 :          0 :         enum hwmon_sensor_types type = hattr->type;
     222                 :          0 :         const char *s;
     223                 :          0 :         int ret;
     224                 :            : 
     225                 :          0 :         ret = hattr->ops->read_string(dev, hattr->type, hattr->attr,
     226                 :            :                                       hattr->index, &s);
     227         [ #  # ]:          0 :         if (ret < 0)
     228                 :          0 :                 return ret;
     229                 :            : 
     230                 :          0 :         trace_hwmon_attr_show_string(hattr->index + hwmon_attr_base(type),
     231         [ #  # ]:          0 :                                      hattr->name, s);
     232                 :            : 
     233                 :          0 :         return sprintf(buf, "%s\n", s);
     234                 :            : }
     235                 :            : 
     236                 :          0 : static ssize_t hwmon_attr_store(struct device *dev,
     237                 :            :                                 struct device_attribute *devattr,
     238                 :            :                                 const char *buf, size_t count)
     239                 :            : {
     240                 :          0 :         struct hwmon_device_attribute *hattr = to_hwmon_attr(devattr);
     241                 :          0 :         long val;
     242                 :          0 :         int ret;
     243                 :            : 
     244                 :          0 :         ret = kstrtol(buf, 10, &val);
     245         [ #  # ]:          0 :         if (ret < 0)
     246                 :          0 :                 return ret;
     247                 :            : 
     248                 :          0 :         ret = hattr->ops->write(dev, hattr->type, hattr->attr, hattr->index,
     249                 :            :                                 val);
     250         [ #  # ]:          0 :         if (ret < 0)
     251                 :          0 :                 return ret;
     252                 :            : 
     253                 :          0 :         trace_hwmon_attr_store(hattr->index + hwmon_attr_base(hattr->type),
     254         [ #  # ]:          0 :                                hattr->name, val);
     255                 :            : 
     256                 :          0 :         return count;
     257                 :            : }
     258                 :            : 
     259                 :          0 : static bool is_string_attr(enum hwmon_sensor_types type, u32 attr)
     260                 :            : {
     261                 :          0 :         return (type == hwmon_temp && attr == hwmon_temp_label) ||
     262         [ #  # ]:          0 :                (type == hwmon_in && attr == hwmon_in_label) ||
     263         [ #  # ]:          0 :                (type == hwmon_curr && attr == hwmon_curr_label) ||
     264         [ #  # ]:          0 :                (type == hwmon_power && attr == hwmon_power_label) ||
     265         [ #  # ]:          0 :                (type == hwmon_energy && attr == hwmon_energy_label) ||
     266   [ #  #  #  # ]:          0 :                (type == hwmon_humidity && attr == hwmon_humidity_label) ||
     267         [ #  # ]:          0 :                (type == hwmon_fan && attr == hwmon_fan_label);
     268                 :            : }
     269                 :            : 
     270                 :          0 : static struct attribute *hwmon_genattr(const void *drvdata,
     271                 :            :                                        enum hwmon_sensor_types type,
     272                 :            :                                        u32 attr,
     273                 :            :                                        int index,
     274                 :            :                                        const char *template,
     275                 :            :                                        const struct hwmon_ops *ops)
     276                 :            : {
     277                 :          0 :         struct hwmon_device_attribute *hattr;
     278                 :          0 :         struct device_attribute *dattr;
     279                 :          0 :         struct attribute *a;
     280                 :          0 :         umode_t mode;
     281                 :          0 :         const char *name;
     282                 :          0 :         bool is_string = is_string_attr(type, attr);
     283                 :            : 
     284                 :            :         /* The attribute is invisible if there is no template string */
     285         [ #  # ]:          0 :         if (!template)
     286                 :            :                 return ERR_PTR(-ENOENT);
     287                 :            : 
     288                 :          0 :         mode = ops->is_visible(drvdata, type, attr, index);
     289         [ #  # ]:          0 :         if (!mode)
     290                 :            :                 return ERR_PTR(-ENOENT);
     291                 :            : 
     292   [ #  #  #  #  :          0 :         if ((mode & 0444) && ((is_string && !ops->read_string) ||
             #  #  #  # ]
     293         [ #  # ]:          0 :                                  (!is_string && !ops->read)))
     294                 :            :                 return ERR_PTR(-EINVAL);
     295   [ #  #  #  # ]:          0 :         if ((mode & 0222) && !ops->write)
     296                 :            :                 return ERR_PTR(-EINVAL);
     297                 :            : 
     298                 :          0 :         hattr = kzalloc(sizeof(*hattr), GFP_KERNEL);
     299         [ #  # ]:          0 :         if (!hattr)
     300                 :            :                 return ERR_PTR(-ENOMEM);
     301                 :            : 
     302         [ #  # ]:          0 :         if (type == hwmon_chip) {
     303                 :            :                 name = template;
     304                 :            :         } else {
     305         [ #  # ]:          0 :                 scnprintf(hattr->name, sizeof(hattr->name), template,
     306                 :            :                           index + hwmon_attr_base(type));
     307                 :          0 :                 name = hattr->name;
     308                 :            :         }
     309                 :            : 
     310                 :          0 :         hattr->type = type;
     311                 :          0 :         hattr->attr = attr;
     312                 :          0 :         hattr->index = index;
     313                 :          0 :         hattr->ops = ops;
     314                 :            : 
     315                 :          0 :         dattr = &hattr->dev_attr;
     316         [ #  # ]:          0 :         dattr->show = is_string ? hwmon_attr_show_string : hwmon_attr_show;
     317                 :          0 :         dattr->store = hwmon_attr_store;
     318                 :            : 
     319                 :          0 :         a = &dattr->attr;
     320                 :          0 :         sysfs_attr_init(a);
     321                 :          0 :         a->name = name;
     322                 :          0 :         a->mode = mode;
     323                 :            : 
     324                 :          0 :         return a;
     325                 :            : }
     326                 :            : 
     327                 :            : /*
     328                 :            :  * Chip attributes are not attribute templates but actual sysfs attributes.
     329                 :            :  * See hwmon_genattr() for special handling.
     330                 :            :  */
     331                 :            : static const char * const hwmon_chip_attrs[] = {
     332                 :            :         [hwmon_chip_temp_reset_history] = "temp_reset_history",
     333                 :            :         [hwmon_chip_in_reset_history] = "in_reset_history",
     334                 :            :         [hwmon_chip_curr_reset_history] = "curr_reset_history",
     335                 :            :         [hwmon_chip_power_reset_history] = "power_reset_history",
     336                 :            :         [hwmon_chip_update_interval] = "update_interval",
     337                 :            :         [hwmon_chip_alarms] = "alarms",
     338                 :            :         [hwmon_chip_samples] = "samples",
     339                 :            :         [hwmon_chip_curr_samples] = "curr_samples",
     340                 :            :         [hwmon_chip_in_samples] = "in_samples",
     341                 :            :         [hwmon_chip_power_samples] = "power_samples",
     342                 :            :         [hwmon_chip_temp_samples] = "temp_samples",
     343                 :            : };
     344                 :            : 
     345                 :            : static const char * const hwmon_temp_attr_templates[] = {
     346                 :            :         [hwmon_temp_enable] = "temp%d_enable",
     347                 :            :         [hwmon_temp_input] = "temp%d_input",
     348                 :            :         [hwmon_temp_type] = "temp%d_type",
     349                 :            :         [hwmon_temp_lcrit] = "temp%d_lcrit",
     350                 :            :         [hwmon_temp_lcrit_hyst] = "temp%d_lcrit_hyst",
     351                 :            :         [hwmon_temp_min] = "temp%d_min",
     352                 :            :         [hwmon_temp_min_hyst] = "temp%d_min_hyst",
     353                 :            :         [hwmon_temp_max] = "temp%d_max",
     354                 :            :         [hwmon_temp_max_hyst] = "temp%d_max_hyst",
     355                 :            :         [hwmon_temp_crit] = "temp%d_crit",
     356                 :            :         [hwmon_temp_crit_hyst] = "temp%d_crit_hyst",
     357                 :            :         [hwmon_temp_emergency] = "temp%d_emergency",
     358                 :            :         [hwmon_temp_emergency_hyst] = "temp%d_emergency_hyst",
     359                 :            :         [hwmon_temp_alarm] = "temp%d_alarm",
     360                 :            :         [hwmon_temp_lcrit_alarm] = "temp%d_lcrit_alarm",
     361                 :            :         [hwmon_temp_min_alarm] = "temp%d_min_alarm",
     362                 :            :         [hwmon_temp_max_alarm] = "temp%d_max_alarm",
     363                 :            :         [hwmon_temp_crit_alarm] = "temp%d_crit_alarm",
     364                 :            :         [hwmon_temp_emergency_alarm] = "temp%d_emergency_alarm",
     365                 :            :         [hwmon_temp_fault] = "temp%d_fault",
     366                 :            :         [hwmon_temp_offset] = "temp%d_offset",
     367                 :            :         [hwmon_temp_label] = "temp%d_label",
     368                 :            :         [hwmon_temp_lowest] = "temp%d_lowest",
     369                 :            :         [hwmon_temp_highest] = "temp%d_highest",
     370                 :            :         [hwmon_temp_reset_history] = "temp%d_reset_history",
     371                 :            : };
     372                 :            : 
     373                 :            : static const char * const hwmon_in_attr_templates[] = {
     374                 :            :         [hwmon_in_enable] = "in%d_enable",
     375                 :            :         [hwmon_in_input] = "in%d_input",
     376                 :            :         [hwmon_in_min] = "in%d_min",
     377                 :            :         [hwmon_in_max] = "in%d_max",
     378                 :            :         [hwmon_in_lcrit] = "in%d_lcrit",
     379                 :            :         [hwmon_in_crit] = "in%d_crit",
     380                 :            :         [hwmon_in_average] = "in%d_average",
     381                 :            :         [hwmon_in_lowest] = "in%d_lowest",
     382                 :            :         [hwmon_in_highest] = "in%d_highest",
     383                 :            :         [hwmon_in_reset_history] = "in%d_reset_history",
     384                 :            :         [hwmon_in_label] = "in%d_label",
     385                 :            :         [hwmon_in_alarm] = "in%d_alarm",
     386                 :            :         [hwmon_in_min_alarm] = "in%d_min_alarm",
     387                 :            :         [hwmon_in_max_alarm] = "in%d_max_alarm",
     388                 :            :         [hwmon_in_lcrit_alarm] = "in%d_lcrit_alarm",
     389                 :            :         [hwmon_in_crit_alarm] = "in%d_crit_alarm",
     390                 :            : };
     391                 :            : 
     392                 :            : static const char * const hwmon_curr_attr_templates[] = {
     393                 :            :         [hwmon_curr_enable] = "curr%d_enable",
     394                 :            :         [hwmon_curr_input] = "curr%d_input",
     395                 :            :         [hwmon_curr_min] = "curr%d_min",
     396                 :            :         [hwmon_curr_max] = "curr%d_max",
     397                 :            :         [hwmon_curr_lcrit] = "curr%d_lcrit",
     398                 :            :         [hwmon_curr_crit] = "curr%d_crit",
     399                 :            :         [hwmon_curr_average] = "curr%d_average",
     400                 :            :         [hwmon_curr_lowest] = "curr%d_lowest",
     401                 :            :         [hwmon_curr_highest] = "curr%d_highest",
     402                 :            :         [hwmon_curr_reset_history] = "curr%d_reset_history",
     403                 :            :         [hwmon_curr_label] = "curr%d_label",
     404                 :            :         [hwmon_curr_alarm] = "curr%d_alarm",
     405                 :            :         [hwmon_curr_min_alarm] = "curr%d_min_alarm",
     406                 :            :         [hwmon_curr_max_alarm] = "curr%d_max_alarm",
     407                 :            :         [hwmon_curr_lcrit_alarm] = "curr%d_lcrit_alarm",
     408                 :            :         [hwmon_curr_crit_alarm] = "curr%d_crit_alarm",
     409                 :            : };
     410                 :            : 
     411                 :            : static const char * const hwmon_power_attr_templates[] = {
     412                 :            :         [hwmon_power_enable] = "power%d_enable",
     413                 :            :         [hwmon_power_average] = "power%d_average",
     414                 :            :         [hwmon_power_average_interval] = "power%d_average_interval",
     415                 :            :         [hwmon_power_average_interval_max] = "power%d_interval_max",
     416                 :            :         [hwmon_power_average_interval_min] = "power%d_interval_min",
     417                 :            :         [hwmon_power_average_highest] = "power%d_average_highest",
     418                 :            :         [hwmon_power_average_lowest] = "power%d_average_lowest",
     419                 :            :         [hwmon_power_average_max] = "power%d_average_max",
     420                 :            :         [hwmon_power_average_min] = "power%d_average_min",
     421                 :            :         [hwmon_power_input] = "power%d_input",
     422                 :            :         [hwmon_power_input_highest] = "power%d_input_highest",
     423                 :            :         [hwmon_power_input_lowest] = "power%d_input_lowest",
     424                 :            :         [hwmon_power_reset_history] = "power%d_reset_history",
     425                 :            :         [hwmon_power_accuracy] = "power%d_accuracy",
     426                 :            :         [hwmon_power_cap] = "power%d_cap",
     427                 :            :         [hwmon_power_cap_hyst] = "power%d_cap_hyst",
     428                 :            :         [hwmon_power_cap_max] = "power%d_cap_max",
     429                 :            :         [hwmon_power_cap_min] = "power%d_cap_min",
     430                 :            :         [hwmon_power_min] = "power%d_min",
     431                 :            :         [hwmon_power_max] = "power%d_max",
     432                 :            :         [hwmon_power_lcrit] = "power%d_lcrit",
     433                 :            :         [hwmon_power_crit] = "power%d_crit",
     434                 :            :         [hwmon_power_label] = "power%d_label",
     435                 :            :         [hwmon_power_alarm] = "power%d_alarm",
     436                 :            :         [hwmon_power_cap_alarm] = "power%d_cap_alarm",
     437                 :            :         [hwmon_power_min_alarm] = "power%d_min_alarm",
     438                 :            :         [hwmon_power_max_alarm] = "power%d_max_alarm",
     439                 :            :         [hwmon_power_lcrit_alarm] = "power%d_lcrit_alarm",
     440                 :            :         [hwmon_power_crit_alarm] = "power%d_crit_alarm",
     441                 :            : };
     442                 :            : 
     443                 :            : static const char * const hwmon_energy_attr_templates[] = {
     444                 :            :         [hwmon_energy_enable] = "energy%d_enable",
     445                 :            :         [hwmon_energy_input] = "energy%d_input",
     446                 :            :         [hwmon_energy_label] = "energy%d_label",
     447                 :            : };
     448                 :            : 
     449                 :            : static const char * const hwmon_humidity_attr_templates[] = {
     450                 :            :         [hwmon_humidity_enable] = "humidity%d_enable",
     451                 :            :         [hwmon_humidity_input] = "humidity%d_input",
     452                 :            :         [hwmon_humidity_label] = "humidity%d_label",
     453                 :            :         [hwmon_humidity_min] = "humidity%d_min",
     454                 :            :         [hwmon_humidity_min_hyst] = "humidity%d_min_hyst",
     455                 :            :         [hwmon_humidity_max] = "humidity%d_max",
     456                 :            :         [hwmon_humidity_max_hyst] = "humidity%d_max_hyst",
     457                 :            :         [hwmon_humidity_alarm] = "humidity%d_alarm",
     458                 :            :         [hwmon_humidity_fault] = "humidity%d_fault",
     459                 :            : };
     460                 :            : 
     461                 :            : static const char * const hwmon_fan_attr_templates[] = {
     462                 :            :         [hwmon_fan_enable] = "fan%d_enable",
     463                 :            :         [hwmon_fan_input] = "fan%d_input",
     464                 :            :         [hwmon_fan_label] = "fan%d_label",
     465                 :            :         [hwmon_fan_min] = "fan%d_min",
     466                 :            :         [hwmon_fan_max] = "fan%d_max",
     467                 :            :         [hwmon_fan_div] = "fan%d_div",
     468                 :            :         [hwmon_fan_pulses] = "fan%d_pulses",
     469                 :            :         [hwmon_fan_target] = "fan%d_target",
     470                 :            :         [hwmon_fan_alarm] = "fan%d_alarm",
     471                 :            :         [hwmon_fan_min_alarm] = "fan%d_min_alarm",
     472                 :            :         [hwmon_fan_max_alarm] = "fan%d_max_alarm",
     473                 :            :         [hwmon_fan_fault] = "fan%d_fault",
     474                 :            : };
     475                 :            : 
     476                 :            : static const char * const hwmon_pwm_attr_templates[] = {
     477                 :            :         [hwmon_pwm_input] = "pwm%d",
     478                 :            :         [hwmon_pwm_enable] = "pwm%d_enable",
     479                 :            :         [hwmon_pwm_mode] = "pwm%d_mode",
     480                 :            :         [hwmon_pwm_freq] = "pwm%d_freq",
     481                 :            : };
     482                 :            : 
     483                 :            : static const char * const hwmon_intrusion_attr_templates[] = {
     484                 :            :         [hwmon_intrusion_alarm] = "intrusion%d_alarm",
     485                 :            :         [hwmon_intrusion_beep]  = "intrusion%d_beep",
     486                 :            : };
     487                 :            : 
     488                 :            : static const char * const *__templates[] = {
     489                 :            :         [hwmon_chip] = hwmon_chip_attrs,
     490                 :            :         [hwmon_temp] = hwmon_temp_attr_templates,
     491                 :            :         [hwmon_in] = hwmon_in_attr_templates,
     492                 :            :         [hwmon_curr] = hwmon_curr_attr_templates,
     493                 :            :         [hwmon_power] = hwmon_power_attr_templates,
     494                 :            :         [hwmon_energy] = hwmon_energy_attr_templates,
     495                 :            :         [hwmon_humidity] = hwmon_humidity_attr_templates,
     496                 :            :         [hwmon_fan] = hwmon_fan_attr_templates,
     497                 :            :         [hwmon_pwm] = hwmon_pwm_attr_templates,
     498                 :            :         [hwmon_intrusion] = hwmon_intrusion_attr_templates,
     499                 :            : };
     500                 :            : 
     501                 :            : static const int __templates_size[] = {
     502                 :            :         [hwmon_chip] = ARRAY_SIZE(hwmon_chip_attrs),
     503                 :            :         [hwmon_temp] = ARRAY_SIZE(hwmon_temp_attr_templates),
     504                 :            :         [hwmon_in] = ARRAY_SIZE(hwmon_in_attr_templates),
     505                 :            :         [hwmon_curr] = ARRAY_SIZE(hwmon_curr_attr_templates),
     506                 :            :         [hwmon_power] = ARRAY_SIZE(hwmon_power_attr_templates),
     507                 :            :         [hwmon_energy] = ARRAY_SIZE(hwmon_energy_attr_templates),
     508                 :            :         [hwmon_humidity] = ARRAY_SIZE(hwmon_humidity_attr_templates),
     509                 :            :         [hwmon_fan] = ARRAY_SIZE(hwmon_fan_attr_templates),
     510                 :            :         [hwmon_pwm] = ARRAY_SIZE(hwmon_pwm_attr_templates),
     511                 :            :         [hwmon_intrusion] = ARRAY_SIZE(hwmon_intrusion_attr_templates),
     512                 :            : };
     513                 :            : 
     514                 :            : static int hwmon_num_channel_attrs(const struct hwmon_channel_info *info)
     515                 :            : {
     516                 :            :         int i, n;
     517                 :            : 
     518                 :            :         for (i = n = 0; info->config[i]; i++)
     519                 :            :                 n += hweight32(info->config[i]);
     520                 :            : 
     521                 :            :         return n;
     522                 :            : }
     523                 :            : 
     524                 :            : static int hwmon_genattrs(const void *drvdata,
     525                 :            :                           struct attribute **attrs,
     526                 :            :                           const struct hwmon_ops *ops,
     527                 :            :                           const struct hwmon_channel_info *info)
     528                 :            : {
     529                 :            :         const char * const *templates;
     530                 :            :         int template_size;
     531                 :            :         int i, aindex = 0;
     532                 :            : 
     533                 :            :         if (info->type >= ARRAY_SIZE(__templates))
     534                 :            :                 return -EINVAL;
     535                 :            : 
     536                 :            :         templates = __templates[info->type];
     537                 :            :         template_size = __templates_size[info->type];
     538                 :            : 
     539                 :            :         for (i = 0; info->config[i]; i++) {
     540                 :            :                 u32 attr_mask = info->config[i];
     541                 :            :                 u32 attr;
     542                 :            : 
     543                 :            :                 while (attr_mask) {
     544                 :            :                         struct attribute *a;
     545                 :            : 
     546                 :            :                         attr = __ffs(attr_mask);
     547                 :            :                         attr_mask &= ~BIT(attr);
     548                 :            :                         if (attr >= template_size)
     549                 :            :                                 return -EINVAL;
     550                 :            :                         a = hwmon_genattr(drvdata, info->type, attr, i,
     551                 :            :                                           templates[attr], ops);
     552                 :            :                         if (IS_ERR(a)) {
     553                 :            :                                 if (PTR_ERR(a) != -ENOENT)
     554                 :            :                                         return PTR_ERR(a);
     555                 :            :                                 continue;
     556                 :            :                         }
     557                 :            :                         attrs[aindex++] = a;
     558                 :            :                 }
     559                 :            :         }
     560                 :            :         return aindex;
     561                 :            : }
     562                 :            : 
     563                 :            : static struct attribute **
     564                 :            : __hwmon_create_attrs(const void *drvdata, const struct hwmon_chip_info *chip)
     565                 :            : {
     566                 :            :         int ret, i, aindex = 0, nattrs = 0;
     567                 :            :         struct attribute **attrs;
     568                 :            : 
     569                 :            :         for (i = 0; chip->info[i]; i++)
     570                 :            :                 nattrs += hwmon_num_channel_attrs(chip->info[i]);
     571                 :            : 
     572                 :            :         if (nattrs == 0)
     573                 :            :                 return ERR_PTR(-EINVAL);
     574                 :            : 
     575                 :            :         attrs = kcalloc(nattrs + 1, sizeof(*attrs), GFP_KERNEL);
     576                 :            :         if (!attrs)
     577                 :            :                 return ERR_PTR(-ENOMEM);
     578                 :            : 
     579                 :            :         for (i = 0; chip->info[i]; i++) {
     580                 :            :                 ret = hwmon_genattrs(drvdata, &attrs[aindex], chip->ops,
     581                 :            :                                      chip->info[i]);
     582                 :            :                 if (ret < 0) {
     583                 :            :                         hwmon_free_attrs(attrs);
     584                 :            :                         return ERR_PTR(ret);
     585                 :            :                 }
     586                 :            :                 aindex += ret;
     587                 :            :         }
     588                 :            : 
     589                 :            :         return attrs;
     590                 :            : }
     591                 :            : 
     592                 :            : static struct device *
     593                 :          0 : __hwmon_device_register(struct device *dev, const char *name, void *drvdata,
     594                 :            :                         const struct hwmon_chip_info *chip,
     595                 :            :                         const struct attribute_group **groups)
     596                 :            : {
     597                 :          0 :         struct hwmon_device *hwdev;
     598                 :          0 :         struct device *hdev;
     599                 :          0 :         int i, j, err, id;
     600                 :            : 
     601                 :            :         /* Complain about invalid characters in hwmon name attribute */
     602   [ #  #  #  #  :          0 :         if (name && (!strlen(name) || strpbrk(name, "-* \t\n")))
                   #  # ]
     603                 :          0 :                 dev_warn(dev,
     604                 :            :                          "hwmon: '%s' is not a valid name attribute, please fix\n",
     605                 :            :                          name);
     606                 :            : 
     607                 :          0 :         id = ida_simple_get(&hwmon_ida, 0, 0, GFP_KERNEL);
     608         [ #  # ]:          0 :         if (id < 0)
     609                 :          0 :                 return ERR_PTR(id);
     610                 :            : 
     611                 :          0 :         hwdev = kzalloc(sizeof(*hwdev), GFP_KERNEL);
     612         [ #  # ]:          0 :         if (hwdev == NULL) {
     613                 :          0 :                 err = -ENOMEM;
     614                 :          0 :                 goto ida_remove;
     615                 :            :         }
     616                 :            : 
     617                 :          0 :         hdev = &hwdev->dev;
     618                 :            : 
     619         [ #  # ]:          0 :         if (chip) {
     620                 :          0 :                 struct attribute **attrs;
     621                 :          0 :                 int ngroups = 2; /* terminating NULL plus &hwdev->groups */
     622                 :            : 
     623         [ #  # ]:          0 :                 if (groups)
     624         [ #  # ]:          0 :                         for (i = 0; groups[i]; i++)
     625                 :          0 :                                 ngroups++;
     626                 :            : 
     627                 :          0 :                 hwdev->groups = kcalloc(ngroups, sizeof(*groups), GFP_KERNEL);
     628         [ #  # ]:          0 :                 if (!hwdev->groups) {
     629                 :          0 :                         err = -ENOMEM;
     630                 :          0 :                         goto free_hwmon;
     631                 :            :                 }
     632                 :            : 
     633                 :          0 :                 attrs = __hwmon_create_attrs(drvdata, chip);
     634         [ #  # ]:          0 :                 if (IS_ERR(attrs)) {
     635                 :          0 :                         err = PTR_ERR(attrs);
     636                 :          0 :                         goto free_hwmon;
     637                 :            :                 }
     638                 :            : 
     639                 :          0 :                 hwdev->group.attrs = attrs;
     640                 :          0 :                 ngroups = 0;
     641                 :          0 :                 hwdev->groups[ngroups++] = &hwdev->group;
     642                 :            : 
     643         [ #  # ]:          0 :                 if (groups) {
     644         [ #  # ]:          0 :                         for (i = 0; groups[i]; i++)
     645                 :          0 :                                 hwdev->groups[ngroups++] = groups[i];
     646                 :            :                 }
     647                 :            : 
     648                 :          0 :                 hdev->groups = hwdev->groups;
     649                 :            :         } else {
     650                 :          0 :                 hdev->groups = groups;
     651                 :            :         }
     652                 :            : 
     653                 :          0 :         hwdev->name = name;
     654                 :          0 :         hdev->class = &hwmon_class;
     655                 :          0 :         hdev->parent = dev;
     656         [ #  # ]:          0 :         hdev->of_node = dev ? dev->of_node : NULL;
     657                 :          0 :         hwdev->chip = chip;
     658                 :          0 :         dev_set_drvdata(hdev, drvdata);
     659                 :          0 :         dev_set_name(hdev, HWMON_ID_FORMAT, id);
     660                 :          0 :         err = device_register(hdev);
     661         [ #  # ]:          0 :         if (err)
     662                 :          0 :                 goto free_hwmon;
     663                 :            : 
     664   [ #  #  #  #  :          0 :         if (dev && dev->of_node && chip && chip->ops->read &&
             #  #  #  # ]
     665         [ #  # ]:          0 :             chip->info[0]->type == hwmon_chip &&
     666         [ #  # ]:          0 :             (chip->info[0]->config[0] & HWMON_C_REGISTER_TZ)) {
     667                 :            :                 const struct hwmon_channel_info **info = chip->info;
     668                 :            : 
     669         [ #  # ]:          0 :                 for (i = 1; info[i]; i++) {
     670         [ #  # ]:          0 :                         if (info[i]->type != hwmon_temp)
     671                 :          0 :                                 continue;
     672                 :            : 
     673         [ #  # ]:          0 :                         for (j = 0; info[i]->config[j]; j++) {
     674                 :          0 :                                 if (!chip->ops->is_visible(drvdata, hwmon_temp,
     675                 :            :                                                            hwmon_temp_input, j))
     676                 :            :                                         continue;
     677                 :          0 :                                 if (info[i]->config[j] & HWMON_T_INPUT) {
     678                 :            :                                         err = hwmon_thermal_add_sensor(hdev, j);
     679                 :            :                                         if (err) {
     680                 :            :                                                 device_unregister(hdev);
     681                 :            :                                                 /*
     682                 :            :                                                  * Don't worry about hwdev;
     683                 :            :                                                  * hwmon_dev_release(), called
     684                 :            :                                                  * from device_unregister(),
     685                 :            :                                                  * will free it.
     686                 :            :                                                  */
     687                 :            :                                                 goto ida_remove;
     688                 :            :                                         }
     689                 :            :                                 }
     690                 :            :                         }
     691                 :            :                 }
     692                 :            :         }
     693                 :            : 
     694                 :            :         return hdev;
     695                 :            : 
     696                 :          0 : free_hwmon:
     697                 :          0 :         hwmon_dev_release(hdev);
     698                 :          0 : ida_remove:
     699                 :          0 :         ida_simple_remove(&hwmon_ida, id);
     700                 :          0 :         return ERR_PTR(err);
     701                 :            : }
     702                 :            : 
     703                 :            : /**
     704                 :            :  * hwmon_device_register_with_groups - register w/ hwmon
     705                 :            :  * @dev: the parent device
     706                 :            :  * @name: hwmon name attribute
     707                 :            :  * @drvdata: driver data to attach to created device
     708                 :            :  * @groups: List of attribute groups to create
     709                 :            :  *
     710                 :            :  * hwmon_device_unregister() must be called when the device is no
     711                 :            :  * longer needed.
     712                 :            :  *
     713                 :            :  * Returns the pointer to the new device.
     714                 :            :  */
     715                 :            : struct device *
     716                 :          0 : hwmon_device_register_with_groups(struct device *dev, const char *name,
     717                 :            :                                   void *drvdata,
     718                 :            :                                   const struct attribute_group **groups)
     719                 :            : {
     720         [ #  # ]:          0 :         if (!name)
     721                 :            :                 return ERR_PTR(-EINVAL);
     722                 :            : 
     723                 :          0 :         return __hwmon_device_register(dev, name, drvdata, NULL, groups);
     724                 :            : }
     725                 :            : EXPORT_SYMBOL_GPL(hwmon_device_register_with_groups);
     726                 :            : 
     727                 :            : /**
     728                 :            :  * hwmon_device_register_with_info - register w/ hwmon
     729                 :            :  * @dev: the parent device
     730                 :            :  * @name: hwmon name attribute
     731                 :            :  * @drvdata: driver data to attach to created device
     732                 :            :  * @chip: pointer to hwmon chip information
     733                 :            :  * @extra_groups: pointer to list of additional non-standard attribute groups
     734                 :            :  *
     735                 :            :  * hwmon_device_unregister() must be called when the device is no
     736                 :            :  * longer needed.
     737                 :            :  *
     738                 :            :  * Returns the pointer to the new device.
     739                 :            :  */
     740                 :            : struct device *
     741                 :          0 : hwmon_device_register_with_info(struct device *dev, const char *name,
     742                 :            :                                 void *drvdata,
     743                 :            :                                 const struct hwmon_chip_info *chip,
     744                 :            :                                 const struct attribute_group **extra_groups)
     745                 :            : {
     746         [ #  # ]:          0 :         if (!name)
     747                 :            :                 return ERR_PTR(-EINVAL);
     748                 :            : 
     749   [ #  #  #  #  :          0 :         if (chip && (!chip->ops || !chip->ops->is_visible || !chip->info))
             #  #  #  # ]
     750                 :            :                 return ERR_PTR(-EINVAL);
     751                 :            : 
     752         [ #  # ]:          0 :         if (chip && !dev)
     753                 :            :                 return ERR_PTR(-EINVAL);
     754                 :            : 
     755                 :          0 :         return __hwmon_device_register(dev, name, drvdata, chip, extra_groups);
     756                 :            : }
     757                 :            : EXPORT_SYMBOL_GPL(hwmon_device_register_with_info);
     758                 :            : 
     759                 :            : /**
     760                 :            :  * hwmon_device_register - register w/ hwmon
     761                 :            :  * @dev: the device to register
     762                 :            :  *
     763                 :            :  * hwmon_device_unregister() must be called when the device is no
     764                 :            :  * longer needed.
     765                 :            :  *
     766                 :            :  * Returns the pointer to the new device.
     767                 :            :  */
     768                 :          0 : struct device *hwmon_device_register(struct device *dev)
     769                 :            : {
     770                 :          0 :         dev_warn(dev,
     771                 :            :                  "hwmon_device_register() is deprecated. Please convert the driver to use hwmon_device_register_with_info().\n");
     772                 :            : 
     773                 :          0 :         return __hwmon_device_register(dev, NULL, NULL, NULL, NULL);
     774                 :            : }
     775                 :            : EXPORT_SYMBOL_GPL(hwmon_device_register);
     776                 :            : 
     777                 :            : /**
     778                 :            :  * hwmon_device_unregister - removes the previously registered class device
     779                 :            :  *
     780                 :            :  * @dev: the class device to destroy
     781                 :            :  */
     782                 :          0 : void hwmon_device_unregister(struct device *dev)
     783                 :            : {
     784                 :          0 :         int id;
     785                 :            : 
     786   [ #  #  #  # ]:          0 :         if (likely(sscanf(dev_name(dev), HWMON_ID_FORMAT, &id) == 1)) {
     787                 :          0 :                 device_unregister(dev);
     788                 :          0 :                 ida_simple_remove(&hwmon_ida, id);
     789                 :            :         } else
     790                 :            :                 dev_dbg(dev->parent,
     791                 :            :                         "hwmon_device_unregister() failed: bad class ID!\n");
     792                 :          0 : }
     793                 :            : EXPORT_SYMBOL_GPL(hwmon_device_unregister);
     794                 :            : 
     795                 :          0 : static void devm_hwmon_release(struct device *dev, void *res)
     796                 :            : {
     797                 :          0 :         struct device *hwdev = *(struct device **)res;
     798                 :            : 
     799                 :          0 :         hwmon_device_unregister(hwdev);
     800                 :          0 : }
     801                 :            : 
     802                 :            : /**
     803                 :            :  * devm_hwmon_device_register_with_groups - register w/ hwmon
     804                 :            :  * @dev: the parent device
     805                 :            :  * @name: hwmon name attribute
     806                 :            :  * @drvdata: driver data to attach to created device
     807                 :            :  * @groups: List of attribute groups to create
     808                 :            :  *
     809                 :            :  * Returns the pointer to the new device. The new device is automatically
     810                 :            :  * unregistered with the parent device.
     811                 :            :  */
     812                 :            : struct device *
     813                 :          0 : devm_hwmon_device_register_with_groups(struct device *dev, const char *name,
     814                 :            :                                        void *drvdata,
     815                 :            :                                        const struct attribute_group **groups)
     816                 :            : {
     817                 :          0 :         struct device **ptr, *hwdev;
     818                 :            : 
     819         [ #  # ]:          0 :         if (!dev)
     820                 :            :                 return ERR_PTR(-EINVAL);
     821                 :            : 
     822                 :          0 :         ptr = devres_alloc(devm_hwmon_release, sizeof(*ptr), GFP_KERNEL);
     823         [ #  # ]:          0 :         if (!ptr)
     824                 :            :                 return ERR_PTR(-ENOMEM);
     825                 :            : 
     826         [ #  # ]:          0 :         hwdev = hwmon_device_register_with_groups(dev, name, drvdata, groups);
     827         [ #  # ]:          0 :         if (IS_ERR(hwdev))
     828                 :          0 :                 goto error;
     829                 :            : 
     830                 :          0 :         *ptr = hwdev;
     831                 :          0 :         devres_add(dev, ptr);
     832                 :          0 :         return hwdev;
     833                 :            : 
     834                 :            : error:
     835                 :          0 :         devres_free(ptr);
     836                 :          0 :         return hwdev;
     837                 :            : }
     838                 :            : EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_groups);
     839                 :            : 
     840                 :            : /**
     841                 :            :  * devm_hwmon_device_register_with_info - register w/ hwmon
     842                 :            :  * @dev:        the parent device
     843                 :            :  * @name:       hwmon name attribute
     844                 :            :  * @drvdata:    driver data to attach to created device
     845                 :            :  * @chip:       pointer to hwmon chip information
     846                 :            :  * @groups:     pointer to list of driver specific attribute groups
     847                 :            :  *
     848                 :            :  * Returns the pointer to the new device. The new device is automatically
     849                 :            :  * unregistered with the parent device.
     850                 :            :  */
     851                 :            : struct device *
     852                 :          0 : devm_hwmon_device_register_with_info(struct device *dev, const char *name,
     853                 :            :                                      void *drvdata,
     854                 :            :                                      const struct hwmon_chip_info *chip,
     855                 :            :                                      const struct attribute_group **groups)
     856                 :            : {
     857                 :          0 :         struct device **ptr, *hwdev;
     858                 :            : 
     859         [ #  # ]:          0 :         if (!dev)
     860                 :            :                 return ERR_PTR(-EINVAL);
     861                 :            : 
     862                 :          0 :         ptr = devres_alloc(devm_hwmon_release, sizeof(*ptr), GFP_KERNEL);
     863         [ #  # ]:          0 :         if (!ptr)
     864                 :            :                 return ERR_PTR(-ENOMEM);
     865                 :            : 
     866                 :          0 :         hwdev = hwmon_device_register_with_info(dev, name, drvdata, chip,
     867                 :            :                                                 groups);
     868         [ #  # ]:          0 :         if (IS_ERR(hwdev))
     869                 :          0 :                 goto error;
     870                 :            : 
     871                 :          0 :         *ptr = hwdev;
     872                 :          0 :         devres_add(dev, ptr);
     873                 :            : 
     874                 :          0 :         return hwdev;
     875                 :            : 
     876                 :            : error:
     877                 :          0 :         devres_free(ptr);
     878                 :          0 :         return hwdev;
     879                 :            : }
     880                 :            : EXPORT_SYMBOL_GPL(devm_hwmon_device_register_with_info);
     881                 :            : 
     882                 :          0 : static int devm_hwmon_match(struct device *dev, void *res, void *data)
     883                 :            : {
     884                 :          0 :         struct device **hwdev = res;
     885                 :            : 
     886                 :          0 :         return *hwdev == data;
     887                 :            : }
     888                 :            : 
     889                 :            : /**
     890                 :            :  * devm_hwmon_device_unregister - removes a previously registered hwmon device
     891                 :            :  *
     892                 :            :  * @dev: the parent device of the device to unregister
     893                 :            :  */
     894                 :          0 : void devm_hwmon_device_unregister(struct device *dev)
     895                 :            : {
     896         [ #  # ]:          0 :         WARN_ON(devres_release(dev, devm_hwmon_release, devm_hwmon_match, dev));
     897                 :          0 : }
     898                 :            : EXPORT_SYMBOL_GPL(devm_hwmon_device_unregister);
     899                 :            : 
     900                 :         11 : static void __init hwmon_pci_quirks(void)
     901                 :            : {
     902                 :            : #if defined CONFIG_X86 && defined CONFIG_PCI
     903                 :         11 :         struct pci_dev *sb;
     904                 :         11 :         u16 base;
     905                 :         11 :         u8 enable;
     906                 :            : 
     907                 :            :         /* Open access to 0x295-0x296 on MSI MS-7031 */
     908                 :         11 :         sb = pci_get_device(PCI_VENDOR_ID_ATI, 0x436c, NULL);
     909         [ -  + ]:         11 :         if (sb) {
     910         [ #  # ]:          0 :                 if (sb->subsystem_vendor == 0x1462 &&        /* MSI */
     911                 :            :                     sb->subsystem_device == 0x0031) {        /* MS-7031 */
     912                 :          0 :                         pci_read_config_byte(sb, 0x48, &enable);
     913                 :          0 :                         pci_read_config_word(sb, 0x64, &base);
     914                 :            : 
     915   [ #  #  #  # ]:          0 :                         if (base == 0 && !(enable & BIT(2))) {
     916                 :          0 :                                 dev_info(&sb->dev,
     917                 :            :                                          "Opening wide generic port at 0x295\n");
     918                 :          0 :                                 pci_write_config_word(sb, 0x64, 0x295);
     919                 :          0 :                                 pci_write_config_byte(sb, 0x48,
     920                 :            :                                                       enable | BIT(2));
     921                 :            :                         }
     922                 :            :                 }
     923                 :          0 :                 pci_dev_put(sb);
     924                 :            :         }
     925                 :            : #endif
     926                 :         11 : }
     927                 :            : 
     928                 :         11 : static int __init hwmon_init(void)
     929                 :            : {
     930                 :         11 :         int err;
     931                 :            : 
     932                 :         11 :         hwmon_pci_quirks();
     933                 :            : 
     934                 :         11 :         err = class_register(&hwmon_class);
     935         [ -  + ]:         11 :         if (err) {
     936                 :          0 :                 pr_err("couldn't register hwmon sysfs class\n");
     937                 :          0 :                 return err;
     938                 :            :         }
     939                 :            :         return 0;
     940                 :            : }
     941                 :            : 
     942                 :          0 : static void __exit hwmon_exit(void)
     943                 :            : {
     944                 :          0 :         class_unregister(&hwmon_class);
     945                 :          0 : }
     946                 :            : 
     947                 :            : subsys_initcall(hwmon_init);
     948                 :            : module_exit(hwmon_exit);
     949                 :            : 
     950                 :            : MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
     951                 :            : MODULE_DESCRIPTION("hardware monitoring sysfs/class support");
     952                 :            : MODULE_LICENSE("GPL");
     953                 :            : 

Generated by: LCOV version 1.14