Merge tag 'kvm-x86-pmu-6.6-fixes' of https://github.com/kvm-x86/linux into HEAD
[platform/kernel/linux-rpi.git] / drivers / hwmon / hp-wmi-sensors.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * hwmon driver for HP (and some HP Compaq) business-class computers that
4  * report numeric sensor data via Windows Management Instrumentation (WMI).
5  *
6  * Copyright (C) 2023 James Seo <james@equiv.tech>
7  *
8  * References:
9  * [1] Hewlett-Packard Development Company, L.P.,
10  *     "HP Client Management Interface Technical White Paper", 2005. [Online].
11  *     Available: https://h20331.www2.hp.com/hpsub/downloads/cmi_whitepaper.pdf
12  * [2] Hewlett-Packard Development Company, L.P.,
13  *     "HP Retail Manageability", 2012. [Online].
14  *     Available: http://h10032.www1.hp.com/ctg/Manual/c03291135.pdf
15  * [3] Linux Hardware Project, A. Ponomarenko et al.,
16  *     "linuxhw/ACPI - Collect ACPI table dumps", 2018. [Online].
17  *     Available: https://github.com/linuxhw/ACPI
18  * [4] P. Rohár, "bmfdec - Decompile binary MOF file (BMF) from WMI buffer",
19  *     2017. [Online]. Available: https://github.com/pali/bmfdec
20  */
21
22 #include <linux/acpi.h>
23 #include <linux/debugfs.h>
24 #include <linux/hwmon.h>
25 #include <linux/jiffies.h>
26 #include <linux/mutex.h>
27 #include <linux/units.h>
28 #include <linux/wmi.h>
29
30 #define HP_WMI_EVENT_NAMESPACE          "root\\WMI"
31 #define HP_WMI_EVENT_CLASS              "HPBIOS_BIOSEvent"
32 #define HP_WMI_EVENT_GUID               "95F24279-4D7B-4334-9387-ACCDC67EF61C"
33 #define HP_WMI_NUMERIC_SENSOR_GUID      "8F1F6435-9F42-42C8-BADC-0E9424F20C9A"
34 #define HP_WMI_PLATFORM_EVENTS_GUID     "41227C2D-80E1-423F-8B8E-87E32755A0EB"
35
36 /* Patterns for recognizing sensors and matching events to channels. */
37
38 #define HP_WMI_PATTERN_SYS_TEMP         "Chassis Thermal Index"
39 #define HP_WMI_PATTERN_SYS_TEMP2        "System Ambient Temperature"
40 #define HP_WMI_PATTERN_CPU_TEMP         "CPU Thermal Index"
41 #define HP_WMI_PATTERN_CPU_TEMP2        "CPU Temperature"
42 #define HP_WMI_PATTERN_TEMP_SENSOR      "Thermal Index"
43 #define HP_WMI_PATTERN_TEMP_ALARM       "Thermal Critical"
44 #define HP_WMI_PATTERN_INTRUSION_ALARM  "Hood Intrusion"
45 #define HP_WMI_PATTERN_FAN_ALARM        "Stall"
46 #define HP_WMI_PATTERN_TEMP             "Temperature"
47 #define HP_WMI_PATTERN_CPU              "CPU"
48
49 /* These limits are arbitrary. The WMI implementation may vary by system. */
50
51 #define HP_WMI_MAX_STR_SIZE             128U
52 #define HP_WMI_MAX_PROPERTIES           32U
53 #define HP_WMI_MAX_INSTANCES            32U
54
55 enum hp_wmi_type {
56         HP_WMI_TYPE_OTHER                       = 1,
57         HP_WMI_TYPE_TEMPERATURE                 = 2,
58         HP_WMI_TYPE_VOLTAGE                     = 3,
59         HP_WMI_TYPE_CURRENT                     = 4,
60         HP_WMI_TYPE_AIR_FLOW                    = 12,
61         HP_WMI_TYPE_INTRUSION                   = 0xabadb01, /* Custom. */
62 };
63
64 enum hp_wmi_category {
65         HP_WMI_CATEGORY_SENSOR                  = 3,
66 };
67
68 enum hp_wmi_severity {
69         HP_WMI_SEVERITY_UNKNOWN                 = 0,
70         HP_WMI_SEVERITY_OK                      = 5,
71         HP_WMI_SEVERITY_DEGRADED_WARNING        = 10,
72         HP_WMI_SEVERITY_MINOR_FAILURE           = 15,
73         HP_WMI_SEVERITY_MAJOR_FAILURE           = 20,
74         HP_WMI_SEVERITY_CRITICAL_FAILURE        = 25,
75         HP_WMI_SEVERITY_NON_RECOVERABLE_ERROR   = 30,
76 };
77
78 enum hp_wmi_status {
79         HP_WMI_STATUS_OK                        = 2,
80         HP_WMI_STATUS_DEGRADED                  = 3,
81         HP_WMI_STATUS_STRESSED                  = 4,
82         HP_WMI_STATUS_PREDICTIVE_FAILURE        = 5,
83         HP_WMI_STATUS_ERROR                     = 6,
84         HP_WMI_STATUS_NON_RECOVERABLE_ERROR     = 7,
85         HP_WMI_STATUS_NO_CONTACT                = 12,
86         HP_WMI_STATUS_LOST_COMMUNICATION        = 13,
87         HP_WMI_STATUS_ABORTED                   = 14,
88         HP_WMI_STATUS_SUPPORTING_ENTITY_IN_ERROR = 16,
89
90         /* Occurs combined with one of "OK", "Degraded", and "Error" [1]. */
91         HP_WMI_STATUS_COMPLETED                 = 17,
92 };
93
94 enum hp_wmi_units {
95         HP_WMI_UNITS_OTHER                      = 1,
96         HP_WMI_UNITS_DEGREES_C                  = 2,
97         HP_WMI_UNITS_DEGREES_F                  = 3,
98         HP_WMI_UNITS_DEGREES_K                  = 4,
99         HP_WMI_UNITS_VOLTS                      = 5,
100         HP_WMI_UNITS_AMPS                       = 6,
101         HP_WMI_UNITS_RPM                        = 19,
102 };
103
104 enum hp_wmi_property {
105         HP_WMI_PROPERTY_NAME                    = 0,
106         HP_WMI_PROPERTY_DESCRIPTION             = 1,
107         HP_WMI_PROPERTY_SENSOR_TYPE             = 2,
108         HP_WMI_PROPERTY_OTHER_SENSOR_TYPE       = 3,
109         HP_WMI_PROPERTY_OPERATIONAL_STATUS      = 4,
110         HP_WMI_PROPERTY_SIZE                    = 5,
111         HP_WMI_PROPERTY_POSSIBLE_STATES         = 6,
112         HP_WMI_PROPERTY_CURRENT_STATE           = 7,
113         HP_WMI_PROPERTY_BASE_UNITS              = 8,
114         HP_WMI_PROPERTY_UNIT_MODIFIER           = 9,
115         HP_WMI_PROPERTY_CURRENT_READING         = 10,
116         HP_WMI_PROPERTY_RATE_UNITS              = 11,
117 };
118
119 static const acpi_object_type hp_wmi_property_map[] = {
120         [HP_WMI_PROPERTY_NAME]                  = ACPI_TYPE_STRING,
121         [HP_WMI_PROPERTY_DESCRIPTION]           = ACPI_TYPE_STRING,
122         [HP_WMI_PROPERTY_SENSOR_TYPE]           = ACPI_TYPE_INTEGER,
123         [HP_WMI_PROPERTY_OTHER_SENSOR_TYPE]     = ACPI_TYPE_STRING,
124         [HP_WMI_PROPERTY_OPERATIONAL_STATUS]    = ACPI_TYPE_INTEGER,
125         [HP_WMI_PROPERTY_SIZE]                  = ACPI_TYPE_INTEGER,
126         [HP_WMI_PROPERTY_POSSIBLE_STATES]       = ACPI_TYPE_STRING,
127         [HP_WMI_PROPERTY_CURRENT_STATE]         = ACPI_TYPE_STRING,
128         [HP_WMI_PROPERTY_BASE_UNITS]            = ACPI_TYPE_INTEGER,
129         [HP_WMI_PROPERTY_UNIT_MODIFIER]         = ACPI_TYPE_INTEGER,
130         [HP_WMI_PROPERTY_CURRENT_READING]       = ACPI_TYPE_INTEGER,
131         [HP_WMI_PROPERTY_RATE_UNITS]            = ACPI_TYPE_INTEGER,
132 };
133
134 enum hp_wmi_platform_events_property {
135         HP_WMI_PLATFORM_EVENTS_PROPERTY_NAME                = 0,
136         HP_WMI_PLATFORM_EVENTS_PROPERTY_DESCRIPTION         = 1,
137         HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_NAMESPACE    = 2,
138         HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_CLASS        = 3,
139         HP_WMI_PLATFORM_EVENTS_PROPERTY_CATEGORY            = 4,
140         HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_SEVERITY   = 5,
141         HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_STATUS     = 6,
142 };
143
144 static const acpi_object_type hp_wmi_platform_events_property_map[] = {
145         [HP_WMI_PLATFORM_EVENTS_PROPERTY_NAME]              = ACPI_TYPE_STRING,
146         [HP_WMI_PLATFORM_EVENTS_PROPERTY_DESCRIPTION]       = ACPI_TYPE_STRING,
147         [HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_NAMESPACE]  = ACPI_TYPE_STRING,
148         [HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_CLASS]      = ACPI_TYPE_STRING,
149         [HP_WMI_PLATFORM_EVENTS_PROPERTY_CATEGORY]          = ACPI_TYPE_INTEGER,
150         [HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_SEVERITY] = ACPI_TYPE_INTEGER,
151         [HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_STATUS]   = ACPI_TYPE_INTEGER,
152 };
153
154 enum hp_wmi_event_property {
155         HP_WMI_EVENT_PROPERTY_NAME              = 0,
156         HP_WMI_EVENT_PROPERTY_DESCRIPTION       = 1,
157         HP_WMI_EVENT_PROPERTY_CATEGORY          = 2,
158         HP_WMI_EVENT_PROPERTY_SEVERITY          = 3,
159         HP_WMI_EVENT_PROPERTY_STATUS            = 4,
160 };
161
162 static const acpi_object_type hp_wmi_event_property_map[] = {
163         [HP_WMI_EVENT_PROPERTY_NAME]            = ACPI_TYPE_STRING,
164         [HP_WMI_EVENT_PROPERTY_DESCRIPTION]     = ACPI_TYPE_STRING,
165         [HP_WMI_EVENT_PROPERTY_CATEGORY]        = ACPI_TYPE_INTEGER,
166         [HP_WMI_EVENT_PROPERTY_SEVERITY]        = ACPI_TYPE_INTEGER,
167         [HP_WMI_EVENT_PROPERTY_STATUS]          = ACPI_TYPE_INTEGER,
168 };
169
170 static const enum hwmon_sensor_types hp_wmi_hwmon_type_map[] = {
171         [HP_WMI_TYPE_TEMPERATURE]               = hwmon_temp,
172         [HP_WMI_TYPE_VOLTAGE]                   = hwmon_in,
173         [HP_WMI_TYPE_CURRENT]                   = hwmon_curr,
174         [HP_WMI_TYPE_AIR_FLOW]                  = hwmon_fan,
175 };
176
177 static const u32 hp_wmi_hwmon_attributes[hwmon_max] = {
178         [hwmon_chip]      = HWMON_C_REGISTER_TZ,
179         [hwmon_temp]      = HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_FAULT,
180         [hwmon_in]        = HWMON_I_INPUT | HWMON_I_LABEL,
181         [hwmon_curr]      = HWMON_C_INPUT | HWMON_C_LABEL,
182         [hwmon_fan]       = HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_FAULT,
183         [hwmon_intrusion] = HWMON_INTRUSION_ALARM,
184 };
185
186 /*
187  * struct hp_wmi_numeric_sensor - a HPBIOS_BIOSNumericSensor instance
188  *
189  * Two variants of HPBIOS_BIOSNumericSensor are known. The first is specified
190  * in [1] and appears to be much more widespread. The second was discovered by
191  * decoding BMOF blobs [4], seems to be found only in some newer ZBook systems
192  * [3], and has two new properties and a slightly different property order.
193  *
194  * These differences don't matter on Windows, where WMI object properties are
195  * accessed by name. For us, supporting both variants gets ugly and hacky at
196  * times. The fun begins now; this struct is defined as per the new variant.
197  *
198  * Effective MOF definition:
199  *
200  *   #pragma namespace("\\\\.\\root\\HP\\InstrumentedBIOS");
201  *   class HPBIOS_BIOSNumericSensor {
202  *     [read] string Name;
203  *     [read] string Description;
204  *     [read, ValueMap {"0","1","2","3","4","5","6","7","8","9",
205  *      "10","11","12"}, Values {"Unknown","Other","Temperature",
206  *      "Voltage","Current","Tachometer","Counter","Switch","Lock",
207  *      "Humidity","Smoke Detection","Presence","Air Flow"}]
208  *     uint32 SensorType;
209  *     [read] string OtherSensorType;
210  *     [read, ValueMap {"0","1","2","3","4","5","6","7","8","9",
211  *      "10","11","12","13","14","15","16","17","18","..",
212  *      "0x8000.."}, Values {"Unknown","Other","OK","Degraded",
213  *      "Stressed","Predictive Failure","Error",
214  *      "Non-Recoverable Error","Starting","Stopping","Stopped",
215  *      "In Service","No Contact","Lost Communication","Aborted",
216  *      "Dormant","Supporting Entity in Error","Completed",
217  *      "Power Mode","DMTF Reserved","Vendor Reserved"}]
218  *     uint32 OperationalStatus;
219  *     [read] uint32 Size;
220  *     [read] string PossibleStates[];
221  *     [read] string CurrentState;
222  *     [read, ValueMap {"0","1","2","3","4","5","6","7","8","9",
223  *      "10","11","12","13","14","15","16","17","18","19","20",
224  *      "21","22","23","24","25","26","27","28","29","30","31",
225  *      "32","33","34","35","36","37","38","39","40","41","42",
226  *      "43","44","45","46","47","48","49","50","51","52","53",
227  *      "54","55","56","57","58","59","60","61","62","63","64",
228  *      "65"}, Values {"Unknown","Other","Degrees C","Degrees F",
229  *      "Degrees K","Volts","Amps","Watts","Joules","Coulombs",
230  *      "VA","Nits","Lumens","Lux","Candelas","kPa","PSI",
231  *      "Newtons","CFM","RPM","Hertz","Seconds","Minutes",
232  *      "Hours","Days","Weeks","Mils","Inches","Feet",
233  *      "Cubic Inches","Cubic Feet","Meters","Cubic Centimeters",
234  *      "Cubic Meters","Liters","Fluid Ounces","Radians",
235  *      "Steradians","Revolutions","Cycles","Gravities","Ounces",
236  *      "Pounds","Foot-Pounds","Ounce-Inches","Gauss","Gilberts",
237  *      "Henries","Farads","Ohms","Siemens","Moles","Becquerels",
238  *      "PPM (parts/million)","Decibels","DbA","DbC","Grays",
239  *      "Sieverts","Color Temperature Degrees K","Bits","Bytes",
240  *      "Words (data)","DoubleWords","QuadWords","Percentage"}]
241  *     uint32 BaseUnits;
242  *     [read] sint32 UnitModifier;
243  *     [read] uint32 CurrentReading;
244  *     [read] uint32 RateUnits;
245  *   };
246  *
247  * Effective MOF definition of old variant [1] (sans redundant info):
248  *
249  *   class HPBIOS_BIOSNumericSensor {
250  *     [read] string Name;
251  *     [read] string Description;
252  *     [read] uint32 SensorType;
253  *     [read] string OtherSensorType;
254  *     [read] uint32 OperationalStatus;
255  *     [read] string CurrentState;
256  *     [read] string PossibleStates[];
257  *     [read] uint32 BaseUnits;
258  *     [read] sint32 UnitModifier;
259  *     [read] uint32 CurrentReading;
260  *   };
261  */
262 struct hp_wmi_numeric_sensor {
263         const char *name;
264         const char *description;
265         u32 sensor_type;
266         const char *other_sensor_type;  /* Explains "Other" SensorType. */
267         u32 operational_status;
268         u8 size;                        /* Count of PossibleStates[]. */
269         const char **possible_states;
270         const char *current_state;
271         u32 base_units;
272         s32 unit_modifier;
273         u32 current_reading;
274         u32 rate_units;
275 };
276
277 /*
278  * struct hp_wmi_platform_events - a HPBIOS_PlatformEvents instance
279  *
280  * Instances of this object reveal the set of possible HPBIOS_BIOSEvent
281  * instances for the current system, but it may not always be present.
282  *
283  * Effective MOF definition:
284  *
285  *   #pragma namespace("\\\\.\\root\\HP\\InstrumentedBIOS");
286  *   class HPBIOS_PlatformEvents {
287  *     [read] string Name;
288  *     [read] string Description;
289  *     [read] string SourceNamespace;
290  *     [read] string SourceClass;
291  *     [read, ValueMap {"0","1","2","3","4",".."}, Values {
292  *      "Unknown","Configuration Change","Button Pressed",
293  *      "Sensor","BIOS Settings","Reserved"}]
294  *     uint32 Category;
295  *     [read, ValueMap{"0","5","10","15","20","25","30",".."},
296  *      Values{"Unknown","OK","Degraded/Warning","Minor Failure",
297  *      "Major Failure","Critical Failure","Non-recoverable Error",
298  *      "DMTF Reserved"}]
299  *     uint32 PossibleSeverity;
300  *     [read, ValueMap {"0","1","2","3","4","5","6","7","8","9",
301  *      "10","11","12","13","14","15","16","17","18","..",
302  *      "0x8000.."}, Values {"Unknown","Other","OK","Degraded",
303  *      "Stressed","Predictive Failure","Error",
304  *      "Non-Recoverable Error","Starting","Stopping","Stopped",
305  *      "In Service","No Contact","Lost Communication","Aborted",
306  *      "Dormant","Supporting Entity in Error","Completed",
307  *      "Power Mode","DMTF Reserved","Vendor Reserved"}]
308  *     uint32 PossibleStatus;
309  *   };
310  */
311 struct hp_wmi_platform_events {
312         const char *name;
313         const char *description;
314         const char *source_namespace;
315         const char *source_class;
316         u32 category;
317         u32 possible_severity;
318         u32 possible_status;
319 };
320
321 /*
322  * struct hp_wmi_event - a HPBIOS_BIOSEvent instance
323  *
324  * Effective MOF definition [1] (corrected below from original):
325  *
326  *   #pragma namespace("\\\\.\\root\\WMI");
327  *   class HPBIOS_BIOSEvent : WMIEvent {
328  *     [read] string Name;
329  *     [read] string Description;
330  *     [read ValueMap {"0","1","2","3","4"}, Values {"Unknown",
331  *      "Configuration Change","Button Pressed","Sensor",
332  *      "BIOS Settings"}]
333  *     uint32 Category;
334  *     [read, ValueMap {"0","5","10","15","20","25","30"},
335  *      Values {"Unknown","OK","Degraded/Warning",
336  *      "Minor Failure","Major Failure","Critical Failure",
337  *      "Non-recoverable Error"}]
338  *     uint32 Severity;
339  *     [read, ValueMap {"0","1","2","3","4","5","6","7","8",
340  *      "9","10","11","12","13","14","15","16","17","18","..",
341  *      "0x8000.."}, Values {"Unknown","Other","OK","Degraded",
342  *      "Stressed","Predictive Failure","Error",
343  *      "Non-Recoverable Error","Starting","Stopping","Stopped",
344  *      "In Service","No Contact","Lost Communication","Aborted",
345  *      "Dormant","Supporting Entity in Error","Completed",
346  *      "Power Mode","DMTF Reserved","Vendor Reserved"}]
347  *     uint32 Status;
348  *   };
349  */
350 struct hp_wmi_event {
351         const char *name;
352         const char *description;
353         u32 category;
354 };
355
356 /*
357  * struct hp_wmi_info - sensor info
358  * @nsensor: numeric sensor properties
359  * @instance: its WMI instance number
360  * @state: pointer to driver state
361  * @has_alarm: whether sensor has an alarm flag
362  * @alarm: alarm flag
363  * @type: its hwmon sensor type
364  * @cached_val: current sensor reading value, scaled for hwmon
365  * @last_updated: when these readings were last updated
366  */
367 struct hp_wmi_info {
368         struct hp_wmi_numeric_sensor nsensor;
369         u8 instance;
370         void *state;                    /* void *: Avoid forward declaration. */
371         bool has_alarm;
372         bool alarm;
373         enum hwmon_sensor_types type;
374         long cached_val;
375         unsigned long last_updated;     /* In jiffies. */
376
377 };
378
379 /*
380  * struct hp_wmi_sensors - driver state
381  * @wdev: pointer to the parent WMI device
382  * @info_map: sensor info structs by hwmon type and channel number
383  * @channel_count: count of hwmon channels by hwmon type
384  * @has_intrusion: whether an intrusion sensor is present
385  * @intrusion: intrusion flag
386  * @lock: mutex to lock polling WMI and changes to driver state
387  */
388 struct hp_wmi_sensors {
389         struct wmi_device *wdev;
390         struct hp_wmi_info **info_map[hwmon_max];
391         u8 channel_count[hwmon_max];
392         bool has_intrusion;
393         bool intrusion;
394
395         struct mutex lock;      /* Lock polling WMI and driver state changes. */
396 };
397
398 /* hp_wmi_strdup - devm_kstrdup, but length-limited */
399 static char *hp_wmi_strdup(struct device *dev, const char *src)
400 {
401         char *dst;
402         size_t len;
403
404         len = strnlen(src, HP_WMI_MAX_STR_SIZE - 1);
405
406         dst = devm_kmalloc(dev, (len + 1) * sizeof(*dst), GFP_KERNEL);
407         if (!dst)
408                 return NULL;
409
410         strscpy(dst, src, len + 1);
411
412         return dst;
413 }
414
415 /*
416  * hp_wmi_get_wobj - poll WMI for a WMI object instance
417  * @guid: WMI object GUID
418  * @instance: WMI object instance number
419  *
420  * Returns a new WMI object instance on success, or NULL on error.
421  * Caller must kfree() the result.
422  */
423 static union acpi_object *hp_wmi_get_wobj(const char *guid, u8 instance)
424 {
425         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
426         acpi_status err;
427
428         err = wmi_query_block(guid, instance, &out);
429         if (ACPI_FAILURE(err))
430                 return NULL;
431
432         return out.pointer;
433 }
434
435 /* hp_wmi_wobj_instance_count - find count of WMI object instances */
436 static u8 hp_wmi_wobj_instance_count(const char *guid)
437 {
438         int count;
439
440         count = wmi_instance_count(guid);
441
442         return clamp(count, 0, (int)HP_WMI_MAX_INSTANCES);
443 }
444
445 static int check_wobj(const union acpi_object *wobj,
446                       const acpi_object_type property_map[], int last_prop)
447 {
448         acpi_object_type type = wobj->type;
449         acpi_object_type valid_type;
450         union acpi_object *elements;
451         u32 elem_count;
452         int prop;
453
454         if (type != ACPI_TYPE_PACKAGE)
455                 return -EINVAL;
456
457         elem_count = wobj->package.count;
458         if (elem_count != last_prop + 1)
459                 return -EINVAL;
460
461         elements = wobj->package.elements;
462         for (prop = 0; prop <= last_prop; prop++) {
463                 type = elements[prop].type;
464                 valid_type = property_map[prop];
465                 if (type != valid_type)
466                         return -EINVAL;
467         }
468
469         return 0;
470 }
471
472 static int extract_acpi_value(struct device *dev,
473                               union acpi_object *element,
474                               acpi_object_type type,
475                               u32 *out_value, char **out_string)
476 {
477         switch (type) {
478         case ACPI_TYPE_INTEGER:
479                 *out_value = element->integer.value;
480                 break;
481
482         case ACPI_TYPE_STRING:
483                 *out_string = hp_wmi_strdup(dev, strim(element->string.pointer));
484                 if (!*out_string)
485                         return -ENOMEM;
486                 break;
487
488         default:
489                 return -EINVAL;
490         }
491
492         return 0;
493 }
494
495 /*
496  * check_numeric_sensor_wobj - validate a HPBIOS_BIOSNumericSensor instance
497  * @wobj: pointer to WMI object instance to check
498  * @out_size: out pointer to count of possible states
499  * @out_is_new: out pointer to whether this is a "new" variant object
500  *
501  * Returns 0 on success, or a negative error code on error.
502  */
503 static int check_numeric_sensor_wobj(const union acpi_object *wobj,
504                                      u8 *out_size, bool *out_is_new)
505 {
506         acpi_object_type type = wobj->type;
507         int prop = HP_WMI_PROPERTY_NAME;
508         acpi_object_type valid_type;
509         union acpi_object *elements;
510         u32 elem_count;
511         int last_prop;
512         bool is_new;
513         u8 count;
514         u32 j;
515         u32 i;
516
517         if (type != ACPI_TYPE_PACKAGE)
518                 return -EINVAL;
519
520         /*
521          * elements is a variable-length array of ACPI objects, one for
522          * each property of the WMI object instance, except that the
523          * strings in PossibleStates[] are flattened into this array
524          * as if each individual string were a property by itself.
525          */
526         elements = wobj->package.elements;
527
528         elem_count = wobj->package.count;
529         if (elem_count <= HP_WMI_PROPERTY_SIZE ||
530             elem_count > HP_WMI_MAX_PROPERTIES)
531                 return -EINVAL;
532
533         type = elements[HP_WMI_PROPERTY_SIZE].type;
534         switch (type) {
535         case ACPI_TYPE_INTEGER:
536                 is_new = true;
537                 last_prop = HP_WMI_PROPERTY_RATE_UNITS;
538                 break;
539
540         case ACPI_TYPE_STRING:
541                 is_new = false;
542                 last_prop = HP_WMI_PROPERTY_CURRENT_READING;
543                 break;
544
545         default:
546                 return -EINVAL;
547         }
548
549         /*
550          * In general, the count of PossibleStates[] must be > 0.
551          * Also, the old variant lacks the Size property, so we may need to
552          * reduce the value of last_prop by 1 when doing arithmetic with it.
553          */
554         if (elem_count < last_prop - !is_new + 1)
555                 return -EINVAL;
556
557         count = elem_count - (last_prop - !is_new);
558
559         for (i = 0; i < elem_count && prop <= last_prop; i++, prop++) {
560                 type = elements[i].type;
561                 valid_type = hp_wmi_property_map[prop];
562                 if (type != valid_type)
563                         return -EINVAL;
564
565                 switch (prop) {
566                 case HP_WMI_PROPERTY_OPERATIONAL_STATUS:
567                         /* Old variant: CurrentState follows OperationalStatus. */
568                         if (!is_new)
569                                 prop = HP_WMI_PROPERTY_CURRENT_STATE - 1;
570                         break;
571
572                 case HP_WMI_PROPERTY_SIZE:
573                         /* New variant: Size == count of PossibleStates[]. */
574                         if (count != elements[i].integer.value)
575                                 return -EINVAL;
576                         break;
577
578                 case HP_WMI_PROPERTY_POSSIBLE_STATES:
579                         /* PossibleStates[0] has already been type-checked. */
580                         for (j = 0; i + 1 < elem_count && j + 1 < count; j++) {
581                                 type = elements[++i].type;
582                                 if (type != valid_type)
583                                         return -EINVAL;
584                         }
585
586                         /* Old variant: BaseUnits follows PossibleStates[]. */
587                         if (!is_new)
588                                 prop = HP_WMI_PROPERTY_BASE_UNITS - 1;
589                         break;
590
591                 case HP_WMI_PROPERTY_CURRENT_STATE:
592                         /* Old variant: PossibleStates[] follows CurrentState. */
593                         if (!is_new)
594                                 prop = HP_WMI_PROPERTY_POSSIBLE_STATES - 1;
595                         break;
596                 }
597         }
598
599         if (prop != last_prop + 1)
600                 return -EINVAL;
601
602         *out_size = count;
603         *out_is_new = is_new;
604
605         return 0;
606 }
607
608 static int
609 numeric_sensor_is_connected(const struct hp_wmi_numeric_sensor *nsensor)
610 {
611         u32 operational_status = nsensor->operational_status;
612
613         return operational_status != HP_WMI_STATUS_NO_CONTACT;
614 }
615
616 static int numeric_sensor_has_fault(const struct hp_wmi_numeric_sensor *nsensor)
617 {
618         u32 operational_status = nsensor->operational_status;
619
620         switch (operational_status) {
621         case HP_WMI_STATUS_DEGRADED:
622         case HP_WMI_STATUS_STRESSED:            /* e.g. Overload, overtemp. */
623         case HP_WMI_STATUS_PREDICTIVE_FAILURE:  /* e.g. Fan removed. */
624         case HP_WMI_STATUS_ERROR:
625         case HP_WMI_STATUS_NON_RECOVERABLE_ERROR:
626         case HP_WMI_STATUS_NO_CONTACT:
627         case HP_WMI_STATUS_LOST_COMMUNICATION:
628         case HP_WMI_STATUS_ABORTED:
629         case HP_WMI_STATUS_SUPPORTING_ENTITY_IN_ERROR:
630
631         /* Assume combination by addition; bitwise OR doesn't make sense. */
632         case HP_WMI_STATUS_COMPLETED + HP_WMI_STATUS_DEGRADED:
633         case HP_WMI_STATUS_COMPLETED + HP_WMI_STATUS_ERROR:
634                 return true;
635         }
636
637         return false;
638 }
639
640 /* scale_numeric_sensor - scale sensor reading for hwmon */
641 static long scale_numeric_sensor(const struct hp_wmi_numeric_sensor *nsensor)
642 {
643         u32 current_reading = nsensor->current_reading;
644         s32 unit_modifier = nsensor->unit_modifier;
645         u32 sensor_type = nsensor->sensor_type;
646         u32 base_units = nsensor->base_units;
647         s32 target_modifier;
648         long val;
649
650         /* Fan readings are in RPM units; others are in milliunits. */
651         target_modifier = sensor_type == HP_WMI_TYPE_AIR_FLOW ? 0 : -3;
652
653         val = current_reading;
654
655         for (; unit_modifier < target_modifier; unit_modifier++)
656                 val = DIV_ROUND_CLOSEST(val, 10);
657
658         for (; unit_modifier > target_modifier; unit_modifier--) {
659                 if (val > LONG_MAX / 10) {
660                         val = LONG_MAX;
661                         break;
662                 }
663                 val *= 10;
664         }
665
666         if (sensor_type == HP_WMI_TYPE_TEMPERATURE) {
667                 switch (base_units) {
668                 case HP_WMI_UNITS_DEGREES_F:
669                         val -= MILLI * 32;
670                         val = val <= LONG_MAX / 5 ?
671                                       DIV_ROUND_CLOSEST(val * 5, 9) :
672                                       DIV_ROUND_CLOSEST(val, 9) * 5;
673                         break;
674
675                 case HP_WMI_UNITS_DEGREES_K:
676                         val = milli_kelvin_to_millicelsius(val);
677                         break;
678                 }
679         }
680
681         return val;
682 }
683
684 /*
685  * classify_numeric_sensor - classify a numeric sensor
686  * @nsensor: pointer to numeric sensor struct
687  *
688  * Returns an enum hp_wmi_type value on success,
689  * or a negative value if the sensor type is unsupported.
690  */
691 static int classify_numeric_sensor(const struct hp_wmi_numeric_sensor *nsensor)
692 {
693         u32 sensor_type = nsensor->sensor_type;
694         u32 base_units = nsensor->base_units;
695         const char *name = nsensor->name;
696
697         switch (sensor_type) {
698         case HP_WMI_TYPE_TEMPERATURE:
699                 /*
700                  * Some systems have sensors named "X Thermal Index" in "Other"
701                  * units. Tested CPU sensor examples were found to be in °C,
702                  * albeit perhaps "differently" accurate; e.g. readings were
703                  * reliably -6°C vs. coretemp on a HP Compaq Elite 8300, and
704                  * +8°C on an EliteOne G1 800. But this is still within the
705                  * realm of plausibility for cheaply implemented motherboard
706                  * sensors, and chassis readings were about as expected.
707                  */
708                 if ((base_units == HP_WMI_UNITS_OTHER &&
709                      strstr(name, HP_WMI_PATTERN_TEMP_SENSOR)) ||
710                     base_units == HP_WMI_UNITS_DEGREES_C ||
711                     base_units == HP_WMI_UNITS_DEGREES_F ||
712                     base_units == HP_WMI_UNITS_DEGREES_K)
713                         return HP_WMI_TYPE_TEMPERATURE;
714                 break;
715
716         case HP_WMI_TYPE_VOLTAGE:
717                 if (base_units == HP_WMI_UNITS_VOLTS)
718                         return HP_WMI_TYPE_VOLTAGE;
719                 break;
720
721         case HP_WMI_TYPE_CURRENT:
722                 if (base_units == HP_WMI_UNITS_AMPS)
723                         return HP_WMI_TYPE_CURRENT;
724                 break;
725
726         case HP_WMI_TYPE_AIR_FLOW:
727                 /*
728                  * Strangely, HP considers fan RPM sensor type to be
729                  * "Air Flow" instead of the more intuitive "Tachometer".
730                  */
731                 if (base_units == HP_WMI_UNITS_RPM)
732                         return HP_WMI_TYPE_AIR_FLOW;
733                 break;
734         }
735
736         return -EINVAL;
737 }
738
739 static int
740 populate_numeric_sensor_from_wobj(struct device *dev,
741                                   struct hp_wmi_numeric_sensor *nsensor,
742                                   union acpi_object *wobj, bool *out_is_new)
743 {
744         int last_prop = HP_WMI_PROPERTY_RATE_UNITS;
745         int prop = HP_WMI_PROPERTY_NAME;
746         const char **possible_states;
747         union acpi_object *element;
748         acpi_object_type type;
749         char *string;
750         bool is_new;
751         u32 value;
752         u8 size;
753         int err;
754
755         err = check_numeric_sensor_wobj(wobj, &size, &is_new);
756         if (err)
757                 return err;
758
759         possible_states = devm_kcalloc(dev, size, sizeof(*possible_states),
760                                        GFP_KERNEL);
761         if (!possible_states)
762                 return -ENOMEM;
763
764         element = wobj->package.elements;
765         nsensor->possible_states = possible_states;
766         nsensor->size = size;
767
768         if (!is_new)
769                 last_prop = HP_WMI_PROPERTY_CURRENT_READING;
770
771         for (; prop <= last_prop; prop++) {
772                 type = hp_wmi_property_map[prop];
773
774                 err = extract_acpi_value(dev, element, type, &value, &string);
775                 if (err)
776                         return err;
777
778                 element++;
779
780                 switch (prop) {
781                 case HP_WMI_PROPERTY_NAME:
782                         nsensor->name = string;
783                         break;
784
785                 case HP_WMI_PROPERTY_DESCRIPTION:
786                         nsensor->description = string;
787                         break;
788
789                 case HP_WMI_PROPERTY_SENSOR_TYPE:
790                         if (value > HP_WMI_TYPE_AIR_FLOW)
791                                 return -EINVAL;
792
793                         nsensor->sensor_type = value;
794                         break;
795
796                 case HP_WMI_PROPERTY_OTHER_SENSOR_TYPE:
797                         nsensor->other_sensor_type = string;
798                         break;
799
800                 case HP_WMI_PROPERTY_OPERATIONAL_STATUS:
801                         nsensor->operational_status = value;
802
803                         /* Old variant: CurrentState follows OperationalStatus. */
804                         if (!is_new)
805                                 prop = HP_WMI_PROPERTY_CURRENT_STATE - 1;
806                         break;
807
808                 case HP_WMI_PROPERTY_SIZE:
809                         break;                  /* Already set. */
810
811                 case HP_WMI_PROPERTY_POSSIBLE_STATES:
812                         *possible_states++ = string;
813                         if (--size)
814                                 prop--;
815
816                         /* Old variant: BaseUnits follows PossibleStates[]. */
817                         if (!is_new && !size)
818                                 prop = HP_WMI_PROPERTY_BASE_UNITS - 1;
819                         break;
820
821                 case HP_WMI_PROPERTY_CURRENT_STATE:
822                         nsensor->current_state = string;
823
824                         /* Old variant: PossibleStates[] follows CurrentState. */
825                         if (!is_new)
826                                 prop = HP_WMI_PROPERTY_POSSIBLE_STATES - 1;
827                         break;
828
829                 case HP_WMI_PROPERTY_BASE_UNITS:
830                         nsensor->base_units = value;
831                         break;
832
833                 case HP_WMI_PROPERTY_UNIT_MODIFIER:
834                         /* UnitModifier is signed. */
835                         nsensor->unit_modifier = (s32)value;
836                         break;
837
838                 case HP_WMI_PROPERTY_CURRENT_READING:
839                         nsensor->current_reading = value;
840                         break;
841
842                 case HP_WMI_PROPERTY_RATE_UNITS:
843                         nsensor->rate_units = value;
844                         break;
845
846                 default:
847                         return -EINVAL;
848                 }
849         }
850
851         *out_is_new = is_new;
852
853         return 0;
854 }
855
856 /* update_numeric_sensor_from_wobj - update fungible sensor properties */
857 static void
858 update_numeric_sensor_from_wobj(struct device *dev,
859                                 struct hp_wmi_numeric_sensor *nsensor,
860                                 const union acpi_object *wobj)
861 {
862         const union acpi_object *elements;
863         const union acpi_object *element;
864         const char *string;
865         bool is_new;
866         int offset;
867         u8 size;
868         int err;
869
870         err = check_numeric_sensor_wobj(wobj, &size, &is_new);
871         if (err)
872                 return;
873
874         elements = wobj->package.elements;
875
876         element = &elements[HP_WMI_PROPERTY_OPERATIONAL_STATUS];
877         nsensor->operational_status = element->integer.value;
878
879         /*
880          * In general, an index offset is needed after PossibleStates[0].
881          * On a new variant, CurrentState is after PossibleStates[]. This is
882          * not the case on an old variant, but we still need to offset the
883          * read because CurrentState is where Size would be on a new variant.
884          */
885         offset = is_new ? size - 1 : -2;
886
887         element = &elements[HP_WMI_PROPERTY_CURRENT_STATE + offset];
888         string = strim(element->string.pointer);
889
890         if (strcmp(string, nsensor->current_state)) {
891                 devm_kfree(dev, nsensor->current_state);
892                 nsensor->current_state = hp_wmi_strdup(dev, string);
893         }
894
895         /* Old variant: -2 (not -1) because it lacks the Size property. */
896         if (!is_new)
897                 offset = (int)size - 2; /* size is > 0, i.e. may be 1. */
898
899         element = &elements[HP_WMI_PROPERTY_UNIT_MODIFIER + offset];
900         nsensor->unit_modifier = (s32)element->integer.value;
901
902         element = &elements[HP_WMI_PROPERTY_CURRENT_READING + offset];
903         nsensor->current_reading = element->integer.value;
904 }
905
906 /*
907  * check_platform_events_wobj - validate a HPBIOS_PlatformEvents instance
908  * @wobj: pointer to WMI object instance to check
909  *
910  * Returns 0 on success, or a negative error code on error.
911  */
912 static int check_platform_events_wobj(const union acpi_object *wobj)
913 {
914         return check_wobj(wobj, hp_wmi_platform_events_property_map,
915                           HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_STATUS);
916 }
917
918 static int
919 populate_platform_events_from_wobj(struct device *dev,
920                                    struct hp_wmi_platform_events *pevents,
921                                    union acpi_object *wobj)
922 {
923         int last_prop = HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_STATUS;
924         int prop = HP_WMI_PLATFORM_EVENTS_PROPERTY_NAME;
925         union acpi_object *element;
926         acpi_object_type type;
927         char *string;
928         u32 value;
929         int err;
930
931         err = check_platform_events_wobj(wobj);
932         if (err)
933                 return err;
934
935         element = wobj->package.elements;
936
937         for (; prop <= last_prop; prop++, element++) {
938                 type = hp_wmi_platform_events_property_map[prop];
939
940                 err = extract_acpi_value(dev, element, type, &value, &string);
941                 if (err)
942                         return err;
943
944                 switch (prop) {
945                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_NAME:
946                         pevents->name = string;
947                         break;
948
949                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_DESCRIPTION:
950                         pevents->description = string;
951                         break;
952
953                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_NAMESPACE:
954                         if (strcasecmp(HP_WMI_EVENT_NAMESPACE, string))
955                                 return -EINVAL;
956
957                         pevents->source_namespace = string;
958                         break;
959
960                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_SOURCE_CLASS:
961                         if (strcasecmp(HP_WMI_EVENT_CLASS, string))
962                                 return -EINVAL;
963
964                         pevents->source_class = string;
965                         break;
966
967                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_CATEGORY:
968                         pevents->category = value;
969                         break;
970
971                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_SEVERITY:
972                         pevents->possible_severity = value;
973                         break;
974
975                 case HP_WMI_PLATFORM_EVENTS_PROPERTY_POSSIBLE_STATUS:
976                         pevents->possible_status = value;
977                         break;
978
979                 default:
980                         return -EINVAL;
981                 }
982         }
983
984         return 0;
985 }
986
987 /*
988  * check_event_wobj - validate a HPBIOS_BIOSEvent instance
989  * @wobj: pointer to WMI object instance to check
990  *
991  * Returns 0 on success, or a negative error code on error.
992  */
993 static int check_event_wobj(const union acpi_object *wobj)
994 {
995         return check_wobj(wobj, hp_wmi_event_property_map,
996                           HP_WMI_EVENT_PROPERTY_STATUS);
997 }
998
999 static int populate_event_from_wobj(struct hp_wmi_event *event,
1000                                     union acpi_object *wobj)
1001 {
1002         int prop = HP_WMI_EVENT_PROPERTY_NAME;
1003         union acpi_object *element;
1004         int err;
1005
1006         err = check_event_wobj(wobj);
1007         if (err)
1008                 return err;
1009
1010         element = wobj->package.elements;
1011
1012         /* Extracted strings are NOT device-managed copies. */
1013
1014         for (; prop <= HP_WMI_EVENT_PROPERTY_CATEGORY; prop++, element++) {
1015                 switch (prop) {
1016                 case HP_WMI_EVENT_PROPERTY_NAME:
1017                         event->name = strim(element->string.pointer);
1018                         break;
1019
1020                 case HP_WMI_EVENT_PROPERTY_DESCRIPTION:
1021                         event->description = strim(element->string.pointer);
1022                         break;
1023
1024                 case HP_WMI_EVENT_PROPERTY_CATEGORY:
1025                         event->category = element->integer.value;
1026                         break;
1027
1028                 default:
1029                         return -EINVAL;
1030                 }
1031         }
1032
1033         return 0;
1034 }
1035
1036 /*
1037  * classify_event - classify an event
1038  * @name: event name
1039  * @category: event category
1040  *
1041  * Classify instances of both HPBIOS_PlatformEvents and HPBIOS_BIOSEvent from
1042  * property values. Recognition criteria are based on multiple ACPI dumps [3].
1043  *
1044  * Returns an enum hp_wmi_type value on success,
1045  * or a negative value if the event type is unsupported.
1046  */
1047 static int classify_event(const char *event_name, u32 category)
1048 {
1049         if (category != HP_WMI_CATEGORY_SENSOR)
1050                 return -EINVAL;
1051
1052         /* Fan events have Name "X Stall". */
1053         if (strstr(event_name, HP_WMI_PATTERN_FAN_ALARM))
1054                 return HP_WMI_TYPE_AIR_FLOW;
1055
1056         /* Intrusion events have Name "Hood Intrusion". */
1057         if (!strcmp(event_name, HP_WMI_PATTERN_INTRUSION_ALARM))
1058                 return HP_WMI_TYPE_INTRUSION;
1059
1060         /*
1061          * Temperature events have Name either "Thermal Caution" or
1062          * "Thermal Critical". Deal only with "Thermal Critical" events.
1063          *
1064          * "Thermal Caution" events have Status "Stressed", informing us that
1065          * the OperationalStatus of the related sensor has become "Stressed".
1066          * However, this is already a fault condition that will clear itself
1067          * when the sensor recovers, so we have no further interest in them.
1068          */
1069         if (!strcmp(event_name, HP_WMI_PATTERN_TEMP_ALARM))
1070                 return HP_WMI_TYPE_TEMPERATURE;
1071
1072         return -EINVAL;
1073 }
1074
1075 /*
1076  * interpret_info - interpret sensor for hwmon
1077  * @info: pointer to sensor info struct
1078  *
1079  * Should be called after the numeric sensor member has been updated.
1080  */
1081 static void interpret_info(struct hp_wmi_info *info)
1082 {
1083         const struct hp_wmi_numeric_sensor *nsensor = &info->nsensor;
1084
1085         info->cached_val = scale_numeric_sensor(nsensor);
1086         info->last_updated = jiffies;
1087 }
1088
1089 /*
1090  * hp_wmi_update_info - poll WMI to update sensor info
1091  * @state: pointer to driver state
1092  * @info: pointer to sensor info struct
1093  *
1094  * Returns 0 on success, or a negative error code on error.
1095  */
1096 static int hp_wmi_update_info(struct hp_wmi_sensors *state,
1097                               struct hp_wmi_info *info)
1098 {
1099         struct hp_wmi_numeric_sensor *nsensor = &info->nsensor;
1100         struct device *dev = &state->wdev->dev;
1101         const union acpi_object *wobj;
1102         u8 instance = info->instance;
1103         int ret = 0;
1104
1105         if (time_after(jiffies, info->last_updated + HZ)) {
1106                 mutex_lock(&state->lock);
1107
1108                 wobj = hp_wmi_get_wobj(HP_WMI_NUMERIC_SENSOR_GUID, instance);
1109                 if (!wobj) {
1110                         ret = -EIO;
1111                         goto out_unlock;
1112                 }
1113
1114                 update_numeric_sensor_from_wobj(dev, nsensor, wobj);
1115
1116                 interpret_info(info);
1117
1118                 kfree(wobj);
1119
1120 out_unlock:
1121                 mutex_unlock(&state->lock);
1122         }
1123
1124         return ret;
1125 }
1126
1127 static int basic_string_show(struct seq_file *seqf, void *ignored)
1128 {
1129         const char *str = seqf->private;
1130
1131         seq_printf(seqf, "%s\n", str);
1132
1133         return 0;
1134 }
1135 DEFINE_SHOW_ATTRIBUTE(basic_string);
1136
1137 static int fungible_show(struct seq_file *seqf, enum hp_wmi_property prop)
1138 {
1139         struct hp_wmi_numeric_sensor *nsensor;
1140         struct hp_wmi_sensors *state;
1141         struct hp_wmi_info *info;
1142         int err;
1143
1144         info = seqf->private;
1145         state = info->state;
1146         nsensor = &info->nsensor;
1147
1148         err = hp_wmi_update_info(state, info);
1149         if (err)
1150                 return err;
1151
1152         switch (prop) {
1153         case HP_WMI_PROPERTY_OPERATIONAL_STATUS:
1154                 seq_printf(seqf, "%u\n", nsensor->operational_status);
1155                 break;
1156
1157         case HP_WMI_PROPERTY_CURRENT_STATE:
1158                 seq_printf(seqf, "%s\n", nsensor->current_state);
1159                 break;
1160
1161         case HP_WMI_PROPERTY_UNIT_MODIFIER:
1162                 seq_printf(seqf, "%d\n", nsensor->unit_modifier);
1163                 break;
1164
1165         case HP_WMI_PROPERTY_CURRENT_READING:
1166                 seq_printf(seqf, "%u\n", nsensor->current_reading);
1167                 break;
1168
1169         default:
1170                 return -EOPNOTSUPP;
1171         }
1172
1173         return 0;
1174 }
1175
1176 static int operational_status_show(struct seq_file *seqf, void *ignored)
1177 {
1178         return fungible_show(seqf, HP_WMI_PROPERTY_OPERATIONAL_STATUS);
1179 }
1180 DEFINE_SHOW_ATTRIBUTE(operational_status);
1181
1182 static int current_state_show(struct seq_file *seqf, void *ignored)
1183 {
1184         return fungible_show(seqf, HP_WMI_PROPERTY_CURRENT_STATE);
1185 }
1186 DEFINE_SHOW_ATTRIBUTE(current_state);
1187
1188 static int possible_states_show(struct seq_file *seqf, void *ignored)
1189 {
1190         struct hp_wmi_numeric_sensor *nsensor = seqf->private;
1191         u8 i;
1192
1193         for (i = 0; i < nsensor->size; i++)
1194                 seq_printf(seqf, "%s%s", i ? "," : "",
1195                            nsensor->possible_states[i]);
1196
1197         seq_puts(seqf, "\n");
1198
1199         return 0;
1200 }
1201 DEFINE_SHOW_ATTRIBUTE(possible_states);
1202
1203 static int unit_modifier_show(struct seq_file *seqf, void *ignored)
1204 {
1205         return fungible_show(seqf, HP_WMI_PROPERTY_UNIT_MODIFIER);
1206 }
1207 DEFINE_SHOW_ATTRIBUTE(unit_modifier);
1208
1209 static int current_reading_show(struct seq_file *seqf, void *ignored)
1210 {
1211         return fungible_show(seqf, HP_WMI_PROPERTY_CURRENT_READING);
1212 }
1213 DEFINE_SHOW_ATTRIBUTE(current_reading);
1214
1215 /* hp_wmi_devm_debugfs_remove - devm callback for debugfs cleanup */
1216 static void hp_wmi_devm_debugfs_remove(void *res)
1217 {
1218         debugfs_remove_recursive(res);
1219 }
1220
1221 /* hp_wmi_debugfs_init - create and populate debugfs directory tree */
1222 static void hp_wmi_debugfs_init(struct device *dev, struct hp_wmi_info *info,
1223                                 struct hp_wmi_platform_events *pevents,
1224                                 u8 icount, u8 pcount, bool is_new)
1225 {
1226         struct hp_wmi_numeric_sensor *nsensor;
1227         char buf[HP_WMI_MAX_STR_SIZE];
1228         struct dentry *debugfs;
1229         struct dentry *entries;
1230         struct dentry *dir;
1231         int err;
1232         u8 i;
1233
1234         /* dev_name() gives a not-very-friendly GUID for WMI devices. */
1235         scnprintf(buf, sizeof(buf), "hp-wmi-sensors-%u", dev->id);
1236
1237         debugfs = debugfs_create_dir(buf, NULL);
1238         if (IS_ERR(debugfs))
1239                 return;
1240
1241         err = devm_add_action_or_reset(dev, hp_wmi_devm_debugfs_remove,
1242                                        debugfs);
1243         if (err)
1244                 return;
1245
1246         entries = debugfs_create_dir("sensor", debugfs);
1247
1248         for (i = 0; i < icount; i++, info++) {
1249                 nsensor = &info->nsensor;
1250
1251                 scnprintf(buf, sizeof(buf), "%u", i);
1252                 dir = debugfs_create_dir(buf, entries);
1253
1254                 debugfs_create_file("name", 0444, dir,
1255                                     (void *)nsensor->name,
1256                                     &basic_string_fops);
1257
1258                 debugfs_create_file("description", 0444, dir,
1259                                     (void *)nsensor->description,
1260                                     &basic_string_fops);
1261
1262                 debugfs_create_u32("sensor_type", 0444, dir,
1263                                    &nsensor->sensor_type);
1264
1265                 debugfs_create_file("other_sensor_type", 0444, dir,
1266                                     (void *)nsensor->other_sensor_type,
1267                                     &basic_string_fops);
1268
1269                 debugfs_create_file("operational_status", 0444, dir,
1270                                     info, &operational_status_fops);
1271
1272                 debugfs_create_file("possible_states", 0444, dir,
1273                                     nsensor, &possible_states_fops);
1274
1275                 debugfs_create_file("current_state", 0444, dir,
1276                                     info, &current_state_fops);
1277
1278                 debugfs_create_u32("base_units", 0444, dir,
1279                                    &nsensor->base_units);
1280
1281                 debugfs_create_file("unit_modifier", 0444, dir,
1282                                     info, &unit_modifier_fops);
1283
1284                 debugfs_create_file("current_reading", 0444, dir,
1285                                     info, &current_reading_fops);
1286
1287                 if (is_new)
1288                         debugfs_create_u32("rate_units", 0444, dir,
1289                                            &nsensor->rate_units);
1290         }
1291
1292         if (!pcount)
1293                 return;
1294
1295         entries = debugfs_create_dir("platform_events", debugfs);
1296
1297         for (i = 0; i < pcount; i++, pevents++) {
1298                 scnprintf(buf, sizeof(buf), "%u", i);
1299                 dir = debugfs_create_dir(buf, entries);
1300
1301                 debugfs_create_file("name", 0444, dir,
1302                                     (void *)pevents->name,
1303                                     &basic_string_fops);
1304
1305                 debugfs_create_file("description", 0444, dir,
1306                                     (void *)pevents->description,
1307                                     &basic_string_fops);
1308
1309                 debugfs_create_file("source_namespace", 0444, dir,
1310                                     (void *)pevents->source_namespace,
1311                                     &basic_string_fops);
1312
1313                 debugfs_create_file("source_class", 0444, dir,
1314                                     (void *)pevents->source_class,
1315                                     &basic_string_fops);
1316
1317                 debugfs_create_u32("category", 0444, dir,
1318                                    &pevents->category);
1319
1320                 debugfs_create_u32("possible_severity", 0444, dir,
1321                                    &pevents->possible_severity);
1322
1323                 debugfs_create_u32("possible_status", 0444, dir,
1324                                    &pevents->possible_status);
1325         }
1326 }
1327
1328 static umode_t hp_wmi_hwmon_is_visible(const void *drvdata,
1329                                        enum hwmon_sensor_types type,
1330                                        u32 attr, int channel)
1331 {
1332         const struct hp_wmi_sensors *state = drvdata;
1333         const struct hp_wmi_info *info;
1334
1335         if (type == hwmon_intrusion)
1336                 return state->has_intrusion ? 0644 : 0;
1337
1338         if (!state->info_map[type] || !state->info_map[type][channel])
1339                 return 0;
1340
1341         info = state->info_map[type][channel];
1342
1343         if ((type == hwmon_temp && attr == hwmon_temp_alarm) ||
1344             (type == hwmon_fan  && attr == hwmon_fan_alarm))
1345                 return info->has_alarm ? 0444 : 0;
1346
1347         return 0444;
1348 }
1349
1350 static int hp_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
1351                              u32 attr, int channel, long *out_val)
1352 {
1353         struct hp_wmi_sensors *state = dev_get_drvdata(dev);
1354         const struct hp_wmi_numeric_sensor *nsensor;
1355         struct hp_wmi_info *info;
1356         int err;
1357
1358         if (type == hwmon_intrusion) {
1359                 *out_val = state->intrusion ? 1 : 0;
1360
1361                 return 0;
1362         }
1363
1364         info = state->info_map[type][channel];
1365
1366         if ((type == hwmon_temp && attr == hwmon_temp_alarm) ||
1367             (type == hwmon_fan  && attr == hwmon_fan_alarm)) {
1368                 *out_val = info->alarm ? 1 : 0;
1369                 info->alarm = false;
1370
1371                 return 0;
1372         }
1373
1374         nsensor = &info->nsensor;
1375
1376         err = hp_wmi_update_info(state, info);
1377         if (err)
1378                 return err;
1379
1380         if ((type == hwmon_temp && attr == hwmon_temp_fault) ||
1381             (type == hwmon_fan  && attr == hwmon_fan_fault))
1382                 *out_val = numeric_sensor_has_fault(nsensor);
1383         else
1384                 *out_val = info->cached_val;
1385
1386         return 0;
1387 }
1388
1389 static int hp_wmi_hwmon_read_string(struct device *dev,
1390                                     enum hwmon_sensor_types type, u32 attr,
1391                                     int channel, const char **out_str)
1392 {
1393         const struct hp_wmi_sensors *state = dev_get_drvdata(dev);
1394         const struct hp_wmi_info *info;
1395
1396         info = state->info_map[type][channel];
1397         *out_str = info->nsensor.name;
1398
1399         return 0;
1400 }
1401
1402 static int hp_wmi_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
1403                               u32 attr, int channel, long val)
1404 {
1405         struct hp_wmi_sensors *state = dev_get_drvdata(dev);
1406
1407         if (val)
1408                 return -EINVAL;
1409
1410         mutex_lock(&state->lock);
1411
1412         state->intrusion = false;
1413
1414         mutex_unlock(&state->lock);
1415
1416         return 0;
1417 }
1418
1419 static const struct hwmon_ops hp_wmi_hwmon_ops = {
1420         .is_visible  = hp_wmi_hwmon_is_visible,
1421         .read        = hp_wmi_hwmon_read,
1422         .read_string = hp_wmi_hwmon_read_string,
1423         .write       = hp_wmi_hwmon_write,
1424 };
1425
1426 static struct hwmon_chip_info hp_wmi_chip_info = {
1427         .ops         = &hp_wmi_hwmon_ops,
1428         .info        = NULL,
1429 };
1430
1431 static struct hp_wmi_info *match_fan_event(struct hp_wmi_sensors *state,
1432                                            const char *event_description)
1433 {
1434         struct hp_wmi_info **ptr_info = state->info_map[hwmon_fan];
1435         u8 fan_count = state->channel_count[hwmon_fan];
1436         struct hp_wmi_info *info;
1437         const char *name;
1438         u8 i;
1439
1440         /* Fan event has Description "X Speed". Sensor has Name "X[ Speed]". */
1441
1442         for (i = 0; i < fan_count; i++, ptr_info++) {
1443                 info = *ptr_info;
1444                 name = info->nsensor.name;
1445
1446                 if (strstr(event_description, name))
1447                         return info;
1448         }
1449
1450         return NULL;
1451 }
1452
1453 static u8 match_temp_events(struct hp_wmi_sensors *state,
1454                             const char *event_description,
1455                             struct hp_wmi_info *temp_info[])
1456 {
1457         struct hp_wmi_info **ptr_info = state->info_map[hwmon_temp];
1458         u8 temp_count = state->channel_count[hwmon_temp];
1459         struct hp_wmi_info *info;
1460         const char *name;
1461         u8 count = 0;
1462         bool is_cpu;
1463         bool is_sys;
1464         u8 i;
1465
1466         /* Description is either "CPU Thermal Index" or "Chassis Thermal Index". */
1467
1468         is_cpu = !strcmp(event_description, HP_WMI_PATTERN_CPU_TEMP);
1469         is_sys = !strcmp(event_description, HP_WMI_PATTERN_SYS_TEMP);
1470         if (!is_cpu && !is_sys)
1471                 return 0;
1472
1473         /*
1474          * CPU event: Match one sensor with Name either "CPU Thermal Index" or
1475          * "CPU Temperature", or multiple with Name(s) "CPU[#] Temperature".
1476          *
1477          * Chassis event: Match one sensor with Name either
1478          * "Chassis Thermal Index" or "System Ambient Temperature".
1479          */
1480
1481         for (i = 0; i < temp_count; i++, ptr_info++) {
1482                 info = *ptr_info;
1483                 name = info->nsensor.name;
1484
1485                 if ((is_cpu && (!strcmp(name, HP_WMI_PATTERN_CPU_TEMP) ||
1486                                 !strcmp(name, HP_WMI_PATTERN_CPU_TEMP2))) ||
1487                     (is_sys && (!strcmp(name, HP_WMI_PATTERN_SYS_TEMP) ||
1488                                 !strcmp(name, HP_WMI_PATTERN_SYS_TEMP2)))) {
1489                         temp_info[0] = info;
1490                         return 1;
1491                 }
1492
1493                 if (is_cpu && (strstr(name, HP_WMI_PATTERN_CPU) &&
1494                                strstr(name, HP_WMI_PATTERN_TEMP)))
1495                         temp_info[count++] = info;
1496         }
1497
1498         return count;
1499 }
1500
1501 /* hp_wmi_devm_debugfs_remove - devm callback for WMI event handler removal */
1502 static void hp_wmi_devm_notify_remove(void *ignored)
1503 {
1504         wmi_remove_notify_handler(HP_WMI_EVENT_GUID);
1505 }
1506
1507 /* hp_wmi_notify - WMI event notification handler */
1508 static void hp_wmi_notify(u32 value, void *context)
1509 {
1510         struct hp_wmi_info *temp_info[HP_WMI_MAX_INSTANCES] = {};
1511         struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
1512         struct hp_wmi_sensors *state = context;
1513         struct device *dev = &state->wdev->dev;
1514         struct hp_wmi_info *fan_info;
1515         struct hp_wmi_event event;
1516         union acpi_object *wobj;
1517         acpi_status err;
1518         int event_type;
1519         u8 count;
1520
1521         /*
1522          * The following warning may occur in the kernel log:
1523          *
1524          *   ACPI Warning: \_SB.WMID._WED: Return type mismatch -
1525          *     found Package, expected Integer/String/Buffer
1526          *
1527          * After using [4] to decode BMOF blobs found in [3], careless copying
1528          * of BIOS code seems the most likely explanation for this warning.
1529          * HP_WMI_EVENT_GUID refers to \\.\root\WMI\HPBIOS_BIOSEvent on
1530          * business-class systems, but it refers to \\.\root\WMI\hpqBEvnt on
1531          * non-business-class systems. Per the existing hp-wmi driver, it
1532          * looks like an instance of hpqBEvnt delivered as event data may
1533          * indeed take the form of a raw ACPI_BUFFER on non-business-class
1534          * systems ("may" because ASL shows some BIOSes do strange things).
1535          *
1536          * In any case, we can ignore this warning, because we always validate
1537          * the event data to ensure it is an ACPI_PACKAGE containing a
1538          * HPBIOS_BIOSEvent instance.
1539          */
1540
1541         mutex_lock(&state->lock);
1542
1543         err = wmi_get_event_data(value, &out);
1544         if (ACPI_FAILURE(err))
1545                 goto out_unlock;
1546
1547         wobj = out.pointer;
1548
1549         err = populate_event_from_wobj(&event, wobj);
1550         if (err) {
1551                 dev_warn(dev, "Bad event data (ACPI type %d)\n", wobj->type);
1552                 goto out_free_wobj;
1553         }
1554
1555         event_type = classify_event(event.name, event.category);
1556         switch (event_type) {
1557         case HP_WMI_TYPE_AIR_FLOW:
1558                 fan_info = match_fan_event(state, event.description);
1559                 if (fan_info)
1560                         fan_info->alarm = true;
1561                 break;
1562
1563         case HP_WMI_TYPE_INTRUSION:
1564                 state->intrusion = true;
1565                 break;
1566
1567         case HP_WMI_TYPE_TEMPERATURE:
1568                 count = match_temp_events(state, event.description, temp_info);
1569                 while (count)
1570                         temp_info[--count]->alarm = true;
1571                 break;
1572
1573         default:
1574                 break;
1575         }
1576
1577 out_free_wobj:
1578         kfree(wobj);
1579
1580 out_unlock:
1581         mutex_unlock(&state->lock);
1582 }
1583
1584 static int init_platform_events(struct device *dev,
1585                                 struct hp_wmi_platform_events **out_pevents,
1586                                 u8 *out_pcount)
1587 {
1588         struct hp_wmi_platform_events *pevents_arr;
1589         struct hp_wmi_platform_events *pevents;
1590         union acpi_object *wobj;
1591         u8 count;
1592         int err;
1593         u8 i;
1594
1595         count = hp_wmi_wobj_instance_count(HP_WMI_PLATFORM_EVENTS_GUID);
1596         if (!count) {
1597                 *out_pcount = 0;
1598
1599                 dev_dbg(dev, "No platform events\n");
1600
1601                 return 0;
1602         }
1603
1604         pevents_arr = devm_kcalloc(dev, count, sizeof(*pevents), GFP_KERNEL);
1605         if (!pevents_arr)
1606                 return -ENOMEM;
1607
1608         for (i = 0, pevents = pevents_arr; i < count; i++, pevents++) {
1609                 wobj = hp_wmi_get_wobj(HP_WMI_PLATFORM_EVENTS_GUID, i);
1610                 if (!wobj)
1611                         return -EIO;
1612
1613                 err = populate_platform_events_from_wobj(dev, pevents, wobj);
1614
1615                 kfree(wobj);
1616
1617                 if (err)
1618                         return err;
1619         }
1620
1621         *out_pevents = pevents_arr;
1622         *out_pcount = count;
1623
1624         dev_dbg(dev, "Found %u platform events\n", count);
1625
1626         return 0;
1627 }
1628
1629 static int init_numeric_sensors(struct hp_wmi_sensors *state,
1630                                 struct hp_wmi_info *connected[],
1631                                 struct hp_wmi_info **out_info,
1632                                 u8 *out_icount, u8 *out_count,
1633                                 bool *out_is_new)
1634 {
1635         struct hp_wmi_info ***info_map = state->info_map;
1636         u8 *channel_count = state->channel_count;
1637         struct device *dev = &state->wdev->dev;
1638         struct hp_wmi_numeric_sensor *nsensor;
1639         u8 channel_index[hwmon_max] = {};
1640         enum hwmon_sensor_types type;
1641         struct hp_wmi_info *info_arr;
1642         struct hp_wmi_info *info;
1643         union acpi_object *wobj;
1644         u8 count = 0;
1645         bool is_new;
1646         u8 icount;
1647         int wtype;
1648         int err;
1649         u8 c;
1650         u8 i;
1651
1652         icount = hp_wmi_wobj_instance_count(HP_WMI_NUMERIC_SENSOR_GUID);
1653         if (!icount)
1654                 return -ENODATA;
1655
1656         info_arr = devm_kcalloc(dev, icount, sizeof(*info), GFP_KERNEL);
1657         if (!info_arr)
1658                 return -ENOMEM;
1659
1660         for (i = 0, info = info_arr; i < icount; i++, info++) {
1661                 wobj = hp_wmi_get_wobj(HP_WMI_NUMERIC_SENSOR_GUID, i);
1662                 if (!wobj)
1663                         return -EIO;
1664
1665                 info->instance = i;
1666                 info->state = state;
1667                 nsensor = &info->nsensor;
1668
1669                 err = populate_numeric_sensor_from_wobj(dev, nsensor, wobj,
1670                                                         &is_new);
1671
1672                 kfree(wobj);
1673
1674                 if (err)
1675                         return err;
1676
1677                 if (!numeric_sensor_is_connected(nsensor))
1678                         continue;
1679
1680                 wtype = classify_numeric_sensor(nsensor);
1681                 if (wtype < 0)
1682                         continue;
1683
1684                 type = hp_wmi_hwmon_type_map[wtype];
1685
1686                 channel_count[type]++;
1687
1688                 info->type = type;
1689
1690                 interpret_info(info);
1691
1692                 connected[count++] = info;
1693         }
1694
1695         dev_dbg(dev, "Found %u sensors (%u connected)\n", i, count);
1696
1697         for (i = 0; i < count; i++) {
1698                 info = connected[i];
1699                 type = info->type;
1700                 c = channel_index[type]++;
1701
1702                 if (!info_map[type]) {
1703                         info_map[type] = devm_kcalloc(dev, channel_count[type],
1704                                                       sizeof(*info_map),
1705                                                       GFP_KERNEL);
1706                         if (!info_map[type])
1707                                 return -ENOMEM;
1708                 }
1709
1710                 info_map[type][c] = info;
1711         }
1712
1713         *out_info = info_arr;
1714         *out_icount = icount;
1715         *out_count = count;
1716         *out_is_new = is_new;
1717
1718         return 0;
1719 }
1720
1721 static bool find_event_attributes(struct hp_wmi_sensors *state,
1722                                   struct hp_wmi_platform_events *pevents,
1723                                   u8 pevents_count)
1724 {
1725         /*
1726          * The existence of this HPBIOS_PlatformEvents instance:
1727          *
1728          *   {
1729          *     Name = "Rear Chassis Fan0 Stall";
1730          *     Description = "Rear Chassis Fan0 Speed";
1731          *     Category = 3;           // "Sensor"
1732          *     PossibleSeverity = 25;  // "Critical Failure"
1733          *     PossibleStatus = 5;     // "Predictive Failure"
1734          *     [...]
1735          *   }
1736          *
1737          * means that this HPBIOS_BIOSEvent instance may occur:
1738          *
1739          *   {
1740          *     Name = "Rear Chassis Fan0 Stall";
1741          *     Description = "Rear Chassis Fan0 Speed";
1742          *     Category = 3;           // "Sensor"
1743          *     Severity = 25;          // "Critical Failure"
1744          *     Status = 5;             // "Predictive Failure"
1745          *   }
1746          *
1747          * After the event occurs (e.g. because the fan was unplugged),
1748          * polling the related HPBIOS_BIOSNumericSensor instance gives:
1749          *
1750          *   {
1751          *      Name = "Rear Chassis Fan0";
1752          *      Description = "Reports rear chassis fan0 speed";
1753          *      OperationalStatus = 5; // "Predictive Failure", was 3 ("OK")
1754          *      CurrentReading = 0;
1755          *      [...]
1756          *   }
1757          *
1758          * In this example, the hwmon fan channel for "Rear Chassis Fan0"
1759          * should support the alarm flag and have it be set if the related
1760          * HPBIOS_BIOSEvent instance occurs.
1761          *
1762          * In addition to fan events, temperature (CPU/chassis) and intrusion
1763          * events are relevant to hwmon [2]. Note that much information in [2]
1764          * is unreliable; it is referenced in addition to ACPI dumps [3] merely
1765          * to support the conclusion that sensor and event names/descriptions
1766          * are systematic enough to allow this driver to match them.
1767          *
1768          * Complications and limitations:
1769          *
1770          * - Strings are freeform and may vary, cf. sensor Name "CPU0 Fan"
1771          *   on a Z420 vs. "CPU Fan Speed" on an EliteOne 800 G1.
1772          * - Leading/trailing whitespace is a rare but real possibility [3].
1773          * - The HPBIOS_PlatformEvents object may not exist or its instances
1774          *   may show that the system only has e.g. BIOS setting-related
1775          *   events (cf. the ProBook 4540s and ProBook 470 G0 [3]).
1776          */
1777
1778         struct hp_wmi_info *temp_info[HP_WMI_MAX_INSTANCES] = {};
1779         const char *event_description;
1780         struct hp_wmi_info *fan_info;
1781         bool has_events = false;
1782         const char *event_name;
1783         u32 event_category;
1784         int event_type;
1785         u8 count;
1786         u8 i;
1787
1788         for (i = 0; i < pevents_count; i++, pevents++) {
1789                 event_name = pevents->name;
1790                 event_description = pevents->description;
1791                 event_category = pevents->category;
1792
1793                 event_type = classify_event(event_name, event_category);
1794                 switch (event_type) {
1795                 case HP_WMI_TYPE_AIR_FLOW:
1796                         fan_info = match_fan_event(state, event_description);
1797                         if (!fan_info)
1798                                 break;
1799
1800                         fan_info->has_alarm = true;
1801                         has_events = true;
1802                         break;
1803
1804                 case HP_WMI_TYPE_INTRUSION:
1805                         state->has_intrusion = true;
1806                         has_events = true;
1807                         break;
1808
1809                 case HP_WMI_TYPE_TEMPERATURE:
1810                         count = match_temp_events(state, event_description,
1811                                                   temp_info);
1812                         if (!count)
1813                                 break;
1814
1815                         while (count)
1816                                 temp_info[--count]->has_alarm = true;
1817                         has_events = true;
1818                         break;
1819
1820                 default:
1821                         break;
1822                 }
1823         }
1824
1825         return has_events;
1826 }
1827
1828 static int make_chip_info(struct hp_wmi_sensors *state, bool has_events)
1829 {
1830         const struct hwmon_channel_info **ptr_channel_info;
1831         struct hp_wmi_info ***info_map = state->info_map;
1832         u8 *channel_count = state->channel_count;
1833         struct hwmon_channel_info *channel_info;
1834         struct device *dev = &state->wdev->dev;
1835         enum hwmon_sensor_types type;
1836         u8 type_count = 0;
1837         u32 *config;
1838         u32 attr;
1839         u8 count;
1840         u8 i;
1841
1842         if (channel_count[hwmon_temp])
1843                 channel_count[hwmon_chip] = 1;
1844
1845         if (has_events && state->has_intrusion)
1846                 channel_count[hwmon_intrusion] = 1;
1847
1848         for (type = hwmon_chip; type < hwmon_max; type++)
1849                 if (channel_count[type])
1850                         type_count++;
1851
1852         channel_info = devm_kcalloc(dev, type_count,
1853                                     sizeof(*channel_info), GFP_KERNEL);
1854         if (!channel_info)
1855                 return -ENOMEM;
1856
1857         ptr_channel_info = devm_kcalloc(dev, type_count + 1,
1858                                         sizeof(*ptr_channel_info), GFP_KERNEL);
1859         if (!ptr_channel_info)
1860                 return -ENOMEM;
1861
1862         hp_wmi_chip_info.info = ptr_channel_info;
1863
1864         for (type = hwmon_chip; type < hwmon_max; type++) {
1865                 count = channel_count[type];
1866                 if (!count)
1867                         continue;
1868
1869                 config = devm_kcalloc(dev, count + 1,
1870                                       sizeof(*config), GFP_KERNEL);
1871                 if (!config)
1872                         return -ENOMEM;
1873
1874                 attr = hp_wmi_hwmon_attributes[type];
1875                 channel_info->type = type;
1876                 channel_info->config = config;
1877                 memset32(config, attr, count);
1878
1879                 *ptr_channel_info++ = channel_info++;
1880
1881                 if (!has_events || (type != hwmon_temp && type != hwmon_fan))
1882                         continue;
1883
1884                 attr = type == hwmon_temp ? HWMON_T_ALARM : HWMON_F_ALARM;
1885
1886                 for (i = 0; i < count; i++)
1887                         if (info_map[type][i]->has_alarm)
1888                                 config[i] |= attr;
1889         }
1890
1891         return 0;
1892 }
1893
1894 static bool add_event_handler(struct hp_wmi_sensors *state)
1895 {
1896         struct device *dev = &state->wdev->dev;
1897         int err;
1898
1899         err = wmi_install_notify_handler(HP_WMI_EVENT_GUID,
1900                                          hp_wmi_notify, state);
1901         if (err) {
1902                 dev_info(dev, "Failed to subscribe to WMI event\n");
1903                 return false;
1904         }
1905
1906         err = devm_add_action_or_reset(dev, hp_wmi_devm_notify_remove, NULL);
1907         if (err)
1908                 return false;
1909
1910         return true;
1911 }
1912
1913 static int hp_wmi_sensors_init(struct hp_wmi_sensors *state)
1914 {
1915         struct hp_wmi_info *connected[HP_WMI_MAX_INSTANCES];
1916         struct hp_wmi_platform_events *pevents = NULL;
1917         struct device *dev = &state->wdev->dev;
1918         struct hp_wmi_info *info;
1919         struct device *hwdev;
1920         bool has_events;
1921         bool is_new;
1922         u8 icount;
1923         u8 pcount;
1924         u8 count;
1925         int err;
1926
1927         err = init_platform_events(dev, &pevents, &pcount);
1928         if (err)
1929                 return err;
1930
1931         err = init_numeric_sensors(state, connected, &info,
1932                                    &icount, &count, &is_new);
1933         if (err)
1934                 return err;
1935
1936         if (IS_ENABLED(CONFIG_DEBUG_FS))
1937                 hp_wmi_debugfs_init(dev, info, pevents, icount, pcount, is_new);
1938
1939         if (!count)
1940                 return 0;       /* No connected sensors; debugfs only. */
1941
1942         has_events = find_event_attributes(state, pevents, pcount);
1943
1944         /* Survive failure to install WMI event handler. */
1945         if (has_events && !add_event_handler(state))
1946                 has_events = false;
1947
1948         err = make_chip_info(state, has_events);
1949         if (err)
1950                 return err;
1951
1952         hwdev = devm_hwmon_device_register_with_info(dev, "hp_wmi_sensors",
1953                                                      state, &hp_wmi_chip_info,
1954                                                      NULL);
1955         return PTR_ERR_OR_ZERO(hwdev);
1956 }
1957
1958 static int hp_wmi_sensors_probe(struct wmi_device *wdev, const void *context)
1959 {
1960         struct device *dev = &wdev->dev;
1961         struct hp_wmi_sensors *state;
1962
1963         state = devm_kzalloc(dev, sizeof(*state), GFP_KERNEL);
1964         if (!state)
1965                 return -ENOMEM;
1966
1967         state->wdev = wdev;
1968
1969         mutex_init(&state->lock);
1970
1971         dev_set_drvdata(dev, state);
1972
1973         return hp_wmi_sensors_init(state);
1974 }
1975
1976 static const struct wmi_device_id hp_wmi_sensors_id_table[] = {
1977         { HP_WMI_NUMERIC_SENSOR_GUID, NULL },
1978         {},
1979 };
1980
1981 static struct wmi_driver hp_wmi_sensors_driver = {
1982         .driver   = { .name = "hp-wmi-sensors" },
1983         .id_table = hp_wmi_sensors_id_table,
1984         .probe    = hp_wmi_sensors_probe,
1985 };
1986 module_wmi_driver(hp_wmi_sensors_driver);
1987
1988 MODULE_AUTHOR("James Seo <james@equiv.tech>");
1989 MODULE_DESCRIPTION("HP WMI Sensors driver");
1990 MODULE_LICENSE("GPL");