1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * A hwmon driver for the IBM PowerExecutive temperature/power sensors 4 * Copyright (C) 2007 IBM 5 * 6 * Author: Darrick J. Wong <darrick.wong@oracle.com> 7 */ 8 9 #include <linux/ipmi.h> 10 #include <linux/module.h> 11 #include <linux/hwmon.h> 12 #include <linux/hwmon-sysfs.h> 13 #include <linux/jiffies.h> 14 #include <linux/mutex.h> 15 #include <linux/slab.h> 16 #include <linux/err.h> 17 18 #define REFRESH_INTERVAL (2 * HZ) 19 #define DRVNAME "ibmpex" 20 21 #define PEX_GET_VERSION 1 22 #define PEX_GET_SENSOR_COUNT 2 23 #define PEX_GET_SENSOR_NAME 3 24 #define PEX_RESET_HIGH_LOW 4 25 #define PEX_GET_SENSOR_DATA 6 26 27 #define PEX_NET_FUNCTION 0x3A 28 #define PEX_COMMAND 0x3C 29 30 static inline u16 extract_value(const char *data, int offset) 31 { 32 return be16_to_cpup((__be16 *)&data[offset]); 33 } 34 35 #define TEMP_SENSOR 1 36 #define POWER_SENSOR 2 37 38 #define PEX_SENSOR_TYPE_LEN 3 39 static u8 const power_sensor_sig[] = {0x70, 0x77, 0x72}; 40 static u8 const temp_sensor_sig[] = {0x74, 0x65, 0x6D}; 41 42 #define PEX_MULT_LEN 2 43 static u8 const watt_sensor_sig[] = {0x41, 0x43}; 44 45 #define PEX_NUM_SENSOR_FUNCS 3 46 static const char * const sensor_name_suffixes[] = { 47 "", 48 "_lowest", 49 "_highest" 50 }; 51 52 static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data); 53 static void ibmpex_register_bmc(int iface, struct device *dev); 54 static void ibmpex_bmc_gone(int iface); 55 56 struct ibmpex_sensor_data { 57 int in_use; 58 s16 values[PEX_NUM_SENSOR_FUNCS]; 59 int multiplier; 60 61 struct sensor_device_attribute_2 attr[PEX_NUM_SENSOR_FUNCS]; 62 }; 63 64 struct ibmpex_bmc_data { 65 struct list_head list; 66 struct device *hwmon_dev; 67 struct device *bmc_device; 68 struct mutex lock; 69 bool valid; 70 unsigned long last_updated; /* In jiffies */ 71 72 struct ipmi_addr address; 73 struct completion read_complete; 74 struct ipmi_user *user; 75 int interface; 76 77 struct kernel_ipmi_msg tx_message; 78 unsigned char tx_msg_data[IPMI_MAX_MSG_LENGTH]; 79 long tx_msgid; 80 81 unsigned char rx_msg_data[IPMI_MAX_MSG_LENGTH]; 82 unsigned long rx_msg_len; 83 unsigned char rx_result; 84 int rx_recv_type; 85 86 unsigned char sensor_major; 87 unsigned char sensor_minor; 88 89 unsigned char num_sensors; 90 struct ibmpex_sensor_data *sensors; 91 }; 92 93 struct ibmpex_driver_data { 94 struct list_head bmc_data; 95 struct ipmi_smi_watcher bmc_events; 96 struct ipmi_user_hndl ipmi_hndlrs; 97 }; 98 99 static struct ibmpex_driver_data driver_data = { 100 .bmc_data = LIST_HEAD_INIT(driver_data.bmc_data), 101 .bmc_events = { 102 .owner = THIS_MODULE, 103 .new_smi = ibmpex_register_bmc, 104 .smi_gone = ibmpex_bmc_gone, 105 }, 106 .ipmi_hndlrs = { 107 .ipmi_recv_hndl = ibmpex_msg_handler, 108 }, 109 }; 110 111 static int ibmpex_send_message(struct ibmpex_bmc_data *data) 112 { 113 int err; 114 115 err = ipmi_validate_addr(&data->address, sizeof(data->address)); 116 if (err) 117 goto out; 118 119 data->tx_msgid++; 120 err = ipmi_request_settime(data->user, &data->address, data->tx_msgid, 121 &data->tx_message, data, 0, 0, 0); 122 if (err) 123 goto out1; 124 125 return 0; 126 out1: 127 dev_err(data->bmc_device, "request_settime=%x\n", err); 128 return err; 129 out: 130 dev_err(data->bmc_device, "validate_addr=%x\n", err); 131 return err; 132 } 133 134 static int ibmpex_ver_check(struct ibmpex_bmc_data *data) 135 { 136 data->tx_msg_data[0] = PEX_GET_VERSION; 137 data->tx_message.data_len = 1; 138 ibmpex_send_message(data); 139 140 wait_for_completion(&data->read_complete); 141 142 if (data->rx_result || data->rx_msg_len != 6) 143 return -ENOENT; 144 145 data->sensor_major = data->rx_msg_data[0]; 146 data->sensor_minor = data->rx_msg_data[1]; 147 148 dev_info(data->bmc_device, 149 "Found BMC with sensor interface v%d.%d %d-%02d-%02d on interface %d\n", 150 data->sensor_major, 151 data->sensor_minor, 152 extract_value(data->rx_msg_data, 2), 153 data->rx_msg_data[4], 154 data->rx_msg_data[5], 155 data->interface); 156 157 return 0; 158 } 159 160 static int ibmpex_query_sensor_count(struct ibmpex_bmc_data *data) 161 { 162 data->tx_msg_data[0] = PEX_GET_SENSOR_COUNT; 163 data->tx_message.data_len = 1; 164 ibmpex_send_message(data); 165 166 wait_for_completion(&data->read_complete); 167 168 if (data->rx_result || data->rx_msg_len != 1) 169 return -ENOENT; 170 171 return data->rx_msg_data[0]; 172 } 173 174 static int ibmpex_query_sensor_name(struct ibmpex_bmc_data *data, int sensor) 175 { 176 data->tx_msg_data[0] = PEX_GET_SENSOR_NAME; 177 data->tx_msg_data[1] = sensor; 178 data->tx_message.data_len = 2; 179 ibmpex_send_message(data); 180 181 wait_for_completion(&data->read_complete); 182 183 if (data->rx_result || data->rx_msg_len < 1) 184 return -ENOENT; 185 186 return 0; 187 } 188 189 static int ibmpex_query_sensor_data(struct ibmpex_bmc_data *data, int sensor) 190 { 191 data->tx_msg_data[0] = PEX_GET_SENSOR_DATA; 192 data->tx_msg_data[1] = sensor; 193 data->tx_message.data_len = 2; 194 ibmpex_send_message(data); 195 196 wait_for_completion(&data->read_complete); 197 198 if (data->rx_result || data->rx_msg_len < 26) { 199 dev_err(data->bmc_device, "Error reading sensor %d.\n", 200 sensor); 201 return -ENOENT; 202 } 203 204 return 0; 205 } 206 207 static int ibmpex_reset_high_low_data(struct ibmpex_bmc_data *data) 208 { 209 data->tx_msg_data[0] = PEX_RESET_HIGH_LOW; 210 data->tx_message.data_len = 1; 211 ibmpex_send_message(data); 212 213 wait_for_completion(&data->read_complete); 214 215 return 0; 216 } 217 218 static void ibmpex_update_device(struct ibmpex_bmc_data *data) 219 { 220 int i, err; 221 222 mutex_lock(&data->lock); 223 if (time_before(jiffies, data->last_updated + REFRESH_INTERVAL) && 224 data->valid) 225 goto out; 226 227 for (i = 0; i < data->num_sensors; i++) { 228 if (!data->sensors[i].in_use) 229 continue; 230 err = ibmpex_query_sensor_data(data, i); 231 if (err) 232 continue; 233 data->sensors[i].values[0] = 234 extract_value(data->rx_msg_data, 16); 235 data->sensors[i].values[1] = 236 extract_value(data->rx_msg_data, 18); 237 data->sensors[i].values[2] = 238 extract_value(data->rx_msg_data, 20); 239 } 240 241 data->last_updated = jiffies; 242 data->valid = true; 243 244 out: 245 mutex_unlock(&data->lock); 246 } 247 248 static struct ibmpex_bmc_data *get_bmc_data(int iface) 249 { 250 struct ibmpex_bmc_data *p, *next; 251 252 list_for_each_entry_safe(p, next, &driver_data.bmc_data, list) 253 if (p->interface == iface) 254 return p; 255 256 return NULL; 257 } 258 259 static DEVICE_STRING_ATTR_RO(name, 0444, DRVNAME); 260 261 static ssize_t ibmpex_show_sensor(struct device *dev, 262 struct device_attribute *devattr, 263 char *buf) 264 { 265 struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(devattr); 266 struct ibmpex_bmc_data *data = dev_get_drvdata(dev); 267 int mult = data->sensors[attr->index].multiplier; 268 ibmpex_update_device(data); 269 270 return sprintf(buf, "%d\n", 271 data->sensors[attr->index].values[attr->nr] * mult); 272 } 273 274 static ssize_t ibmpex_high_low_store(struct device *dev, 275 struct device_attribute *devattr, 276 const char *buf, size_t count) 277 { 278 struct ibmpex_bmc_data *data = dev_get_drvdata(dev); 279 280 if (!data) 281 return -ENODEV; 282 283 ibmpex_reset_high_low_data(data); 284 285 return count; 286 } 287 288 static SENSOR_DEVICE_ATTR_WO(reset_high_low, ibmpex_high_low, 0); 289 290 static int is_power_sensor(const char *sensor_id, int len) 291 { 292 if (len < PEX_SENSOR_TYPE_LEN) 293 return 0; 294 295 if (!memcmp(sensor_id, power_sensor_sig, PEX_SENSOR_TYPE_LEN)) 296 return 1; 297 return 0; 298 } 299 300 static int is_temp_sensor(const char *sensor_id, int len) 301 { 302 if (len < PEX_SENSOR_TYPE_LEN) 303 return 0; 304 305 if (!memcmp(sensor_id, temp_sensor_sig, PEX_SENSOR_TYPE_LEN)) 306 return 1; 307 return 0; 308 } 309 310 static int power_sensor_multiplier(struct ibmpex_bmc_data *data, 311 const char *sensor_id, int len) 312 { 313 int i; 314 315 if (data->sensor_major == 2) 316 return 1000000; 317 318 for (i = PEX_SENSOR_TYPE_LEN; i < len - 1; i++) 319 if (!memcmp(&sensor_id[i], watt_sensor_sig, PEX_MULT_LEN)) 320 return 1000000; 321 322 return 100000; 323 } 324 325 static int create_sensor(struct ibmpex_bmc_data *data, int type, 326 int counter, int sensor, int func) 327 { 328 int err; 329 char *n; 330 331 n = kmalloc(32, GFP_KERNEL); 332 if (!n) 333 return -ENOMEM; 334 335 if (type == TEMP_SENSOR) 336 sprintf(n, "temp%d_input%s", 337 counter, sensor_name_suffixes[func]); 338 else if (type == POWER_SENSOR) 339 sprintf(n, "power%d_average%s", 340 counter, sensor_name_suffixes[func]); 341 342 sysfs_attr_init(&data->sensors[sensor].attr[func].dev_attr.attr); 343 data->sensors[sensor].attr[func].dev_attr.attr.name = n; 344 data->sensors[sensor].attr[func].dev_attr.attr.mode = 0444; 345 data->sensors[sensor].attr[func].dev_attr.show = ibmpex_show_sensor; 346 data->sensors[sensor].attr[func].index = sensor; 347 data->sensors[sensor].attr[func].nr = func; 348 349 err = device_create_file(data->bmc_device, 350 &data->sensors[sensor].attr[func].dev_attr); 351 if (err) { 352 data->sensors[sensor].attr[func].dev_attr.attr.name = NULL; 353 kfree(n); 354 return err; 355 } 356 357 return 0; 358 } 359 360 static int ibmpex_find_sensors(struct ibmpex_bmc_data *data) 361 { 362 int i, j, err; 363 int sensor_type; 364 int sensor_counter; 365 int num_power = 0; 366 int num_temp = 0; 367 368 err = ibmpex_query_sensor_count(data); 369 if (err <= 0) 370 return -ENOENT; 371 data->num_sensors = err; 372 373 data->sensors = kcalloc(data->num_sensors, sizeof(*data->sensors), 374 GFP_KERNEL); 375 if (!data->sensors) 376 return -ENOMEM; 377 378 for (i = 0; i < data->num_sensors; i++) { 379 err = ibmpex_query_sensor_name(data, i); 380 if (err) 381 continue; 382 383 if (is_power_sensor(data->rx_msg_data, data->rx_msg_len)) { 384 sensor_type = POWER_SENSOR; 385 num_power++; 386 sensor_counter = num_power; 387 data->sensors[i].multiplier = 388 power_sensor_multiplier(data, 389 data->rx_msg_data, 390 data->rx_msg_len); 391 } else if (is_temp_sensor(data->rx_msg_data, 392 data->rx_msg_len)) { 393 sensor_type = TEMP_SENSOR; 394 num_temp++; 395 sensor_counter = num_temp; 396 data->sensors[i].multiplier = 1000; 397 } else 398 continue; 399 400 data->sensors[i].in_use = 1; 401 402 /* Create attributes */ 403 for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) { 404 err = create_sensor(data, sensor_type, sensor_counter, 405 i, j); 406 if (err) 407 goto exit_remove; 408 } 409 } 410 411 err = device_create_file(data->bmc_device, 412 &sensor_dev_attr_reset_high_low.dev_attr); 413 if (err) 414 goto exit_remove; 415 416 err = device_create_file(data->bmc_device, &dev_attr_name.attr); 417 if (err) 418 goto exit_remove; 419 420 return 0; 421 422 exit_remove: 423 device_remove_file(data->bmc_device, 424 &sensor_dev_attr_reset_high_low.dev_attr); 425 device_remove_file(data->bmc_device, &dev_attr_name.attr); 426 for (i = 0; i < data->num_sensors; i++) 427 for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) { 428 if (!data->sensors[i].attr[j].dev_attr.attr.name) 429 continue; 430 device_remove_file(data->bmc_device, 431 &data->sensors[i].attr[j].dev_attr); 432 kfree(data->sensors[i].attr[j].dev_attr.attr.name); 433 } 434 435 kfree(data->sensors); 436 return err; 437 } 438 439 static void ibmpex_register_bmc(int iface, struct device *dev) 440 { 441 struct ibmpex_bmc_data *data; 442 int err; 443 444 data = kzalloc(sizeof(*data), GFP_KERNEL); 445 if (!data) 446 return; 447 448 data->address.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 449 data->address.channel = IPMI_BMC_CHANNEL; 450 data->address.data[0] = 0; 451 data->interface = iface; 452 data->bmc_device = dev; 453 454 /* Create IPMI messaging interface user */ 455 err = ipmi_create_user(data->interface, &driver_data.ipmi_hndlrs, 456 data, &data->user); 457 if (err < 0) { 458 dev_err(dev, 459 "Unable to register user with IPMI interface %d\n", 460 data->interface); 461 goto out; 462 } 463 464 mutex_init(&data->lock); 465 466 /* Initialize message */ 467 data->tx_msgid = 0; 468 init_completion(&data->read_complete); 469 data->tx_message.netfn = PEX_NET_FUNCTION; 470 data->tx_message.cmd = PEX_COMMAND; 471 data->tx_message.data = data->tx_msg_data; 472 473 /* Does this BMC support PowerExecutive? */ 474 err = ibmpex_ver_check(data); 475 if (err) 476 goto out_user; 477 478 /* Register the BMC as a HWMON class device */ 479 data->hwmon_dev = hwmon_device_register(data->bmc_device); 480 481 if (IS_ERR(data->hwmon_dev)) { 482 dev_err(data->bmc_device, 483 "Unable to register hwmon device for IPMI interface %d\n", 484 data->interface); 485 goto out_user; 486 } 487 488 /* finally add the new bmc data to the bmc data list */ 489 dev_set_drvdata(dev, data); 490 list_add_tail(&data->list, &driver_data.bmc_data); 491 492 /* Now go find all the sensors */ 493 err = ibmpex_find_sensors(data); 494 if (err) { 495 dev_err(data->bmc_device, "Error %d finding sensors\n", err); 496 goto out_register; 497 } 498 499 return; 500 501 out_register: 502 list_del(&data->list); 503 hwmon_device_unregister(data->hwmon_dev); 504 out_user: 505 ipmi_destroy_user(data->user); 506 out: 507 kfree(data); 508 } 509 510 static void ibmpex_bmc_delete(struct ibmpex_bmc_data *data) 511 { 512 int i, j; 513 514 hwmon_device_unregister(data->hwmon_dev); 515 dev_set_drvdata(data->bmc_device, NULL); 516 517 device_remove_file(data->bmc_device, 518 &sensor_dev_attr_reset_high_low.dev_attr); 519 device_remove_file(data->bmc_device, &dev_attr_name.attr); 520 for (i = 0; i < data->num_sensors; i++) 521 for (j = 0; j < PEX_NUM_SENSOR_FUNCS; j++) { 522 if (!data->sensors[i].attr[j].dev_attr.attr.name) 523 continue; 524 device_remove_file(data->bmc_device, 525 &data->sensors[i].attr[j].dev_attr); 526 kfree(data->sensors[i].attr[j].dev_attr.attr.name); 527 } 528 529 list_del(&data->list); 530 531 ipmi_destroy_user(data->user); 532 kfree(data->sensors); 533 kfree(data); 534 } 535 536 static void ibmpex_bmc_gone(int iface) 537 { 538 struct ibmpex_bmc_data *data = get_bmc_data(iface); 539 540 if (!data) 541 return; 542 543 ibmpex_bmc_delete(data); 544 } 545 546 static void ibmpex_msg_handler(struct ipmi_recv_msg *msg, void *user_msg_data) 547 { 548 struct ibmpex_bmc_data *data = user_msg_data; 549 550 if (msg->msgid != data->tx_msgid) { 551 dev_err(data->bmc_device, 552 "Mismatch between received msgid (%02x) and transmitted msgid (%02x)!\n", 553 (int)msg->msgid, 554 (int)data->tx_msgid); 555 ipmi_free_recv_msg(msg); 556 return; 557 } 558 559 data->rx_recv_type = msg->recv_type; 560 if (msg->msg.data_len > 0) 561 data->rx_result = msg->msg.data[0]; 562 else 563 data->rx_result = IPMI_UNKNOWN_ERR_COMPLETION_CODE; 564 565 if (msg->msg.data_len > 1) { 566 data->rx_msg_len = msg->msg.data_len - 1; 567 memcpy(data->rx_msg_data, msg->msg.data + 1, data->rx_msg_len); 568 } else 569 data->rx_msg_len = 0; 570 571 ipmi_free_recv_msg(msg); 572 complete(&data->read_complete); 573 } 574 575 static int __init ibmpex_init(void) 576 { 577 return ipmi_smi_watcher_register(&driver_data.bmc_events); 578 } 579 580 static void __exit ibmpex_exit(void) 581 { 582 struct ibmpex_bmc_data *p, *next; 583 584 ipmi_smi_watcher_unregister(&driver_data.bmc_events); 585 list_for_each_entry_safe(p, next, &driver_data.bmc_data, list) 586 ibmpex_bmc_delete(p); 587 } 588 589 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>"); 590 MODULE_DESCRIPTION("IBM PowerExecutive power/temperature sensor driver"); 591 MODULE_LICENSE("GPL"); 592 593 module_init(ibmpex_init); 594 module_exit(ibmpex_exit); 595 596 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*"); 597 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*"); 598 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*"); 599 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*"); 600 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*"); 601