Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * HWMON driver for ASUS B550/X570 motherboards that publish sensor
0004  * values via the embedded controller registers.
0005  *
0006  * Copyright (C) 2021 Eugene Shalygin <eugene.shalygin@gmail.com>
0007  * Copyright (C) 2018-2019 Ed Brindley <kernel@maidavale.org>
0008  *
0009  * EC provides:
0010  * - Chipset temperature
0011  * - CPU temperature
0012  * - Motherboard temperature
0013  * - T_Sensor temperature
0014  * - VRM temperature
0015  * - Water In temperature
0016  * - Water Out temperature
0017  * - CPU Optional Fan RPM
0018  * - Chipset Fan RPM
0019  * - Water Flow Fan RPM
0020  * - CPU current
0021  */
0022 
0023 #include <linux/acpi.h>
0024 #include <linux/dmi.h>
0025 #include <linux/hwmon.h>
0026 #include <linux/init.h>
0027 #include <linux/jiffies.h>
0028 #include <linux/kernel.h>
0029 #include <linux/module.h>
0030 #include <linux/mutex.h>
0031 #include <linux/nls.h>
0032 #include <linux/units.h>
0033 #include <linux/wmi.h>
0034 
0035 #include <asm/unaligned.h>
0036 
0037 #define ASUSWMI_MONITORING_GUID     "466747A0-70EC-11DE-8A39-0800200C9A66"
0038 #define ASUSWMI_METHODID_BLOCK_READ_EC  0x42524543 /* BREC */
0039 /* From the ASUS DSDT source */
0040 #define ASUSWMI_BREC_REGISTERS_MAX  16
0041 #define ASUSWMI_MAX_BUF_LEN     128
0042 #define SENSOR_LABEL_LEN        16
0043 
0044 static u32 hwmon_attributes[hwmon_max] = {
0045     [hwmon_chip]    = HWMON_C_REGISTER_TZ,
0046     [hwmon_temp]    = HWMON_T_INPUT | HWMON_T_LABEL,
0047     [hwmon_in]  = HWMON_I_INPUT | HWMON_I_LABEL,
0048     [hwmon_curr]    = HWMON_C_INPUT | HWMON_C_LABEL,
0049     [hwmon_fan] = HWMON_F_INPUT | HWMON_F_LABEL,
0050 };
0051 
0052 struct asus_wmi_ec_sensor_address {
0053     u8 index;
0054     u8 bank;
0055     u8 size;
0056 };
0057 
0058 #define MAKE_SENSOR_ADDRESS(size_i, bank_i, index_i) {  \
0059     .size = size_i,                 \
0060     .bank = bank_i,                 \
0061     .index = index_i,               \
0062 }
0063 
0064 struct ec_sensor_info {
0065     struct asus_wmi_ec_sensor_address addr;
0066     char label[SENSOR_LABEL_LEN];
0067     enum hwmon_sensor_types type;
0068 };
0069 
0070 #define EC_SENSOR(sensor_label, sensor_type, size, bank, index) {   \
0071     .addr = MAKE_SENSOR_ADDRESS(size, bank, index),         \
0072     .label = sensor_label,                      \
0073     .type = sensor_type,                        \
0074 }
0075 
0076 enum known_ec_sensor {
0077     SENSOR_TEMP_CHIPSET,
0078     SENSOR_TEMP_CPU,
0079     SENSOR_TEMP_MB,
0080     SENSOR_TEMP_T_SENSOR,
0081     SENSOR_TEMP_VRM,
0082     SENSOR_FAN_CPU_OPT,
0083     SENSOR_FAN_CHIPSET,
0084     SENSOR_FAN_VRM_HS,
0085     SENSOR_FAN_WATER_FLOW,
0086     SENSOR_CURR_CPU,
0087     SENSOR_TEMP_WATER_IN,
0088     SENSOR_TEMP_WATER_OUT,
0089     SENSOR_MAX
0090 };
0091 
0092 /* All known sensors for ASUS EC controllers */
0093 static const struct ec_sensor_info known_ec_sensors[] = {
0094     [SENSOR_TEMP_CHIPSET]   = EC_SENSOR("Chipset", hwmon_temp, 1, 0x00, 0x3a),
0095     [SENSOR_TEMP_CPU]   = EC_SENSOR("CPU", hwmon_temp, 1, 0x00, 0x3b),
0096     [SENSOR_TEMP_MB]    = EC_SENSOR("Motherboard", hwmon_temp, 1, 0x00, 0x3c),
0097     [SENSOR_TEMP_T_SENSOR]  = EC_SENSOR("T_Sensor", hwmon_temp, 1, 0x00, 0x3d),
0098     [SENSOR_TEMP_VRM]   = EC_SENSOR("VRM", hwmon_temp, 1, 0x00, 0x3e),
0099     [SENSOR_FAN_CPU_OPT]    = EC_SENSOR("CPU_Opt", hwmon_fan, 2, 0x00, 0xb0),
0100     [SENSOR_FAN_VRM_HS] = EC_SENSOR("VRM HS", hwmon_fan, 2, 0x00, 0xb2),
0101     [SENSOR_FAN_CHIPSET]    = EC_SENSOR("Chipset", hwmon_fan, 2, 0x00, 0xb4),
0102     [SENSOR_FAN_WATER_FLOW] = EC_SENSOR("Water_Flow", hwmon_fan, 2, 0x00, 0xbc),
0103     [SENSOR_CURR_CPU]   = EC_SENSOR("CPU", hwmon_curr, 1, 0x00, 0xf4),
0104     [SENSOR_TEMP_WATER_IN]  = EC_SENSOR("Water_In", hwmon_temp, 1, 0x01, 0x00),
0105     [SENSOR_TEMP_WATER_OUT] = EC_SENSOR("Water_Out", hwmon_temp, 1, 0x01, 0x01),
0106 };
0107 
0108 struct asus_wmi_data {
0109     const enum known_ec_sensor known_board_sensors[SENSOR_MAX + 1];
0110 };
0111 
0112 /* boards with EC support */
0113 static struct asus_wmi_data sensors_board_PW_X570_P = {
0114     .known_board_sensors = {
0115         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0116         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0117         SENSOR_FAN_CHIPSET,
0118         SENSOR_MAX
0119     },
0120 };
0121 
0122 static struct asus_wmi_data sensors_board_PW_X570_A = {
0123     .known_board_sensors = {
0124         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB, SENSOR_TEMP_VRM,
0125         SENSOR_FAN_CHIPSET,
0126         SENSOR_CURR_CPU,
0127         SENSOR_MAX
0128     },
0129 };
0130 
0131 static struct asus_wmi_data sensors_board_R_C8H = {
0132     .known_board_sensors = {
0133         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0134         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0135         SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
0136         SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET, SENSOR_FAN_WATER_FLOW,
0137         SENSOR_CURR_CPU,
0138         SENSOR_MAX
0139     },
0140 };
0141 
0142 /* Same as Hero but without chipset fan */
0143 static struct asus_wmi_data sensors_board_R_C8DH = {
0144     .known_board_sensors = {
0145         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0146         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0147         SENSOR_TEMP_WATER_IN, SENSOR_TEMP_WATER_OUT,
0148         SENSOR_FAN_CPU_OPT, SENSOR_FAN_WATER_FLOW,
0149         SENSOR_CURR_CPU,
0150         SENSOR_MAX
0151     },
0152 };
0153 
0154 /* Same as Hero but without water */
0155 static struct asus_wmi_data sensors_board_R_C8F = {
0156     .known_board_sensors = {
0157         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0158         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0159         SENSOR_FAN_CPU_OPT, SENSOR_FAN_CHIPSET,
0160         SENSOR_CURR_CPU,
0161         SENSOR_MAX
0162     },
0163 };
0164 
0165 static struct asus_wmi_data sensors_board_RS_B550_E_G = {
0166     .known_board_sensors = {
0167         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0168         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0169         SENSOR_FAN_CPU_OPT,
0170         SENSOR_MAX
0171     },
0172 };
0173 
0174 static struct asus_wmi_data sensors_board_RS_B550_I_G = {
0175     .known_board_sensors = {
0176         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0177         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0178         SENSOR_FAN_VRM_HS,
0179         SENSOR_CURR_CPU,
0180         SENSOR_MAX
0181     },
0182 };
0183 
0184 static struct asus_wmi_data sensors_board_RS_X570_E_G = {
0185     .known_board_sensors = {
0186         SENSOR_TEMP_CHIPSET, SENSOR_TEMP_CPU, SENSOR_TEMP_MB,
0187         SENSOR_TEMP_T_SENSOR, SENSOR_TEMP_VRM,
0188         SENSOR_FAN_CHIPSET,
0189         SENSOR_CURR_CPU,
0190         SENSOR_MAX
0191     },
0192 };
0193 
0194 #define DMI_EXACT_MATCH_ASUS_BOARD_NAME(name, sensors) {            \
0195     .matches = {                                \
0196         DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "ASUSTeK COMPUTER INC."), \
0197         DMI_EXACT_MATCH(DMI_BOARD_NAME, name),              \
0198     },                                  \
0199     .driver_data = sensors,                         \
0200 }
0201 
0202 static const struct dmi_system_id asus_wmi_ec_dmi_table[] = {
0203     DMI_EXACT_MATCH_ASUS_BOARD_NAME("PRIME X570-PRO", &sensors_board_PW_X570_P),
0204     DMI_EXACT_MATCH_ASUS_BOARD_NAME("Pro WS X570-ACE", &sensors_board_PW_X570_A),
0205     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII DARK HERO", &sensors_board_R_C8DH),
0206     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII FORMULA", &sensors_board_R_C8F),
0207     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG CROSSHAIR VIII HERO", &sensors_board_R_C8H),
0208     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-E GAMING", &sensors_board_RS_B550_E_G),
0209     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX B550-I GAMING", &sensors_board_RS_B550_I_G),
0210     DMI_EXACT_MATCH_ASUS_BOARD_NAME("ROG STRIX X570-E GAMING", &sensors_board_RS_X570_E_G),
0211     {}
0212 };
0213 MODULE_DEVICE_TABLE(dmi, asus_wmi_ec_dmi_table);
0214 
0215 struct ec_sensor {
0216     enum known_ec_sensor info_index;
0217     long cached_value;
0218 };
0219 
0220 /**
0221  * struct asus_wmi_ec_info - sensor info.
0222  * @sensors: list of sensors.
0223  * @read_arg: UTF-16LE string to pass to BRxx() WMI function.
0224  * @read_buffer: decoded output from WMI result.
0225  * @nr_sensors: number of board EC sensors.
0226  * @nr_registers: number of EC registers to read (sensor might span more than 1 register).
0227  * @last_updated: in jiffies.
0228  */
0229 struct asus_wmi_ec_info {
0230     struct ec_sensor sensors[SENSOR_MAX];
0231     char read_arg[(ASUSWMI_BREC_REGISTERS_MAX * 4 + 1) * 2];
0232     u8 read_buffer[ASUSWMI_BREC_REGISTERS_MAX];
0233     unsigned int nr_sensors;
0234     unsigned int nr_registers;
0235     unsigned long last_updated;
0236 };
0237 
0238 struct asus_wmi_sensors {
0239     struct asus_wmi_ec_info ec;
0240     /* lock access to internal cache */
0241     struct mutex lock;
0242 };
0243 
0244 static int asus_wmi_ec_fill_board_sensors(struct asus_wmi_ec_info *ec,
0245                       const enum known_ec_sensor *bsi)
0246 {
0247     struct ec_sensor *s = ec->sensors;
0248     int i;
0249 
0250     ec->nr_sensors = 0;
0251     ec->nr_registers = 0;
0252 
0253     for (i = 0; bsi[i] != SENSOR_MAX; i++) {
0254         s[i].info_index = bsi[i];
0255         ec->nr_sensors++;
0256         ec->nr_registers += known_ec_sensors[bsi[i]].addr.size;
0257     }
0258 
0259     return 0;
0260 }
0261 
0262 /*
0263  * The next four functions convert to or from BRxx string argument format.
0264  * The format of the string is as follows:
0265  * - The string consists of two-byte UTF-16LE characters.
0266  * - The value of the very first byte in the string is equal to the total
0267  *   length of the next string in bytes, thus excluding the first two-byte
0268  *   character.
0269  * - The rest of the string encodes the pairs of (bank, index) pairs, where
0270  *   both values are byte-long (0x00 to 0xFF).
0271  * - Numbers are encoded as UTF-16LE hex values.
0272  */
0273 static int asus_wmi_ec_decode_reply_buffer(const u8 *in, u32 length, u8 *out)
0274 {
0275     char buffer[ASUSWMI_MAX_BUF_LEN * 2];
0276     u32 len = min_t(u32, get_unaligned_le16(in), length - 2);
0277 
0278     utf16s_to_utf8s((wchar_t *)(in + 2), len / 2, UTF16_LITTLE_ENDIAN, buffer, sizeof(buffer));
0279 
0280     return hex2bin(out, buffer, len / 4);
0281 }
0282 
0283 static void asus_wmi_ec_encode_registers(const u8 *in, u32 len, char *out)
0284 {
0285     char buffer[ASUSWMI_MAX_BUF_LEN * 2];
0286 
0287     bin2hex(buffer, in, len);
0288 
0289     utf8s_to_utf16s(buffer, len * 2, UTF16_LITTLE_ENDIAN, (wchar_t *)(out + 2), len * 2);
0290 
0291     put_unaligned_le16(len * 4, out);
0292 }
0293 
0294 static void asus_wmi_ec_make_block_read_query(struct asus_wmi_ec_info *ec)
0295 {
0296     u8 registers[ASUSWMI_BREC_REGISTERS_MAX * 2];
0297     const struct ec_sensor_info *si;
0298     int i, j, offset;
0299 
0300     offset = 0;
0301     for (i = 0; i < ec->nr_sensors; i++) {
0302         si = &known_ec_sensors[ec->sensors[i].info_index];
0303         for (j = 0; j < si->addr.size; j++) {
0304             registers[offset++] = si->addr.bank;
0305             registers[offset++] = si->addr.index + j;
0306         }
0307     }
0308 
0309     asus_wmi_ec_encode_registers(registers, offset, ec->read_arg);
0310 }
0311 
0312 static int asus_wmi_ec_block_read(u32 method_id, char *query, u8 *out)
0313 {
0314     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0315     struct acpi_buffer input;
0316     union acpi_object *obj;
0317     acpi_status status;
0318     int ret;
0319 
0320     /* The first byte of the BRxx() argument string has to be the string size. */
0321     input.length = query[0] + 2;
0322     input.pointer = query;
0323     status = wmi_evaluate_method(ASUSWMI_MONITORING_GUID, 0, method_id, &input, &output);
0324     if (ACPI_FAILURE(status))
0325         return -EIO;
0326 
0327     obj = output.pointer;
0328     if (!obj)
0329         return -EIO;
0330 
0331     if (obj->type != ACPI_TYPE_BUFFER || obj->buffer.length < 2) {
0332         ret = -EIO;
0333         goto out_free_obj;
0334     }
0335 
0336     ret = asus_wmi_ec_decode_reply_buffer(obj->buffer.pointer, obj->buffer.length, out);
0337 
0338 out_free_obj:
0339     ACPI_FREE(obj);
0340     return ret;
0341 }
0342 
0343 static inline long get_sensor_value(const struct ec_sensor_info *si, u8 *data)
0344 {
0345     switch (si->addr.size) {
0346     case 1:
0347         return *data;
0348     case 2:
0349         return get_unaligned_be16(data);
0350     case 4:
0351         return get_unaligned_be32(data);
0352     default:
0353         return 0;
0354     }
0355 }
0356 
0357 static void asus_wmi_ec_update_ec_sensors(struct asus_wmi_ec_info *ec)
0358 {
0359     const struct ec_sensor_info *si;
0360     struct ec_sensor *s;
0361     u8 i_sensor;
0362     u8 *data;
0363 
0364     data = ec->read_buffer;
0365     for (i_sensor = 0; i_sensor < ec->nr_sensors; i_sensor++) {
0366         s = &ec->sensors[i_sensor];
0367         si = &known_ec_sensors[s->info_index];
0368         s->cached_value = get_sensor_value(si, data);
0369         data += si->addr.size;
0370     }
0371 }
0372 
0373 static long asus_wmi_ec_scale_sensor_value(long value, int data_type)
0374 {
0375     switch (data_type) {
0376     case hwmon_curr:
0377     case hwmon_temp:
0378     case hwmon_in:
0379         return value * MILLI;
0380     default:
0381         return value;
0382     }
0383 }
0384 
0385 static int asus_wmi_ec_find_sensor_index(const struct asus_wmi_ec_info *ec,
0386                      enum hwmon_sensor_types type, int channel)
0387 {
0388     int i;
0389 
0390     for (i = 0; i < ec->nr_sensors; i++) {
0391         if (known_ec_sensors[ec->sensors[i].info_index].type == type) {
0392             if (channel == 0)
0393                 return i;
0394 
0395             channel--;
0396         }
0397     }
0398     return -EINVAL;
0399 }
0400 
0401 static int asus_wmi_ec_get_cached_value_or_update(struct asus_wmi_sensors *sensor_data,
0402                           int sensor_index,
0403                           long *value)
0404 {
0405     struct asus_wmi_ec_info *ec = &sensor_data->ec;
0406     int ret = 0;
0407 
0408     mutex_lock(&sensor_data->lock);
0409 
0410     if (time_after(jiffies, ec->last_updated + HZ)) {
0411         ret = asus_wmi_ec_block_read(ASUSWMI_METHODID_BLOCK_READ_EC,
0412                          ec->read_arg, ec->read_buffer);
0413         if (ret)
0414             goto unlock;
0415 
0416         asus_wmi_ec_update_ec_sensors(ec);
0417         ec->last_updated = jiffies;
0418     }
0419 
0420     *value = ec->sensors[sensor_index].cached_value;
0421 
0422 unlock:
0423     mutex_unlock(&sensor_data->lock);
0424 
0425     return ret;
0426 }
0427 
0428 /* Now follow the functions that implement the hwmon interface */
0429 
0430 static int asus_wmi_ec_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
0431                   u32 attr, int channel, long *val)
0432 {
0433     struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
0434     struct asus_wmi_ec_info *ec = &sensor_data->ec;
0435     int ret, sidx, info_index;
0436     long value = 0;
0437 
0438     sidx = asus_wmi_ec_find_sensor_index(ec, type, channel);
0439     if (sidx < 0)
0440         return sidx;
0441 
0442     ret = asus_wmi_ec_get_cached_value_or_update(sensor_data, sidx, &value);
0443     if (ret)
0444         return ret;
0445 
0446     info_index = ec->sensors[sidx].info_index;
0447     *val = asus_wmi_ec_scale_sensor_value(value, known_ec_sensors[info_index].type);
0448 
0449     return ret;
0450 }
0451 
0452 static int asus_wmi_ec_hwmon_read_string(struct device *dev,
0453                      enum hwmon_sensor_types type, u32 attr,
0454                      int channel, const char **str)
0455 {
0456     struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
0457     struct asus_wmi_ec_info *ec = &sensor_data->ec;
0458     int sensor_index;
0459 
0460     sensor_index = asus_wmi_ec_find_sensor_index(ec, type, channel);
0461     *str = known_ec_sensors[ec->sensors[sensor_index].info_index].label;
0462 
0463     return 0;
0464 }
0465 
0466 static umode_t asus_wmi_ec_hwmon_is_visible(const void *drvdata,
0467                         enum hwmon_sensor_types type, u32 attr,
0468                         int channel)
0469 {
0470     const struct asus_wmi_sensors *sensor_data = drvdata;
0471     const struct asus_wmi_ec_info *ec = &sensor_data->ec;
0472     int index;
0473 
0474     index = asus_wmi_ec_find_sensor_index(ec, type, channel);
0475 
0476     return index < 0 ? 0 : 0444;
0477 }
0478 
0479 static int asus_wmi_hwmon_add_chan_info(struct hwmon_channel_info *asus_wmi_hwmon_chan,
0480                     struct device *dev, int num,
0481                     enum hwmon_sensor_types type, u32 config)
0482 {
0483     u32 *cfg;
0484 
0485     cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL);
0486     if (!cfg)
0487         return -ENOMEM;
0488 
0489     asus_wmi_hwmon_chan->type = type;
0490     asus_wmi_hwmon_chan->config = cfg;
0491     memset32(cfg, config, num);
0492 
0493     return 0;
0494 }
0495 
0496 static const struct hwmon_ops asus_wmi_ec_hwmon_ops = {
0497     .is_visible = asus_wmi_ec_hwmon_is_visible,
0498     .read = asus_wmi_ec_hwmon_read,
0499     .read_string = asus_wmi_ec_hwmon_read_string,
0500 };
0501 
0502 static struct hwmon_chip_info asus_wmi_ec_chip_info = {
0503     .ops = &asus_wmi_ec_hwmon_ops,
0504 };
0505 
0506 static int asus_wmi_ec_configure_sensor_setup(struct device *dev,
0507                           const enum known_ec_sensor *bsi)
0508 {
0509     struct asus_wmi_sensors *sensor_data = dev_get_drvdata(dev);
0510     struct asus_wmi_ec_info *ec = &sensor_data->ec;
0511     struct hwmon_channel_info *asus_wmi_hwmon_chan;
0512     const struct hwmon_channel_info **asus_wmi_ci;
0513     int nr_count[hwmon_max] = {}, nr_types = 0;
0514     const struct hwmon_chip_info *chip_info;
0515     const struct ec_sensor_info *si;
0516     enum hwmon_sensor_types type;
0517     struct device *hwdev;
0518     int i, ret;
0519 
0520     ret = asus_wmi_ec_fill_board_sensors(ec, bsi);
0521     if (ret)
0522         return ret;
0523 
0524     if (!sensor_data->ec.nr_sensors)
0525         return -ENODEV;
0526 
0527     for (i = 0; i < ec->nr_sensors; i++) {
0528         si = &known_ec_sensors[ec->sensors[i].info_index];
0529         if (!nr_count[si->type])
0530             nr_types++;
0531         nr_count[si->type]++;
0532     }
0533 
0534     if (nr_count[hwmon_temp]) {
0535         nr_count[hwmon_chip]++;
0536         nr_types++;
0537     }
0538 
0539     /*
0540      * If we can get values for all the registers in a single query,
0541      * the query will not change from call to call.
0542      */
0543     asus_wmi_ec_make_block_read_query(ec);
0544 
0545     asus_wmi_hwmon_chan = devm_kcalloc(dev, nr_types, sizeof(*asus_wmi_hwmon_chan),
0546                        GFP_KERNEL);
0547     if (!asus_wmi_hwmon_chan)
0548         return -ENOMEM;
0549 
0550     asus_wmi_ci = devm_kcalloc(dev, nr_types + 1, sizeof(*asus_wmi_ci), GFP_KERNEL);
0551     if (!asus_wmi_ci)
0552         return -ENOMEM;
0553 
0554     asus_wmi_ec_chip_info.info = asus_wmi_ci;
0555     chip_info = &asus_wmi_ec_chip_info;
0556 
0557     for (type = 0; type < hwmon_max; type++) {
0558         if (!nr_count[type])
0559             continue;
0560 
0561         ret = asus_wmi_hwmon_add_chan_info(asus_wmi_hwmon_chan, dev,
0562                            nr_count[type], type,
0563                            hwmon_attributes[type]);
0564         if (ret)
0565             return ret;
0566 
0567         *asus_wmi_ci++ = asus_wmi_hwmon_chan++;
0568     }
0569 
0570     dev_dbg(dev, "board has %d EC sensors that span %d registers",
0571         ec->nr_sensors, ec->nr_registers);
0572 
0573     hwdev = devm_hwmon_device_register_with_info(dev, "asus_wmi_ec_sensors",
0574                              sensor_data, chip_info, NULL);
0575 
0576     return PTR_ERR_OR_ZERO(hwdev);
0577 }
0578 
0579 static int asus_wmi_probe(struct wmi_device *wdev, const void *context)
0580 {
0581     struct asus_wmi_sensors *sensor_data;
0582     struct asus_wmi_data *board_sensors;
0583     const struct dmi_system_id *dmi_id;
0584     const enum known_ec_sensor *bsi;
0585     struct device *dev = &wdev->dev;
0586 
0587     dmi_id = dmi_first_match(asus_wmi_ec_dmi_table);
0588     if (!dmi_id)
0589         return -ENODEV;
0590 
0591     board_sensors = dmi_id->driver_data;
0592     bsi = board_sensors->known_board_sensors;
0593 
0594     sensor_data = devm_kzalloc(dev, sizeof(*sensor_data), GFP_KERNEL);
0595     if (!sensor_data)
0596         return -ENOMEM;
0597 
0598     mutex_init(&sensor_data->lock);
0599 
0600     dev_set_drvdata(dev, sensor_data);
0601 
0602     return asus_wmi_ec_configure_sensor_setup(dev, bsi);
0603 }
0604 
0605 static const struct wmi_device_id asus_ec_wmi_id_table[] = {
0606     { ASUSWMI_MONITORING_GUID, NULL },
0607     { }
0608 };
0609 
0610 static struct wmi_driver asus_sensors_wmi_driver = {
0611     .driver = {
0612         .name = "asus_wmi_ec_sensors",
0613     },
0614     .id_table = asus_ec_wmi_id_table,
0615     .probe = asus_wmi_probe,
0616 };
0617 module_wmi_driver(asus_sensors_wmi_driver);
0618 
0619 MODULE_AUTHOR("Ed Brindley <kernel@maidavale.org>");
0620 MODULE_AUTHOR("Eugene Shalygin <eugene.shalygin@gmail.com>");
0621 MODULE_DESCRIPTION("Asus WMI Sensors Driver");
0622 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!