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