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