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