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