1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Linux driver for WMI sensor information on Dell notebooks.
4 *
5 * Copyright (C) 2022 Armin Wolf <W_Armin@gmx.de>
6 */
7
8 #define pr_format(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/bitfield.h>
11 #include <linux/cleanup.h>
12 #include <linux/compiler_attributes.h>
13 #include <linux/debugfs.h>
14 #include <linux/device.h>
15 #include <linux/device/driver.h>
16 #include <linux/dev_printk.h>
17 #include <linux/errno.h>
18 #include <linux/kconfig.h>
19 #include <linux/kernel.h>
20 #include <linux/hwmon.h>
21 #include <linux/kstrtox.h>
22 #include <linux/math64.h>
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/limits.h>
26 #include <linux/pm.h>
27 #include <linux/power_supply.h>
28 #include <linux/printk.h>
29 #include <linux/seq_file.h>
30 #include <linux/sysfs.h>
31 #include <linux/types.h>
32 #include <linux/wmi.h>
33
34 #include <acpi/battery.h>
35
36 #include <linux/unaligned.h>
37
38 #define DRIVER_NAME "dell-wmi-ddv"
39
40 #define DELL_DDV_SUPPORTED_VERSION_MIN 2
41 #define DELL_DDV_SUPPORTED_VERSION_MAX 3
42 #define DELL_DDV_GUID "8A42EA14-4F2A-FD45-6422-0087F7A7E608"
43
44 /* Battery indices 1, 2 and 3 */
45 #define DELL_DDV_NUM_BATTERIES 3
46
47 #define SBS_MANUFACTURE_YEAR_MASK GENMASK(15, 9)
48 #define SBS_MANUFACTURE_MONTH_MASK GENMASK(8, 5)
49 #define SBS_MANUFACTURE_DAY_MASK GENMASK(4, 0)
50
51 #define MA_FAILURE_MODE_MASK GENMASK(11, 8)
52 #define MA_FAILURE_MODE_PERMANENT 0x9
53 #define MA_FAILURE_MODE_OVERHEAT 0xA
54 #define MA_FAILURE_MODE_OVERCURRENT 0xB
55
56 #define MA_PERMANENT_FAILURE_CODE_MASK GENMASK(13, 12)
57 #define MA_PERMANENT_FAILURE_FUSE_BLOWN 0x0
58 #define MA_PERMANENT_FAILURE_CELL_IMBALANCE 0x1
59 #define MA_PERMANENT_FAILURE_OVERVOLTAGE 0x2
60 #define MA_PERMANENT_FAILURE_FET_FAILURE 0x3
61
62 #define MA_OVERHEAT_FAILURE_CODE_MASK GENMASK(15, 12)
63 #define MA_OVERHEAT_FAILURE_START 0x5
64 #define MA_OVERHEAT_FAILURE_CHARGING 0x7
65 #define MA_OVERHEAT_FAILURE_DISCHARGING 0x8
66
67 #define MA_OVERCURRENT_FAILURE_CODE_MASK GENMASK(15, 12)
68 #define MA_OVERCURRENT_FAILURE_CHARGING 0x6
69 #define MA_OVERCURRENT_FAILURE_DISCHARGING 0xB
70
71 #define DELL_EPPID_LENGTH 20
72 #define DELL_EPPID_EXT_LENGTH 23
73
74 static bool force;
75 module_param_unsafe(force, bool, 0);
76 MODULE_PARM_DESC(force, "Force loading without checking for supported WMI interface versions");
77
78 enum dell_ddv_method {
79 DELL_DDV_BATTERY_DESIGN_CAPACITY = 0x01,
80 DELL_DDV_BATTERY_FULL_CHARGE_CAPACITY = 0x02,
81 DELL_DDV_BATTERY_MANUFACTURE_NAME = 0x03,
82 DELL_DDV_BATTERY_MANUFACTURE_DATE = 0x04,
83 DELL_DDV_BATTERY_SERIAL_NUMBER = 0x05,
84 DELL_DDV_BATTERY_CHEMISTRY_VALUE = 0x06,
85 DELL_DDV_BATTERY_TEMPERATURE = 0x07,
86 DELL_DDV_BATTERY_CURRENT = 0x08,
87 DELL_DDV_BATTERY_VOLTAGE = 0x09,
88 DELL_DDV_BATTERY_MANUFACTURER_ACCESS = 0x0A,
89 DELL_DDV_BATTERY_RELATIVE_CHARGE_STATE = 0x0B,
90 DELL_DDV_BATTERY_CYCLE_COUNT = 0x0C,
91 DELL_DDV_BATTERY_EPPID = 0x0D,
92 DELL_DDV_BATTERY_RAW_ANALYTICS_START = 0x0E,
93 DELL_DDV_BATTERY_RAW_ANALYTICS = 0x0F,
94 DELL_DDV_BATTERY_DESIGN_VOLTAGE = 0x10,
95 DELL_DDV_BATTERY_RAW_ANALYTICS_A_BLOCK = 0x11, /* version 3 */
96
97 DELL_DDV_INTERFACE_VERSION = 0x12,
98
99 DELL_DDV_FAN_SENSOR_INFORMATION = 0x20,
100 DELL_DDV_THERMAL_SENSOR_INFORMATION = 0x22,
101 };
102
103 struct dell_wmi_buffer {
104 __le32 raw_size;
105 u8 raw_data[];
106 } __packed;
107
108 struct fan_sensor_entry {
109 u8 type;
110 __le16 rpm;
111 } __packed;
112
113 struct thermal_sensor_entry {
114 u8 type;
115 s8 now;
116 s8 min;
117 s8 max;
118 u8 unknown;
119 } __packed;
120
121 struct combined_channel_info {
122 struct hwmon_channel_info info;
123 u32 config[];
124 };
125
126 struct combined_chip_info {
127 struct hwmon_chip_info chip;
128 const struct hwmon_channel_info *info[];
129 };
130
131 struct dell_wmi_ddv_sensors {
132 bool active;
133 struct mutex lock; /* protect caching */
134 unsigned long timestamp;
135 struct dell_wmi_buffer *buffer;
136 u64 entries;
137 };
138
139 struct dell_wmi_ddv_data {
140 struct acpi_battery_hook hook;
141 struct device_attribute eppid_attr;
142 struct mutex translation_cache_lock; /* Protects the translation cache */
143 struct power_supply *translation_cache[DELL_DDV_NUM_BATTERIES];
144 struct dell_wmi_ddv_sensors fans;
145 struct dell_wmi_ddv_sensors temps;
146 struct wmi_device *wdev;
147 };
148
149 static const char * const fan_labels[] = {
150 "CPU Fan",
151 "Chassis Motherboard Fan",
152 "Video Fan",
153 "Power Supply Fan",
154 "Chipset Fan",
155 "Memory Fan",
156 "PCI Fan",
157 "HDD Fan",
158 };
159
160 static const char * const fan_dock_labels[] = {
161 "Docking Chassis/Motherboard Fan",
162 "Docking Video Fan",
163 "Docking Power Supply Fan",
164 "Docking Chipset Fan",
165 };
166
dell_wmi_ddv_query(struct wmi_device * wdev,enum dell_ddv_method method,u32 arg,struct wmi_buffer * output,size_t min_size)167 static int dell_wmi_ddv_query(struct wmi_device *wdev, enum dell_ddv_method method, u32 arg,
168 struct wmi_buffer *output, size_t min_size)
169 {
170 __le32 arg2 = cpu_to_le32(arg);
171 const struct wmi_buffer input = {
172 .length = sizeof(arg2),
173 .data = &arg2,
174 };
175
176 return wmidev_invoke_method(wdev, 0x0, method, &input, output, min_size);
177 }
178
dell_wmi_ddv_query_integer(struct wmi_device * wdev,enum dell_ddv_method method,u32 arg,u32 * res)179 static int dell_wmi_ddv_query_integer(struct wmi_device *wdev, enum dell_ddv_method method,
180 u32 arg, u32 *res)
181 {
182 struct wmi_buffer output;
183 int ret;
184
185 ret = dell_wmi_ddv_query(wdev, method, arg, &output, sizeof(__le32));
186 if (ret < 0)
187 return ret;
188
189 __le32 *argr __free(kfree) = output.data;
190
191 *res = le32_to_cpu(*argr);
192
193 return 0;
194 }
195
dell_wmi_ddv_query_buffer(struct wmi_device * wdev,enum dell_ddv_method method,u32 arg,struct dell_wmi_buffer ** result)196 static int dell_wmi_ddv_query_buffer(struct wmi_device *wdev, enum dell_ddv_method method,
197 u32 arg, struct dell_wmi_buffer **result)
198 {
199 struct wmi_buffer output;
200 size_t buffer_size;
201 int ret;
202
203 ret = dell_wmi_ddv_query(wdev, method, arg, &output, sizeof(struct dell_wmi_buffer));
204 if (ret < 0)
205 return ret;
206
207 struct dell_wmi_buffer *buffer __free(kfree) = output.data;
208
209 if (!le32_to_cpu(buffer->raw_size))
210 return -ENODATA;
211
212 buffer_size = struct_size(buffer, raw_data, le32_to_cpu(buffer->raw_size));
213 if (buffer_size > output.length) {
214 dev_warn(&wdev->dev,
215 FW_WARN "Dell WMI buffer size (%zu) exceeds WMI buffer size (%zu)\n",
216 buffer_size, output.length);
217 return -EMSGSIZE;
218 }
219
220 *result = no_free_ptr(buffer);
221
222 return 0;
223 }
224
dell_wmi_ddv_query_string(struct wmi_device * wdev,enum dell_ddv_method method,u32 arg,char * buf,size_t length)225 static ssize_t dell_wmi_ddv_query_string(struct wmi_device *wdev, enum dell_ddv_method method,
226 u32 arg, char *buf, size_t length)
227 {
228 struct wmi_buffer output;
229 size_t str_size;
230 int ret;
231
232 ret = dell_wmi_ddv_query(wdev, method, arg, &output, sizeof(struct wmi_string));
233 if (ret < 0)
234 return ret;
235
236 struct wmi_string *str __free(kfree) = output.data;
237
238 str_size = sizeof(*str) + le16_to_cpu(str->length);
239 if (str_size > output.length) {
240 dev_warn(&wdev->dev,
241 FW_WARN "WMI string size (%zu) exceeds WMI buffer size (%zu)\n",
242 str_size, output.length);
243 return -EMSGSIZE;
244 }
245
246 return wmi_string_to_utf8s(str, buf, length);
247 }
248
249 /*
250 * Needs to be called with lock held, except during initialization.
251 */
dell_wmi_ddv_update_sensors(struct wmi_device * wdev,enum dell_ddv_method method,struct dell_wmi_ddv_sensors * sensors,size_t entry_size)252 static int dell_wmi_ddv_update_sensors(struct wmi_device *wdev, enum dell_ddv_method method,
253 struct dell_wmi_ddv_sensors *sensors, size_t entry_size)
254 {
255 struct dell_wmi_buffer *buffer;
256 u64 buffer_size, rem, entries;
257 int ret;
258
259 if (sensors->buffer) {
260 if (time_before(jiffies, sensors->timestamp + HZ))
261 return 0;
262
263 kfree(sensors->buffer);
264 sensors->buffer = NULL;
265 }
266
267 ret = dell_wmi_ddv_query_buffer(wdev, method, 0, &buffer);
268 if (ret < 0)
269 return ret;
270
271 /* buffer format sanity check */
272 buffer_size = le32_to_cpu(buffer->raw_size);
273 entries = div64_u64_rem(buffer_size, entry_size, &rem);
274 if (rem != 1 || buffer->raw_data[buffer_size - 1] != 0xff) {
275 ret = -ENOMSG;
276 goto err_free;
277 }
278
279 if (!entries) {
280 ret = -ENODATA;
281 goto err_free;
282 }
283
284 sensors->buffer = buffer;
285 sensors->entries = entries;
286 sensors->timestamp = jiffies;
287
288 return 0;
289
290 err_free:
291 kfree(buffer);
292
293 return ret;
294 }
295
dell_wmi_ddv_is_visible(const void * drvdata,enum hwmon_sensor_types type,u32 attr,int channel)296 static umode_t dell_wmi_ddv_is_visible(const void *drvdata, enum hwmon_sensor_types type, u32 attr,
297 int channel)
298 {
299 return 0444;
300 }
301
dell_wmi_ddv_fan_read_channel(struct dell_wmi_ddv_data * data,u32 attr,int channel,long * val)302 static int dell_wmi_ddv_fan_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel,
303 long *val)
304 {
305 struct fan_sensor_entry *entry;
306 int ret;
307
308 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION,
309 &data->fans, sizeof(*entry));
310 if (ret < 0)
311 return ret;
312
313 if (channel >= data->fans.entries)
314 return -ENXIO;
315
316 entry = (struct fan_sensor_entry *)data->fans.buffer->raw_data;
317 switch (attr) {
318 case hwmon_fan_input:
319 *val = get_unaligned_le16(&entry[channel].rpm);
320 return 0;
321 default:
322 break;
323 }
324
325 return -EOPNOTSUPP;
326 }
327
dell_wmi_ddv_temp_read_channel(struct dell_wmi_ddv_data * data,u32 attr,int channel,long * val)328 static int dell_wmi_ddv_temp_read_channel(struct dell_wmi_ddv_data *data, u32 attr, int channel,
329 long *val)
330 {
331 struct thermal_sensor_entry *entry;
332 int ret;
333
334 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION,
335 &data->temps, sizeof(*entry));
336 if (ret < 0)
337 return ret;
338
339 if (channel >= data->temps.entries)
340 return -ENXIO;
341
342 entry = (struct thermal_sensor_entry *)data->temps.buffer->raw_data;
343 switch (attr) {
344 case hwmon_temp_input:
345 *val = entry[channel].now * 1000;
346 return 0;
347 case hwmon_temp_min:
348 *val = entry[channel].min * 1000;
349 return 0;
350 case hwmon_temp_max:
351 *val = entry[channel].max * 1000;
352 return 0;
353 default:
354 break;
355 }
356
357 return -EOPNOTSUPP;
358 }
359
dell_wmi_ddv_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)360 static int dell_wmi_ddv_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
361 int channel, long *val)
362 {
363 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev);
364 int ret;
365
366 switch (type) {
367 case hwmon_fan:
368 mutex_lock(&data->fans.lock);
369 ret = dell_wmi_ddv_fan_read_channel(data, attr, channel, val);
370 mutex_unlock(&data->fans.lock);
371 return ret;
372 case hwmon_temp:
373 mutex_lock(&data->temps.lock);
374 ret = dell_wmi_ddv_temp_read_channel(data, attr, channel, val);
375 mutex_unlock(&data->temps.lock);
376 return ret;
377 default:
378 break;
379 }
380
381 return -EOPNOTSUPP;
382 }
383
dell_wmi_ddv_fan_read_string(struct dell_wmi_ddv_data * data,int channel,const char ** str)384 static int dell_wmi_ddv_fan_read_string(struct dell_wmi_ddv_data *data, int channel,
385 const char **str)
386 {
387 struct fan_sensor_entry *entry;
388 int ret;
389 u8 type;
390
391 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_FAN_SENSOR_INFORMATION,
392 &data->fans, sizeof(*entry));
393 if (ret < 0)
394 return ret;
395
396 if (channel >= data->fans.entries)
397 return -ENXIO;
398
399 entry = (struct fan_sensor_entry *)data->fans.buffer->raw_data;
400 type = entry[channel].type;
401 switch (type) {
402 case 0x00 ... 0x07:
403 *str = fan_labels[type];
404 break;
405 case 0x11 ... 0x14:
406 *str = fan_dock_labels[type - 0x11];
407 break;
408 default:
409 *str = "Unknown Fan";
410 break;
411 }
412
413 return 0;
414 }
415
dell_wmi_ddv_temp_read_string(struct dell_wmi_ddv_data * data,int channel,const char ** str)416 static int dell_wmi_ddv_temp_read_string(struct dell_wmi_ddv_data *data, int channel,
417 const char **str)
418 {
419 struct thermal_sensor_entry *entry;
420 int ret;
421
422 ret = dell_wmi_ddv_update_sensors(data->wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION,
423 &data->temps, sizeof(*entry));
424 if (ret < 0)
425 return ret;
426
427 if (channel >= data->temps.entries)
428 return -ENXIO;
429
430 entry = (struct thermal_sensor_entry *)data->temps.buffer->raw_data;
431 switch (entry[channel].type) {
432 case 0x00:
433 *str = "CPU";
434 break;
435 case 0x11:
436 *str = "Video";
437 break;
438 case 0x22:
439 *str = "Memory"; /* sometimes called DIMM */
440 break;
441 case 0x33:
442 *str = "Other";
443 break;
444 case 0x44:
445 *str = "Ambient"; /* sometimes called SKIN */
446 break;
447 case 0x52:
448 *str = "SODIMM";
449 break;
450 case 0x55:
451 *str = "HDD";
452 break;
453 case 0x62:
454 *str = "SODIMM 2";
455 break;
456 case 0x73:
457 *str = "NB";
458 break;
459 case 0x83:
460 *str = "Charger";
461 break;
462 case 0xbb:
463 *str = "Memory 3";
464 break;
465 default:
466 *str = "Unknown";
467 break;
468 }
469
470 return 0;
471 }
472
dell_wmi_ddv_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)473 static int dell_wmi_ddv_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
474 int channel, const char **str)
475 {
476 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev);
477 int ret;
478
479 switch (type) {
480 case hwmon_fan:
481 switch (attr) {
482 case hwmon_fan_label:
483 mutex_lock(&data->fans.lock);
484 ret = dell_wmi_ddv_fan_read_string(data, channel, str);
485 mutex_unlock(&data->fans.lock);
486 return ret;
487 default:
488 break;
489 }
490 break;
491 case hwmon_temp:
492 switch (attr) {
493 case hwmon_temp_label:
494 mutex_lock(&data->temps.lock);
495 ret = dell_wmi_ddv_temp_read_string(data, channel, str);
496 mutex_unlock(&data->temps.lock);
497 return ret;
498 default:
499 break;
500 }
501 break;
502 default:
503 break;
504 }
505
506 return -EOPNOTSUPP;
507 }
508
509 static const struct hwmon_ops dell_wmi_ddv_ops = {
510 .is_visible = dell_wmi_ddv_is_visible,
511 .read = dell_wmi_ddv_read,
512 .read_string = dell_wmi_ddv_read_string,
513 };
514
dell_wmi_ddv_channel_create(struct device * dev,u64 count,enum hwmon_sensor_types type,u32 config)515 static struct hwmon_channel_info *dell_wmi_ddv_channel_create(struct device *dev, u64 count,
516 enum hwmon_sensor_types type,
517 u32 config)
518 {
519 struct combined_channel_info *cinfo;
520 int i;
521
522 cinfo = devm_kzalloc(dev, struct_size(cinfo, config, count + 1), GFP_KERNEL);
523 if (!cinfo)
524 return ERR_PTR(-ENOMEM);
525
526 cinfo->info.type = type;
527 cinfo->info.config = cinfo->config;
528
529 for (i = 0; i < count; i++)
530 cinfo->config[i] = config;
531
532 return &cinfo->info;
533 }
534
dell_wmi_ddv_hwmon_cache_invalidate(struct dell_wmi_ddv_sensors * sensors)535 static void dell_wmi_ddv_hwmon_cache_invalidate(struct dell_wmi_ddv_sensors *sensors)
536 {
537 if (!sensors->active)
538 return;
539
540 mutex_lock(&sensors->lock);
541 kfree(sensors->buffer);
542 sensors->buffer = NULL;
543 mutex_unlock(&sensors->lock);
544 }
545
dell_wmi_ddv_hwmon_cache_destroy(void * data)546 static void dell_wmi_ddv_hwmon_cache_destroy(void *data)
547 {
548 struct dell_wmi_ddv_sensors *sensors = data;
549
550 sensors->active = false;
551 mutex_destroy(&sensors->lock);
552 kfree(sensors->buffer);
553 }
554
dell_wmi_ddv_channel_init(struct wmi_device * wdev,enum dell_ddv_method method,struct dell_wmi_ddv_sensors * sensors,size_t entry_size,enum hwmon_sensor_types type,u32 config)555 static struct hwmon_channel_info *dell_wmi_ddv_channel_init(struct wmi_device *wdev,
556 enum dell_ddv_method method,
557 struct dell_wmi_ddv_sensors *sensors,
558 size_t entry_size,
559 enum hwmon_sensor_types type,
560 u32 config)
561 {
562 struct hwmon_channel_info *info;
563 int ret;
564
565 ret = dell_wmi_ddv_update_sensors(wdev, method, sensors, entry_size);
566 if (ret < 0)
567 return ERR_PTR(ret);
568
569 mutex_init(&sensors->lock);
570 sensors->active = true;
571
572 ret = devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors);
573 if (ret < 0)
574 return ERR_PTR(ret);
575
576 info = dell_wmi_ddv_channel_create(&wdev->dev, sensors->entries, type, config);
577 if (IS_ERR(info))
578 devm_release_action(&wdev->dev, dell_wmi_ddv_hwmon_cache_destroy, sensors);
579
580 return info;
581 }
582
dell_wmi_ddv_hwmon_add(struct dell_wmi_ddv_data * data)583 static int dell_wmi_ddv_hwmon_add(struct dell_wmi_ddv_data *data)
584 {
585 struct wmi_device *wdev = data->wdev;
586 struct combined_chip_info *cinfo;
587 struct hwmon_channel_info *info;
588 struct device *hdev;
589 int index = 0;
590 int ret;
591
592 if (!devres_open_group(&wdev->dev, dell_wmi_ddv_hwmon_add, GFP_KERNEL))
593 return -ENOMEM;
594
595 cinfo = devm_kzalloc(&wdev->dev, struct_size(cinfo, info, 4), GFP_KERNEL);
596 if (!cinfo) {
597 ret = -ENOMEM;
598
599 goto err_release;
600 }
601
602 cinfo->chip.ops = &dell_wmi_ddv_ops;
603 cinfo->chip.info = cinfo->info;
604
605 info = dell_wmi_ddv_channel_create(&wdev->dev, 1, hwmon_chip, HWMON_C_REGISTER_TZ);
606 if (IS_ERR(info)) {
607 ret = PTR_ERR(info);
608
609 goto err_release;
610 }
611
612 cinfo->info[index] = info;
613 index++;
614
615 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_FAN_SENSOR_INFORMATION, &data->fans,
616 sizeof(struct fan_sensor_entry), hwmon_fan,
617 (HWMON_F_INPUT | HWMON_F_LABEL));
618 if (!IS_ERR(info)) {
619 cinfo->info[index] = info;
620 index++;
621 }
622
623 info = dell_wmi_ddv_channel_init(wdev, DELL_DDV_THERMAL_SENSOR_INFORMATION, &data->temps,
624 sizeof(struct thermal_sensor_entry), hwmon_temp,
625 (HWMON_T_INPUT | HWMON_T_MIN | HWMON_T_MAX |
626 HWMON_T_LABEL));
627 if (!IS_ERR(info)) {
628 cinfo->info[index] = info;
629 index++;
630 }
631
632 if (index < 2) {
633 /* Finding no available sensors is not an error */
634 ret = 0;
635
636 goto err_release;
637 }
638
639 hdev = devm_hwmon_device_register_with_info(&wdev->dev, "dell_ddv", data, &cinfo->chip,
640 NULL);
641 if (IS_ERR(hdev)) {
642 ret = PTR_ERR(hdev);
643
644 goto err_release;
645 }
646
647 devres_close_group(&wdev->dev, dell_wmi_ddv_hwmon_add);
648
649 return 0;
650
651 err_release:
652 devres_release_group(&wdev->dev, dell_wmi_ddv_hwmon_add);
653
654 return ret;
655 }
656
dell_wmi_ddv_battery_translate(struct dell_wmi_ddv_data * data,struct power_supply * battery,u32 * index)657 static int dell_wmi_ddv_battery_translate(struct dell_wmi_ddv_data *data,
658 struct power_supply *battery, u32 *index)
659 {
660 u32 serial_dec, serial_hex, serial;
661 union power_supply_propval val;
662 int ret;
663
664 guard(mutex)(&data->translation_cache_lock);
665
666 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) {
667 if (data->translation_cache[i] == battery) {
668 dev_dbg(&data->wdev->dev, "Translation cache hit for battery index %u\n",
669 i + 1);
670 *index = i + 1;
671 return 0;
672 }
673 }
674
675 dev_dbg(&data->wdev->dev, "Translation cache miss\n");
676
677 /*
678 * Perform a translation between a ACPI battery and a battery index.
679 * We have to use power_supply_get_property_direct() here because this
680 * function will also get called from the callbacks of the power supply
681 * extension.
682 */
683 ret = power_supply_get_property_direct(battery, POWER_SUPPLY_PROP_SERIAL_NUMBER, &val);
684 if (ret < 0)
685 return ret;
686
687 /*
688 * Some devices display the serial number of the ACPI battery (string!) as a decimal
689 * number while other devices display it as a hexadecimal number. Because of this we
690 * have to check both cases.
691 */
692 ret = kstrtou32(val.strval, 16, &serial_hex);
693 if (ret < 0)
694 return ret; /* Should never fail */
695
696 ret = kstrtou32(val.strval, 10, &serial_dec);
697 if (ret < 0)
698 serial_dec = 0; /* Can fail, thus we only mark serial_dec as invalid */
699
700 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) {
701 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_SERIAL_NUMBER, i + 1,
702 &serial);
703 if (ret < 0)
704 return ret;
705
706 /* A serial number of 0 signals that this index is not associated with a battery */
707 if (!serial)
708 continue;
709
710 if (serial == serial_dec || serial == serial_hex) {
711 dev_dbg(&data->wdev->dev, "Translation cache update for battery index %u\n",
712 i + 1);
713 data->translation_cache[i] = battery;
714 *index = i + 1;
715 return 0;
716 }
717 }
718
719 return -ENODEV;
720 }
721
dell_wmi_battery_invalidate(struct dell_wmi_ddv_data * data,struct power_supply * battery)722 static void dell_wmi_battery_invalidate(struct dell_wmi_ddv_data *data,
723 struct power_supply *battery)
724 {
725 guard(mutex)(&data->translation_cache_lock);
726
727 for (int i = 0; i < ARRAY_SIZE(data->translation_cache); i++) {
728 if (data->translation_cache[i] == battery) {
729 data->translation_cache[i] = NULL;
730 return;
731 }
732 }
733 }
734
eppid_show(struct device * dev,struct device_attribute * attr,char * buf)735 static ssize_t eppid_show(struct device *dev, struct device_attribute *attr, char *buf)
736 {
737 struct dell_wmi_ddv_data *data = container_of(attr, struct dell_wmi_ddv_data, eppid_attr);
738 ssize_t count;
739 u32 index;
740 int ret;
741
742 ret = dell_wmi_ddv_battery_translate(data, to_power_supply(dev), &index);
743 if (ret < 0)
744 return ret;
745
746 count = dell_wmi_ddv_query_string(data->wdev, DELL_DDV_BATTERY_EPPID, index, buf,
747 PAGE_SIZE);
748 if (count < 0)
749 return count;
750
751 if (count != DELL_EPPID_LENGTH && count != DELL_EPPID_EXT_LENGTH)
752 dev_info_once(&data->wdev->dev, FW_INFO "Suspicious ePPID length (%zd)\n", count);
753
754 ret = sysfs_emit_at(buf, count, "\n");
755 if (ret < 0)
756 return ret;
757
758 return count + ret;
759 }
760
dell_wmi_ddv_get_health(struct dell_wmi_ddv_data * data,u32 index,union power_supply_propval * val)761 static int dell_wmi_ddv_get_health(struct dell_wmi_ddv_data *data, u32 index,
762 union power_supply_propval *val)
763 {
764 u32 value, code;
765 int ret;
766
767 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_MANUFACTURER_ACCESS, index,
768 &value);
769 if (ret < 0)
770 return ret;
771
772 switch (FIELD_GET(MA_FAILURE_MODE_MASK, value)) {
773 case MA_FAILURE_MODE_PERMANENT:
774 code = FIELD_GET(MA_PERMANENT_FAILURE_CODE_MASK, value);
775 switch (code) {
776 case MA_PERMANENT_FAILURE_FUSE_BLOWN:
777 val->intval = POWER_SUPPLY_HEALTH_BLOWN_FUSE;
778 return 0;
779 case MA_PERMANENT_FAILURE_CELL_IMBALANCE:
780 val->intval = POWER_SUPPLY_HEALTH_CELL_IMBALANCE;
781 return 0;
782 case MA_PERMANENT_FAILURE_OVERVOLTAGE:
783 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
784 return 0;
785 case MA_PERMANENT_FAILURE_FET_FAILURE:
786 val->intval = POWER_SUPPLY_HEALTH_DEAD;
787 return 0;
788 default:
789 dev_notice_once(&data->wdev->dev, "Unknown permanent failure code %u\n",
790 code);
791 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
792 return 0;
793 }
794 case MA_FAILURE_MODE_OVERHEAT:
795 code = FIELD_GET(MA_OVERHEAT_FAILURE_CODE_MASK, value);
796 switch (code) {
797 case MA_OVERHEAT_FAILURE_START:
798 case MA_OVERHEAT_FAILURE_CHARGING:
799 case MA_OVERHEAT_FAILURE_DISCHARGING:
800 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
801 return 0;
802 default:
803 dev_notice_once(&data->wdev->dev, "Unknown overheat failure code %u\n",
804 code);
805 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
806 return 0;
807 }
808 case MA_FAILURE_MODE_OVERCURRENT:
809 code = FIELD_GET(MA_OVERCURRENT_FAILURE_CODE_MASK, value);
810 switch (code) {
811 case MA_OVERCURRENT_FAILURE_CHARGING:
812 case MA_OVERCURRENT_FAILURE_DISCHARGING:
813 val->intval = POWER_SUPPLY_HEALTH_OVERCURRENT;
814 return 0;
815 default:
816 dev_notice_once(&data->wdev->dev, "Unknown overcurrent failure code %u\n",
817 code);
818 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
819 return 0;
820 }
821 default:
822 val->intval = POWER_SUPPLY_HEALTH_GOOD;
823 return 0;
824 }
825 }
826
dell_wmi_ddv_get_manufacture_date(struct dell_wmi_ddv_data * data,u32 index,enum power_supply_property psp,union power_supply_propval * val)827 static int dell_wmi_ddv_get_manufacture_date(struct dell_wmi_ddv_data *data, u32 index,
828 enum power_supply_property psp,
829 union power_supply_propval *val)
830 {
831 u16 year, month, day;
832 u32 value;
833 int ret;
834
835 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_MANUFACTURE_DATE,
836 index, &value);
837 if (ret < 0)
838 return ret;
839 if (value > U16_MAX)
840 return -ENXIO;
841
842 /*
843 * Some devices report a invalid manufacture date value
844 * like 0.0.1980. Because of this we have to check the
845 * whole value before exposing parts of it to user space.
846 */
847 year = FIELD_GET(SBS_MANUFACTURE_YEAR_MASK, value) + 1980;
848 month = FIELD_GET(SBS_MANUFACTURE_MONTH_MASK, value);
849 if (month < 1 || month > 12)
850 return -ENODATA;
851
852 day = FIELD_GET(SBS_MANUFACTURE_DAY_MASK, value);
853 if (day < 1 || day > 31)
854 return -ENODATA;
855
856 switch (psp) {
857 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR:
858 val->intval = year;
859 return 0;
860 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH:
861 val->intval = month;
862 return 0;
863 case POWER_SUPPLY_PROP_MANUFACTURE_DAY:
864 val->intval = day;
865 return 0;
866 default:
867 return -EINVAL;
868 }
869 }
870
dell_wmi_ddv_get_property(struct power_supply * psy,const struct power_supply_ext * ext,void * drvdata,enum power_supply_property psp,union power_supply_propval * val)871 static int dell_wmi_ddv_get_property(struct power_supply *psy, const struct power_supply_ext *ext,
872 void *drvdata, enum power_supply_property psp,
873 union power_supply_propval *val)
874 {
875 struct dell_wmi_ddv_data *data = drvdata;
876 u32 index, value;
877 int ret;
878
879 ret = dell_wmi_ddv_battery_translate(data, psy, &index);
880 if (ret < 0)
881 return ret;
882
883 switch (psp) {
884 case POWER_SUPPLY_PROP_HEALTH:
885 return dell_wmi_ddv_get_health(data, index, val);
886 case POWER_SUPPLY_PROP_TEMP:
887 ret = dell_wmi_ddv_query_integer(data->wdev, DELL_DDV_BATTERY_TEMPERATURE, index,
888 &value);
889 if (ret < 0)
890 return ret;
891
892 /* Use 2732 instead of 2731.5 to avoid unnecessary rounding and to emulate
893 * the behaviour of the OEM application which seems to round down the result.
894 */
895 val->intval = value - 2732;
896 return 0;
897 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR:
898 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH:
899 case POWER_SUPPLY_PROP_MANUFACTURE_DAY:
900 return dell_wmi_ddv_get_manufacture_date(data, index, psp, val);
901 default:
902 return -EINVAL;
903 }
904 }
905
906 static const enum power_supply_property dell_wmi_ddv_properties[] = {
907 POWER_SUPPLY_PROP_HEALTH,
908 POWER_SUPPLY_PROP_TEMP,
909 POWER_SUPPLY_PROP_MANUFACTURE_YEAR,
910 POWER_SUPPLY_PROP_MANUFACTURE_MONTH,
911 POWER_SUPPLY_PROP_MANUFACTURE_DAY,
912 };
913
914 static const struct power_supply_ext dell_wmi_ddv_extension = {
915 .name = DRIVER_NAME,
916 .properties = dell_wmi_ddv_properties,
917 .num_properties = ARRAY_SIZE(dell_wmi_ddv_properties),
918 .get_property = dell_wmi_ddv_get_property,
919 };
920
dell_wmi_ddv_add_battery(struct power_supply * battery,struct acpi_battery_hook * hook)921 static int dell_wmi_ddv_add_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
922 {
923 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook);
924 int ret;
925
926 /*
927 * We cannot do the battery matching here since the battery might be absent, preventing
928 * us from reading the serial number.
929 */
930
931 ret = device_create_file(&battery->dev, &data->eppid_attr);
932 if (ret < 0)
933 return ret;
934
935 ret = power_supply_register_extension(battery, &dell_wmi_ddv_extension, &data->wdev->dev,
936 data);
937 if (ret < 0) {
938 device_remove_file(&battery->dev, &data->eppid_attr);
939
940 return ret;
941 }
942
943 return 0;
944 }
945
dell_wmi_ddv_remove_battery(struct power_supply * battery,struct acpi_battery_hook * hook)946 static int dell_wmi_ddv_remove_battery(struct power_supply *battery, struct acpi_battery_hook *hook)
947 {
948 struct dell_wmi_ddv_data *data = container_of(hook, struct dell_wmi_ddv_data, hook);
949
950 device_remove_file(&battery->dev, &data->eppid_attr);
951 power_supply_unregister_extension(battery, &dell_wmi_ddv_extension);
952
953 dell_wmi_battery_invalidate(data, battery);
954
955 return 0;
956 }
957
dell_wmi_ddv_battery_add(struct dell_wmi_ddv_data * data)958 static int dell_wmi_ddv_battery_add(struct dell_wmi_ddv_data *data)
959 {
960 int ret;
961
962 ret = devm_mutex_init(&data->wdev->dev, &data->translation_cache_lock);
963 if (ret < 0)
964 return ret;
965
966 data->hook.name = "Dell DDV Battery Extension";
967 data->hook.add_battery = dell_wmi_ddv_add_battery;
968 data->hook.remove_battery = dell_wmi_ddv_remove_battery;
969
970 sysfs_attr_init(&data->eppid_attr.attr);
971 data->eppid_attr.attr.name = "eppid";
972 data->eppid_attr.attr.mode = 0444;
973 data->eppid_attr.show = eppid_show;
974
975 return devm_battery_hook_register(&data->wdev->dev, &data->hook);
976 }
977
dell_wmi_ddv_buffer_read(struct seq_file * seq,enum dell_ddv_method method)978 static int dell_wmi_ddv_buffer_read(struct seq_file *seq, enum dell_ddv_method method)
979 {
980 struct device *dev = seq->private;
981 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev);
982 struct dell_wmi_buffer *buffer;
983 int ret;
984
985 ret = dell_wmi_ddv_query_buffer(data->wdev, method, 0, &buffer);
986 if (ret < 0)
987 return ret;
988
989 ret = seq_write(seq, buffer->raw_data, le32_to_cpu(buffer->raw_size));
990 kfree(buffer);
991
992 return ret;
993 }
994
dell_wmi_ddv_fan_read(struct seq_file * seq,void * offset)995 static int dell_wmi_ddv_fan_read(struct seq_file *seq, void *offset)
996 {
997 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_FAN_SENSOR_INFORMATION);
998 }
999
dell_wmi_ddv_temp_read(struct seq_file * seq,void * offset)1000 static int dell_wmi_ddv_temp_read(struct seq_file *seq, void *offset)
1001 {
1002 return dell_wmi_ddv_buffer_read(seq, DELL_DDV_THERMAL_SENSOR_INFORMATION);
1003 }
1004
dell_wmi_ddv_debugfs_remove(void * data)1005 static void dell_wmi_ddv_debugfs_remove(void *data)
1006 {
1007 struct dentry *entry = data;
1008
1009 debugfs_remove(entry);
1010 }
1011
dell_wmi_ddv_debugfs_init(struct wmi_device * wdev)1012 static void dell_wmi_ddv_debugfs_init(struct wmi_device *wdev)
1013 {
1014 struct dentry *entry;
1015 char name[64];
1016
1017 scnprintf(name, ARRAY_SIZE(name), "%s-%s", DRIVER_NAME, dev_name(&wdev->dev));
1018 entry = debugfs_create_dir(name, NULL);
1019
1020 debugfs_create_devm_seqfile(&wdev->dev, "fan_sensor_information", entry,
1021 dell_wmi_ddv_fan_read);
1022 debugfs_create_devm_seqfile(&wdev->dev, "thermal_sensor_information", entry,
1023 dell_wmi_ddv_temp_read);
1024
1025 devm_add_action_or_reset(&wdev->dev, dell_wmi_ddv_debugfs_remove, entry);
1026 }
1027
dell_wmi_ddv_probe(struct wmi_device * wdev,const void * context)1028 static int dell_wmi_ddv_probe(struct wmi_device *wdev, const void *context)
1029 {
1030 struct dell_wmi_ddv_data *data;
1031 u32 version;
1032 int ret;
1033
1034 ret = dell_wmi_ddv_query_integer(wdev, DELL_DDV_INTERFACE_VERSION, 0, &version);
1035 if (ret < 0)
1036 return ret;
1037
1038 dev_dbg(&wdev->dev, "WMI interface version: %d\n", version);
1039 if (version < DELL_DDV_SUPPORTED_VERSION_MIN || version > DELL_DDV_SUPPORTED_VERSION_MAX) {
1040 if (!force)
1041 return -ENODEV;
1042
1043 dev_warn(&wdev->dev, "Loading despite unsupported WMI interface version (%u)\n",
1044 version);
1045 }
1046
1047 data = devm_kzalloc(&wdev->dev, sizeof(*data), GFP_KERNEL);
1048 if (!data)
1049 return -ENOMEM;
1050
1051 dev_set_drvdata(&wdev->dev, data);
1052 data->wdev = wdev;
1053
1054 dell_wmi_ddv_debugfs_init(wdev);
1055
1056 if (IS_REACHABLE(CONFIG_ACPI_BATTERY)) {
1057 ret = dell_wmi_ddv_battery_add(data);
1058 if (ret < 0)
1059 dev_warn(&wdev->dev, "Unable to register ACPI battery hook: %d\n", ret);
1060 }
1061
1062 if (IS_REACHABLE(CONFIG_HWMON)) {
1063 ret = dell_wmi_ddv_hwmon_add(data);
1064 if (ret < 0)
1065 dev_warn(&wdev->dev, "Unable to register hwmon interface: %d\n", ret);
1066 }
1067
1068 return 0;
1069 }
1070
dell_wmi_ddv_resume(struct device * dev)1071 static int dell_wmi_ddv_resume(struct device *dev)
1072 {
1073 struct dell_wmi_ddv_data *data = dev_get_drvdata(dev);
1074
1075 /* Force re-reading of all active sensors */
1076 dell_wmi_ddv_hwmon_cache_invalidate(&data->fans);
1077 dell_wmi_ddv_hwmon_cache_invalidate(&data->temps);
1078
1079 return 0;
1080 }
1081
1082 static DEFINE_SIMPLE_DEV_PM_OPS(dell_wmi_ddv_dev_pm_ops, NULL, dell_wmi_ddv_resume);
1083
1084 static const struct wmi_device_id dell_wmi_ddv_id_table[] = {
1085 { DELL_DDV_GUID, NULL },
1086 { }
1087 };
1088 MODULE_DEVICE_TABLE(wmi, dell_wmi_ddv_id_table);
1089
1090 static struct wmi_driver dell_wmi_ddv_driver = {
1091 .driver = {
1092 .name = DRIVER_NAME,
1093 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1094 .pm = pm_sleep_ptr(&dell_wmi_ddv_dev_pm_ops),
1095 },
1096 .id_table = dell_wmi_ddv_id_table,
1097 .probe = dell_wmi_ddv_probe,
1098 .no_singleton = true,
1099 };
1100 module_wmi_driver(dell_wmi_ddv_driver);
1101
1102 MODULE_AUTHOR("Armin Wolf <W_Armin@gmx.de>");
1103 MODULE_DESCRIPTION("Dell WMI sensor driver");
1104 MODULE_LICENSE("GPL");
1105