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