1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <libipmi.h> 28 #include <stddef.h> 29 #include <string.h> 30 #include <strings.h> 31 #include <math.h> 32 33 #include "ipmi_impl.h" 34 35 /* 36 * This macros are used by ipmi_sdr_conv_reading. They were taken verbatim from 37 * the source for ipmitool (v1.88) 38 */ 39 #define tos32(val, bits) ((val & ((1<<((bits)-1)))) ? (-((val) & \ 40 (1<<((bits)-1))) | (val)) : (val)) 41 42 #define __TO_TOL(mtol) (uint16_t)(BSWAP_16(mtol) & 0x3f) 43 44 #define __TO_M(mtol) (int16_t)(tos32((((BSWAP_16(mtol) & 0xff00) >> 8) | \ 45 ((BSWAP_16(mtol) & 0xc0) << 2)), 10)) 46 47 #define __TO_B(bacc) (int32_t)(tos32((((BSWAP_32(bacc) & \ 48 0xff000000) >> 24) | \ 49 ((BSWAP_32(bacc) & 0xc00000) >> 14)), 10)) 50 51 #define __TO_ACC(bacc) (uint32_t)(((BSWAP_32(bacc) & 0x3f0000) >> 16) | \ 52 ((BSWAP_32(bacc) & 0xf000) >> 6)) 53 54 #define __TO_ACC_EXP(bacc) (uint32_t)((BSWAP_32(bacc) & 0xc00) >> 10) 55 #define __TO_R_EXP(bacc) (int32_t)(tos32(((BSWAP_32(bacc) & 0xf0) >> 4),\ 56 4)) 57 #define __TO_B_EXP(bacc) (int32_t)(tos32((BSWAP_32(bacc) & 0xf), 4)) 58 59 #define SDR_SENSOR_L_LINEAR 0x00 60 #define SDR_SENSOR_L_LN 0x01 61 #define SDR_SENSOR_L_LOG10 0x02 62 #define SDR_SENSOR_L_LOG2 0x03 63 #define SDR_SENSOR_L_E 0x04 64 #define SDR_SENSOR_L_EXP10 0x05 65 #define SDR_SENSOR_L_EXP2 0x06 66 #define SDR_SENSOR_L_1_X 0x07 67 #define SDR_SENSOR_L_SQR 0x08 68 #define SDR_SENSOR_L_CUBE 0x09 69 #define SDR_SENSOR_L_SQRT 0x0a 70 #define SDR_SENSOR_L_CUBERT 0x0b 71 #define SDR_SENSOR_L_NONLINEAR 0x70 72 73 /* 74 * Analog sensor reading data formats 75 * 76 * See Section 43.1 77 */ 78 #define IPMI_DATA_FMT_UNSIGNED 0 79 #define IPMI_DATA_FMT_ONESCOMP 1 80 #define IPMI_DATA_FMT_TWOSCOMP 2 81 82 #define IPMI_SDR_HDR_SZ offsetof(ipmi_sdr_t, is_record) 83 84 typedef struct ipmi_sdr_cache_ent { 85 char *isc_name; 86 struct ipmi_sdr *isc_sdr; 87 ipmi_hash_link_t isc_link; 88 } ipmi_sdr_cache_ent_t; 89 90 typedef struct ipmi_cmd_get_sdr { 91 uint16_t ic_gs_resid; 92 uint16_t ic_gs_recid; 93 uint8_t ic_gs_offset; 94 uint8_t ic_gs_len; 95 } ipmi_cmd_get_sdr_t; 96 97 typedef struct ipmi_rsp_get_sdr { 98 uint16_t ir_gs_next; 99 uint8_t ir_gs_record[1]; 100 } ipmi_rsp_get_sdr_t; 101 102 /* 103 * "Get SDR Repostiory Info" command. 104 */ 105 ipmi_sdr_info_t * 106 ipmi_sdr_get_info(ipmi_handle_t *ihp) 107 { 108 ipmi_cmd_t cmd, *rsp; 109 ipmi_sdr_info_t *sip; 110 uint16_t tmp16; 111 uint32_t tmp32; 112 113 cmd.ic_netfn = IPMI_NETFN_STORAGE; 114 cmd.ic_lun = 0; 115 cmd.ic_cmd = IPMI_CMD_GET_SDR_INFO; 116 cmd.ic_dlen = 0; 117 cmd.ic_data = NULL; 118 119 if ((rsp = ipmi_send(ihp, &cmd)) == NULL) 120 return (NULL); 121 122 sip = rsp->ic_data; 123 124 tmp16 = LE_IN16(&sip->isi_record_count); 125 (void) memcpy(&sip->isi_record_count, &tmp16, sizeof (tmp16)); 126 127 tmp16 = LE_IN16(&sip->isi_free_space); 128 (void) memcpy(&sip->isi_free_space, &tmp16, sizeof (tmp16)); 129 130 tmp32 = LE_IN32(&sip->isi_add_ts); 131 (void) memcpy(&sip->isi_add_ts, &tmp32, sizeof (tmp32)); 132 133 tmp32 = LE_IN32(&sip->isi_erase_ts); 134 (void) memcpy(&sip->isi_erase_ts, &tmp32, sizeof (tmp32)); 135 136 return (sip); 137 } 138 139 /* 140 * Issue the "Reserve SDR Repository" command. 141 */ 142 static int 143 ipmi_sdr_reserve_repository(ipmi_handle_t *ihp) 144 { 145 ipmi_cmd_t cmd, *rsp; 146 147 cmd.ic_netfn = IPMI_NETFN_STORAGE; 148 cmd.ic_lun = 0; 149 cmd.ic_cmd = IPMI_CMD_RESERVE_SDR_REPOSITORY; 150 cmd.ic_dlen = 0; 151 cmd.ic_data = NULL; 152 153 if ((rsp = ipmi_send(ihp, &cmd)) == NULL) 154 return (-1); 155 156 ihp->ih_reservation = *((uint16_t *)rsp->ic_data); 157 return (0); 158 } 159 160 /* 161 * Returns B_TRUE if the repository has changed since the cached copy was last 162 * referenced. 163 */ 164 boolean_t 165 ipmi_sdr_changed(ipmi_handle_t *ihp) 166 { 167 ipmi_sdr_info_t *sip; 168 169 if ((sip = ipmi_sdr_get_info(ihp)) == NULL) 170 return (B_TRUE); 171 172 return (sip->isi_add_ts > ihp->ih_sdr_ts || 173 sip->isi_erase_ts > ihp->ih_sdr_ts || 174 ipmi_hash_first(ihp->ih_sdr_cache) == NULL); 175 } 176 177 /* 178 * Refresh the cache of sensor data records. 179 */ 180 int 181 ipmi_sdr_refresh(ipmi_handle_t *ihp) 182 { 183 uint16_t id; 184 ipmi_sdr_t *sdr; 185 ipmi_sdr_cache_ent_t *ent; 186 size_t namelen; 187 uint8_t type; 188 char *name; 189 ipmi_sdr_info_t *sip; 190 uint32_t isi_add_ts, isi_erase_ts; 191 192 if ((sip = ipmi_sdr_get_info(ihp)) == NULL) 193 return (-1); 194 195 (void) memcpy(&isi_add_ts, &sip->isi_add_ts, sizeof (uint32_t)); 196 (void) memcpy(&isi_erase_ts, &sip->isi_erase_ts, sizeof (uint32_t)); 197 if (isi_add_ts <= ihp->ih_sdr_ts && 198 isi_erase_ts <= ihp->ih_sdr_ts && 199 ipmi_hash_first(ihp->ih_sdr_cache) != NULL) 200 return (0); 201 202 ipmi_sdr_clear(ihp); 203 ipmi_entity_clear(ihp); 204 ihp->ih_sdr_ts = MAX(isi_add_ts, isi_erase_ts); 205 206 /* 207 * Iterate over all existing SDRs and add them to the cache. 208 */ 209 id = IPMI_SDR_FIRST; 210 while (id != IPMI_SDR_LAST) { 211 if ((sdr = ipmi_sdr_get(ihp, id, &id)) == NULL) 212 goto error; 213 214 /* 215 * Extract the name from the record-specific data. 216 */ 217 switch (sdr->is_type) { 218 case IPMI_SDR_TYPE_GENERIC_LOCATOR: 219 { 220 ipmi_sdr_generic_locator_t *glp = 221 (ipmi_sdr_generic_locator_t *) 222 sdr->is_record; 223 namelen = glp->is_gl_idlen; 224 type = glp->is_gl_idtype; 225 name = glp->is_gl_idstring; 226 break; 227 } 228 229 case IPMI_SDR_TYPE_FRU_LOCATOR: 230 { 231 ipmi_sdr_fru_locator_t *flp = 232 (ipmi_sdr_fru_locator_t *) 233 sdr->is_record; 234 namelen = flp->is_fl_idlen; 235 name = flp->is_fl_idstring; 236 type = flp->is_fl_idtype; 237 break; 238 } 239 240 case IPMI_SDR_TYPE_COMPACT_SENSOR: 241 { 242 ipmi_sdr_compact_sensor_t *csp = 243 (ipmi_sdr_compact_sensor_t *) 244 sdr->is_record; 245 uint16_t tmp; 246 247 namelen = csp->is_cs_idlen; 248 type = csp->is_cs_idtype; 249 name = csp->is_cs_idstring; 250 251 tmp = LE_IN16(&csp->is_cs_assert_mask); 252 (void) memcpy(&csp->is_cs_assert_mask, &tmp, 253 sizeof (tmp)); 254 255 tmp = LE_IN16(&csp->is_cs_deassert_mask); 256 (void) memcpy(&csp->is_cs_deassert_mask, &tmp, 257 sizeof (tmp)); 258 259 tmp = LE_IN16(&csp->is_cs_reading_mask); 260 (void) memcpy(&csp->is_cs_reading_mask, &tmp, 261 sizeof (tmp)); 262 break; 263 } 264 265 case IPMI_SDR_TYPE_FULL_SENSOR: 266 { 267 ipmi_sdr_full_sensor_t *fsp = 268 (ipmi_sdr_full_sensor_t *) 269 sdr->is_record; 270 uint16_t tmp; 271 272 namelen = fsp->is_fs_idlen; 273 type = fsp->is_fs_idtype; 274 name = fsp->is_fs_idstring; 275 276 tmp = LE_IN16(&fsp->is_fs_assert_mask); 277 (void) memcpy(&fsp->is_fs_assert_mask, &tmp, 278 sizeof (tmp)); 279 280 tmp = LE_IN16(&fsp->is_fs_deassert_mask); 281 (void) memcpy(&fsp->is_fs_deassert_mask, &tmp, 282 sizeof (tmp)); 283 284 tmp = LE_IN16(&fsp->is_fs_reading_mask); 285 (void) memcpy(&fsp->is_fs_reading_mask, &tmp, 286 sizeof (tmp)); 287 break; 288 } 289 290 case IPMI_SDR_TYPE_EVENT_ONLY: 291 { 292 ipmi_sdr_event_only_t *esp = 293 (ipmi_sdr_event_only_t *) 294 sdr->is_record; 295 namelen = esp->is_eo_idlen; 296 type = esp->is_eo_idtype; 297 name = esp->is_eo_idstring; 298 break; 299 } 300 301 case IPMI_SDR_TYPE_MANAGEMENT_LOCATOR: 302 { 303 ipmi_sdr_management_locator_t *msp = 304 (ipmi_sdr_management_locator_t *) 305 sdr->is_record; 306 namelen = msp->is_ml_idlen; 307 type = msp->is_ml_idtype; 308 name = msp->is_ml_idstring; 309 break; 310 } 311 312 case IPMI_SDR_TYPE_MANAGEMENT_CONFIRMATION: 313 { 314 ipmi_sdr_management_confirmation_t *mcp = 315 (ipmi_sdr_management_confirmation_t *) 316 sdr->is_record; 317 uint16_t tmp; 318 319 name = NULL; 320 tmp = LE_IN16(&mcp->is_mc_product); 321 (void) memcpy(&mcp->is_mc_product, &tmp, 322 sizeof (tmp)); 323 break; 324 } 325 326 default: 327 name = NULL; 328 } 329 330 if ((ent = ipmi_zalloc(ihp, 331 sizeof (ipmi_sdr_cache_ent_t))) == NULL) { 332 free(sdr); 333 goto error; 334 } 335 336 ent->isc_sdr = sdr; 337 338 if (name != NULL) { 339 if ((ent->isc_name = ipmi_alloc(ihp, namelen + 1)) == 340 NULL) { 341 ipmi_free(ihp, ent->isc_sdr); 342 ipmi_free(ihp, ent); 343 goto error; 344 } 345 346 ipmi_decode_string(type, namelen, name, ent->isc_name); 347 } 348 349 /* 350 * This should never happen. It means that the SP has returned 351 * a SDR record twice, with the same name and ID. This has 352 * been observed on service processors that don't correctly 353 * return SDR_LAST during iteration, so assume we've looped in 354 * the SDR and return gracefully. 355 */ 356 if (ipmi_hash_lookup(ihp->ih_sdr_cache, ent) != NULL) { 357 ipmi_free(ihp, ent->isc_sdr); 358 ipmi_free(ihp, ent->isc_name); 359 ipmi_free(ihp, ent); 360 break; 361 } 362 363 ipmi_hash_insert(ihp->ih_sdr_cache, ent); 364 } 365 366 return (0); 367 368 error: 369 ipmi_sdr_clear(ihp); 370 ipmi_entity_clear(ihp); 371 return (-1); 372 } 373 374 /* 375 * Hash routines. We allow lookup by name, but since not all entries have 376 * names, we fall back to the entry pointer, which is guaranteed to be unique. 377 * The end result is that entities without names cannot be looked up, but will 378 * show up during iteration. 379 */ 380 static const void * 381 ipmi_sdr_hash_convert(const void *p) 382 { 383 return (p); 384 } 385 386 static ulong_t 387 ipmi_sdr_hash_compute(const void *p) 388 { 389 const ipmi_sdr_cache_ent_t *ep = p; 390 391 if (ep->isc_name) 392 return (ipmi_hash_strhash(ep->isc_name)); 393 else 394 return (ipmi_hash_ptrhash(ep)); 395 } 396 397 static int 398 ipmi_sdr_hash_compare(const void *a, const void *b) 399 { 400 const ipmi_sdr_cache_ent_t *ap = a; 401 const ipmi_sdr_cache_ent_t *bp = b; 402 403 if (ap->isc_name == NULL || bp->isc_name == NULL) 404 return (-1); 405 406 if (strcmp(ap->isc_name, bp->isc_name) != 0) 407 return (-1); 408 409 /* 410 * While it is strange for a service processor to report multiple 411 * entries with the same name, we allow it by treating the (name, id) 412 * as the unique identifier. When looking up by name, the SDR pointer 413 * is NULL, and we return the first matching name. 414 */ 415 if (ap->isc_sdr == NULL || bp->isc_sdr == NULL) 416 return (0); 417 418 if (ap->isc_sdr->is_id == bp->isc_sdr->is_id) 419 return (0); 420 else 421 return (-1); 422 } 423 424 int 425 ipmi_sdr_init(ipmi_handle_t *ihp) 426 { 427 if ((ihp->ih_sdr_cache = ipmi_hash_create(ihp, 428 offsetof(ipmi_sdr_cache_ent_t, isc_link), 429 ipmi_sdr_hash_convert, ipmi_sdr_hash_compute, 430 ipmi_sdr_hash_compare)) == NULL) 431 return (-1); 432 433 return (0); 434 } 435 436 void 437 ipmi_sdr_clear(ipmi_handle_t *ihp) 438 { 439 ipmi_sdr_cache_ent_t *ent; 440 441 while ((ent = ipmi_hash_first(ihp->ih_sdr_cache)) != NULL) { 442 ipmi_hash_remove(ihp->ih_sdr_cache, ent); 443 ipmi_free(ihp, ent->isc_sdr); 444 ipmi_free(ihp, ent->isc_name); 445 ipmi_free(ihp, ent); 446 } 447 } 448 449 void 450 ipmi_sdr_fini(ipmi_handle_t *ihp) 451 { 452 if (ihp->ih_sdr_cache != NULL) { 453 ipmi_sdr_clear(ihp); 454 ipmi_hash_destroy(ihp->ih_sdr_cache); 455 } 456 } 457 458 ipmi_sdr_t * 459 ipmi_sdr_get(ipmi_handle_t *ihp, uint16_t id, uint16_t *next) 460 { 461 uint8_t offset = IPMI_SDR_HDR_SZ, count = 0, chunksz = 16, sdr_sz; 462 ipmi_cmd_t cmd, *rsp; 463 ipmi_cmd_get_sdr_t req; 464 ipmi_sdr_t *sdr; 465 int i = 0; 466 char *buf; 467 468 req.ic_gs_resid = ihp->ih_reservation; 469 req.ic_gs_recid = id; 470 471 cmd.ic_netfn = IPMI_NETFN_STORAGE; 472 cmd.ic_lun = 0; 473 cmd.ic_cmd = IPMI_CMD_GET_SDR; 474 cmd.ic_dlen = sizeof (req); 475 cmd.ic_data = &req; 476 477 /* 478 * The size of the SDR is contained in the 5th byte of the SDR header, 479 * so we'll read the first 5 bytes to get the size, so we know how big 480 * to make the buffer. 481 */ 482 req.ic_gs_offset = 0; 483 req.ic_gs_len = IPMI_SDR_HDR_SZ; 484 for (i = 0; i < ihp->ih_retries; i++) { 485 if ((rsp = ipmi_send(ihp, &cmd)) != NULL) 486 break; 487 488 if (ipmi_errno(ihp) != EIPMI_INVALID_RESERVATION) 489 return (NULL); 490 491 if (ipmi_sdr_reserve_repository(ihp) != 0) 492 return (NULL); 493 req.ic_gs_resid = ihp->ih_reservation; 494 } 495 if (rsp == NULL) 496 return (NULL); 497 498 sdr = (ipmi_sdr_t *)((ipmi_rsp_get_sdr_t *)rsp->ic_data)->ir_gs_record; 499 sdr_sz = sdr->is_length; 500 501 if ((buf = ipmi_zalloc(ihp, sdr_sz + IPMI_SDR_HDR_SZ)) == NULL) { 502 (void) ipmi_set_error(ihp, EIPMI_NOMEM, NULL); 503 return (NULL); 504 } 505 (void) memcpy(buf, (void *)sdr, IPMI_SDR_HDR_SZ); 506 507 /* 508 * Some SDRs can be bigger than the buffer sizes for a given bmc 509 * interface. Therefore we break up the process of reading in an entire 510 * SDR into multiple smaller reads. 511 */ 512 while (count < sdr_sz) { 513 req.ic_gs_offset = offset; 514 if (chunksz > (sdr_sz - count)) 515 chunksz = sdr_sz - count; 516 req.ic_gs_len = chunksz; 517 rsp = ipmi_send(ihp, &cmd); 518 519 if (rsp != NULL) { 520 count += chunksz; 521 sdr = (ipmi_sdr_t *) 522 ((ipmi_rsp_get_sdr_t *)rsp->ic_data)->ir_gs_record; 523 (void) memcpy(buf+offset, (void *)sdr, chunksz); 524 offset += chunksz; 525 i = 0; 526 } else if (ipmi_errno(ihp) == EIPMI_INVALID_RESERVATION) { 527 if (i >= ihp->ih_retries || 528 ipmi_sdr_reserve_repository(ihp) != 0) { 529 free(buf); 530 return (NULL); 531 } 532 req.ic_gs_resid = ihp->ih_reservation; 533 i++; 534 } else { 535 free(buf); 536 return (NULL); 537 } 538 } 539 *next = ((ipmi_rsp_get_sdr_t *)rsp->ic_data)->ir_gs_next; 540 541 return ((ipmi_sdr_t *)buf); 542 } 543 544 int 545 ipmi_sdr_iter(ipmi_handle_t *ihp, int (*func)(ipmi_handle_t *, 546 const char *, ipmi_sdr_t *, void *), void *data) 547 { 548 ipmi_sdr_cache_ent_t *ent; 549 int ret; 550 551 if (ipmi_hash_first(ihp->ih_sdr_cache) == NULL && 552 ipmi_sdr_refresh(ihp) != 0) 553 return (-1); 554 555 for (ent = ipmi_hash_first(ihp->ih_sdr_cache); ent != NULL; 556 ent = ipmi_hash_next(ihp->ih_sdr_cache, ent)) { 557 if ((ret = func(ihp, ent->isc_name, ent->isc_sdr, data)) != 0) 558 return (ret); 559 } 560 561 return (0); 562 } 563 564 ipmi_sdr_t * 565 ipmi_sdr_lookup(ipmi_handle_t *ihp, const char *idstr) 566 { 567 ipmi_sdr_cache_ent_t *ent, search; 568 569 if (ipmi_hash_first(ihp->ih_sdr_cache) == NULL && 570 ipmi_sdr_refresh(ihp) != 0) 571 return (NULL); 572 573 search.isc_name = (char *)idstr; 574 search.isc_sdr = NULL; 575 if ((ent = ipmi_hash_lookup(ihp->ih_sdr_cache, &search)) == NULL) { 576 (void) ipmi_set_error(ihp, EIPMI_NOT_PRESENT, NULL); 577 return (NULL); 578 } 579 580 return (ent->isc_sdr); 581 } 582 583 static void * 584 ipmi_sdr_lookup_common(ipmi_handle_t *ihp, const char *idstr, 585 uint8_t type) 586 { 587 ipmi_sdr_t *sdrp; 588 589 if ((sdrp = ipmi_sdr_lookup(ihp, idstr)) == NULL) 590 return (NULL); 591 592 if (sdrp->is_type != type) { 593 (void) ipmi_set_error(ihp, EIPMI_NOT_PRESENT, NULL); 594 return (NULL); 595 } 596 597 return (sdrp->is_record); 598 } 599 600 ipmi_sdr_fru_locator_t * 601 ipmi_sdr_lookup_fru(ipmi_handle_t *ihp, const char *idstr) 602 { 603 return (ipmi_sdr_lookup_common(ihp, idstr, 604 IPMI_SDR_TYPE_FRU_LOCATOR)); 605 } 606 607 ipmi_sdr_generic_locator_t * 608 ipmi_sdr_lookup_generic(ipmi_handle_t *ihp, const char *idstr) 609 { 610 return (ipmi_sdr_lookup_common(ihp, idstr, 611 IPMI_SDR_TYPE_GENERIC_LOCATOR)); 612 } 613 614 ipmi_sdr_compact_sensor_t * 615 ipmi_sdr_lookup_compact_sensor(ipmi_handle_t *ihp, const char *idstr) 616 { 617 return (ipmi_sdr_lookup_common(ihp, idstr, 618 IPMI_SDR_TYPE_COMPACT_SENSOR)); 619 } 620 621 ipmi_sdr_full_sensor_t * 622 ipmi_sdr_lookup_full_sensor(ipmi_handle_t *ihp, const char *idstr) 623 { 624 return (ipmi_sdr_lookup_common(ihp, idstr, 625 IPMI_SDR_TYPE_FULL_SENSOR)); 626 } 627 628 /* 629 * Mostly taken from ipmitool source v1.88 630 * 631 * This function converts the raw sensor reading returned by 632 * ipmi_get_sensor_reading to a unit-based value of type double. 633 */ 634 int 635 ipmi_sdr_conv_reading(ipmi_sdr_full_sensor_t *sensor, uint8_t val, 636 double *result) 637 { 638 int m, b, k1, k2; 639 640 m = __TO_M(sensor->is_fs_mtol); 641 b = __TO_B(sensor->is_fs_bacc); 642 k1 = __TO_B_EXP(sensor->is_fs_bacc); 643 k2 = __TO_R_EXP(sensor->is_fs_bacc); 644 645 switch (sensor->is_fs_analog_fmt) { 646 case IPMI_DATA_FMT_UNSIGNED: 647 *result = (double)(((m * val) + 648 (b * pow(10, k1))) * pow(10, k2)); 649 break; 650 case IPMI_DATA_FMT_ONESCOMP: 651 if (val & 0x80) 652 val++; 653 /* FALLTHRU */ 654 case IPMI_DATA_FMT_TWOSCOMP: 655 *result = (double)(((m * (int8_t)val) + 656 (b * pow(10, k1))) * pow(10, k2)); 657 break; 658 default: 659 /* This sensor does not return a numeric reading */ 660 return (-1); 661 } 662 663 switch (sensor->is_fs_sensor_linear_type) { 664 case SDR_SENSOR_L_LN: 665 *result = log(*result); 666 break; 667 case SDR_SENSOR_L_LOG10: 668 *result = log10(*result); 669 break; 670 case SDR_SENSOR_L_LOG2: 671 *result = (double)(log(*result) / log(2.0)); 672 break; 673 case SDR_SENSOR_L_E: 674 *result = exp(*result); 675 break; 676 case SDR_SENSOR_L_EXP10: 677 *result = pow(10.0, *result); 678 break; 679 case SDR_SENSOR_L_EXP2: 680 *result = pow(2.0, *result); 681 break; 682 case SDR_SENSOR_L_1_X: 683 *result = pow(*result, -1.0); /* 1/x w/o exception */ 684 break; 685 case SDR_SENSOR_L_SQR: 686 *result = pow(*result, 2.0); 687 break; 688 case SDR_SENSOR_L_CUBE: 689 *result = pow(*result, 3.0); 690 break; 691 case SDR_SENSOR_L_SQRT: 692 *result = sqrt(*result); 693 break; 694 case SDR_SENSOR_L_CUBERT: 695 *result = cbrt(*result); 696 break; 697 case SDR_SENSOR_L_LINEAR: 698 default: 699 break; 700 } 701 return (0); 702 } 703