1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Kunit tests for IIO rescale conversions 4 * 5 * Copyright (c) 2021 Liam Beguin <liambeguin@gmail.com> 6 */ 7 8 #include <linux/gcd.h> 9 #include <linux/overflow.h> 10 11 #include <linux/iio/afe/rescale.h> 12 #include <linux/iio/iio.h> 13 14 #include <kunit/test.h> 15 16 struct rescale_tc_data { 17 const char *name; 18 19 const s32 numerator; 20 const s32 denominator; 21 const s32 offset; 22 23 const int schan_val; 24 const int schan_val2; 25 const int schan_off; 26 const int schan_scale_type; 27 28 const char *expected; 29 const char *expected_off; 30 }; 31 32 const struct rescale_tc_data scale_cases[] = { 33 /* 34 * Typical use cases 35 */ 36 { 37 .name = "typical IIO_VAL_INT, positive", 38 .numerator = 1000000, 39 .denominator = 8060, 40 .schan_scale_type = IIO_VAL_INT, 41 .schan_val = 42, 42 .expected = "5210.918114143", 43 }, 44 { 45 .name = "typical IIO_VAL_INT, negative", 46 .numerator = -1000000, 47 .denominator = 8060, 48 .schan_scale_type = IIO_VAL_INT, 49 .schan_val = 42, 50 .expected = "-5210.918114143", 51 }, 52 { 53 .name = "typical IIO_VAL_FRACTIONAL, positive", 54 .numerator = 1000000, 55 .denominator = 8060, 56 .schan_scale_type = IIO_VAL_FRACTIONAL, 57 .schan_val = 42, 58 .schan_val2 = 20, 59 .expected = "260.545905707", 60 }, 61 { 62 .name = "typical IIO_VAL_FRACTIONAL, negative", 63 .numerator = -1000000, 64 .denominator = 8060, 65 .schan_scale_type = IIO_VAL_FRACTIONAL, 66 .schan_val = 42, 67 .schan_val2 = 20, 68 .expected = "-260.545905707", 69 }, 70 { 71 .name = "typical IIO_VAL_FRACTIONAL_LOG2, positive", 72 .numerator = 42, 73 .denominator = 53, 74 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 75 .schan_val = 4096, 76 .schan_val2 = 16, 77 .expected = "0.049528301", 78 }, 79 { 80 .name = "typical IIO_VAL_FRACTIONAL_LOG2, negative", 81 .numerator = -42, 82 .denominator = 53, 83 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 84 .schan_val = 4096, 85 .schan_val2 = 16, 86 .expected = "-0.049528301", 87 }, 88 { 89 .name = "typical IIO_VAL_INT_PLUS_NANO, positive", 90 .numerator = 1000000, 91 .denominator = 8060, 92 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 93 .schan_val = 10, 94 .schan_val2 = 123456, 95 .expected = "1240.710106203", 96 }, 97 { 98 .name = "typical IIO_VAL_INT_PLUS_NANO, negative", 99 .numerator = -1000000, 100 .denominator = 8060, 101 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 102 .schan_val = 10, 103 .schan_val2 = 123456, 104 .expected = "-1240.710106203", 105 }, 106 { 107 .name = "typical IIO_VAL_INT_PLUS_MICRO, positive", 108 .numerator = 1000000, 109 .denominator = 8060, 110 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 111 .schan_val = 10, 112 .schan_val2 = 1234, 113 .expected = "1240.84789", 114 }, 115 { 116 .name = "typical IIO_VAL_INT_PLUS_MICRO, negative", 117 .numerator = -1000000, 118 .denominator = 8060, 119 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 120 .schan_val = 10, 121 .schan_val2 = 1234, 122 .expected = "-1240.84789", 123 }, 124 /* 125 * Use cases with small scales involving divisions 126 */ 127 { 128 .name = "small IIO_VAL_FRACTIONAL, 261/509 scaled by 90/1373754273", 129 .numerator = 261, 130 .denominator = 509, 131 .schan_scale_type = IIO_VAL_FRACTIONAL, 132 .schan_val = 90, 133 .schan_val2 = 1373754273, 134 .expected = "0.000000033594", 135 }, 136 { 137 .name = "small IIO_VAL_FRACTIONAL, 90/1373754273 scaled by 261/509", 138 .numerator = 90, 139 .denominator = 1373754273, 140 .schan_scale_type = IIO_VAL_FRACTIONAL, 141 .schan_val = 261, 142 .schan_val2 = 509, 143 .expected = "0.000000033594", 144 }, 145 { 146 .name = "small IIO_VAL_FRACTIONAL, 760/1373754273 scaled by 427/2727", 147 .numerator = 760, 148 .denominator = 1373754273, 149 .schan_scale_type = IIO_VAL_FRACTIONAL, 150 .schan_val = 427, 151 .schan_val2 = 2727, 152 .expected = "0.000000086626", 153 }, 154 { 155 .name = "small IIO_VAL_FRACTIONAL, 761/1373754273 scaled by 427/2727", 156 .numerator = 761, 157 .denominator = 1373754273, 158 .schan_scale_type = IIO_VAL_FRACTIONAL, 159 .schan_val = 427, 160 .schan_val2 = 2727, 161 .expected = "0.000000086740", 162 }, 163 { 164 .name = "small IIO_VAL_FRACTIONAL, 5/32768 scaled by 3/10000", 165 .numerator = 5, 166 .denominator = 32768, 167 .schan_scale_type = IIO_VAL_FRACTIONAL, 168 .schan_val = 3, 169 .schan_val2 = 10000, 170 .expected = "0.0000000457763671875", 171 }, 172 { 173 .name = "small IIO_VAL_FRACTIONAL, 0 < scale < 1", 174 .numerator = 6, 175 .denominator = 6, 176 .schan_scale_type = IIO_VAL_FRACTIONAL, 177 .schan_val = 1, 178 .schan_val2 = 3, 179 .expected = "0.3333333333333333", 180 }, 181 { 182 .name = "small IIO_VAL_FRACTIONAL, -1 < scale < 0", 183 .numerator = -6, 184 .denominator = 6, 185 .schan_scale_type = IIO_VAL_FRACTIONAL, 186 .schan_val = 1, 187 .schan_val2 = 3, 188 .expected = "-0.3333333333333333", 189 }, 190 { 191 .name = "small IIO_VAL_FRACTIONAL, 0 < scale < 2", 192 .numerator = 8, 193 .denominator = 2, 194 .schan_scale_type = IIO_VAL_FRACTIONAL, 195 .schan_val = 1, 196 .schan_val2 = 3, 197 .expected = "1.3333333333333333", 198 }, 199 { 200 .name = "small IIO_VAL_FRACTIONAL, -2 < scale < 0", 201 .numerator = -8, 202 .denominator = 2, 203 .schan_scale_type = IIO_VAL_FRACTIONAL, 204 .schan_val = 1, 205 .schan_val2 = 3, 206 .expected = "-1.3333333333333333", 207 }, 208 { 209 .name = "small IIO_VAL_FRACTIONAL_LOG2, 760/32768 scaled by 15/22", 210 .numerator = 760, 211 .denominator = 32768, 212 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 213 .schan_val = 15, 214 .schan_val2 = 22, 215 .expected = "0.000000082946", 216 }, 217 { 218 .name = "small IIO_VAL_FRACTIONAL_LOG2, 761/32768 scaled by 15/22", 219 .numerator = 761, 220 .denominator = 32768, 221 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 222 .schan_val = 15, 223 .schan_val2 = 22, 224 .expected = "0.000000083055", 225 }, 226 { 227 .name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 1", 228 .numerator = 16, 229 .denominator = 3, 230 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 231 .schan_val = 1, 232 .schan_val2 = 4, 233 .expected = "0.3333333333333333", 234 }, 235 { 236 .name = "small IIO_VAL_FRACTIONAL_LOG2, -1 < scale < 0", 237 .numerator = -16, 238 .denominator = 3, 239 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 240 .schan_val = 1, 241 .schan_val2 = 4, 242 .expected = "-0.3333333333333333", 243 }, 244 { 245 .name = "small IIO_VAL_FRACTIONAL_LOG2, 0 < scale < 2", 246 .numerator = 8, 247 .denominator = 3, 248 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 249 .schan_val = 1, 250 .schan_val2 = 1, 251 .expected = "1.3333333333333333", 252 }, 253 { 254 .name = "small IIO_VAL_FRACTIONAL_LOG2, -2 < scale < 0", 255 .numerator = -8, 256 .denominator = 3, 257 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 258 .schan_val = 1, 259 .schan_val2 = 1, 260 .expected = "-1.3333333333333333", 261 }, 262 { 263 .name = "small IIO_VAL_INT_PLUS_MICRO, positive", 264 .numerator = 1, 265 .denominator = 2, 266 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 267 .schan_val = 5, 268 .schan_val2 = 1234, 269 .expected = "2.500617", 270 }, 271 { 272 .name = "small IIO_VAL_INT_PLUS_MICRO, negative", 273 .numerator = -1, 274 .denominator = 2, 275 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 276 .schan_val = 5, 277 .schan_val2 = 1234, 278 .expected = "-2.500617", 279 }, 280 /* 281 * INT_PLUS_{MICRO,NANO} positive/negative corner cases 282 */ 283 { 284 .name = "negative IIO_VAL_INT_PLUS_NANO, negative schan", 285 .numerator = 1000000, 286 .denominator = 8060, 287 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 288 .schan_val = -10, 289 .schan_val2 = 123456, 290 .expected = "-1240.710106203", 291 }, 292 { 293 .name = "negative IIO_VAL_INT_PLUS_NANO, both negative", 294 .numerator = -1000000, 295 .denominator = 8060, 296 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 297 .schan_val = -10, 298 .schan_val2 = 123456, 299 .expected = "1240.710106203", 300 }, 301 { 302 .name = "negative IIO_VAL_INT_PLUS_NANO, 3 negative", 303 .numerator = -1000000, 304 .denominator = -8060, 305 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 306 .schan_val = -10, 307 .schan_val2 = 123456, 308 .expected = "-1240.710106203", 309 }, 310 { 311 .name = "negative IIO_VAL_INT_PLUS_NANO, 4 negative", 312 .numerator = -1000000, 313 .denominator = -8060, 314 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 315 .schan_val = -10, 316 .schan_val2 = -123456, 317 .expected = "-1240.710106203", 318 }, 319 { 320 .name = "negative IIO_VAL_INT_PLUS_NANO, negative, *val = 0", 321 .numerator = 1, 322 .denominator = -10, 323 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 324 .schan_val = 0, 325 .schan_val2 = 123456789, 326 .expected = "-0.012345678", 327 }, 328 /* 329 * INT_PLUS_{MICRO,NANO} decimal part overflow 330 */ 331 { 332 .name = "decimal overflow IIO_VAL_INT_PLUS_NANO, positive", 333 .numerator = 1000000, 334 .denominator = 8060, 335 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 336 .schan_val = 10, 337 .schan_val2 = 123456789, 338 .expected = "1256.01200856", 339 }, 340 { 341 .name = "decimal overflow IIO_VAL_INT_PLUS_NANO, negative", 342 .numerator = -1000000, 343 .denominator = 8060, 344 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 345 .schan_val = 10, 346 .schan_val2 = 123456789, 347 .expected = "-1256.01200856", 348 }, 349 { 350 .name = "decimal overflow IIO_VAL_INT_PLUS_NANO, negative schan", 351 .numerator = 1000000, 352 .denominator = 8060, 353 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 354 .schan_val = -10, 355 .schan_val2 = 123456789, 356 .expected = "-1256.01200856", 357 }, 358 { 359 .name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, positive", 360 .numerator = 1000000, 361 .denominator = 8060, 362 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 363 .schan_val = 10, 364 .schan_val2 = 123456789, 365 .expected = "16557.914267", 366 }, 367 { 368 .name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, negative", 369 .numerator = -1000000, 370 .denominator = 8060, 371 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 372 .schan_val = 10, 373 .schan_val2 = 123456789, 374 .expected = "-16557.914267", 375 }, 376 { 377 .name = "decimal overflow IIO_VAL_INT_PLUS_MICRO, negative schan", 378 .numerator = 1000000, 379 .denominator = 8060, 380 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 381 .schan_val = -10, 382 .schan_val2 = 123456789, 383 .expected = "-16557.914267", 384 }, 385 /* 386 * 32-bit overflow conditions 387 */ 388 { 389 .name = "overflow IIO_VAL_FRACTIONAL, positive", 390 .numerator = 2, 391 .denominator = 20, 392 .schan_scale_type = IIO_VAL_FRACTIONAL, 393 .schan_val = S32_MAX, 394 .schan_val2 = 1, 395 .expected = "214748364.7", 396 }, 397 { 398 .name = "overflow IIO_VAL_FRACTIONAL, negative", 399 .numerator = -2, 400 .denominator = 20, 401 .schan_scale_type = IIO_VAL_FRACTIONAL, 402 .schan_val = S32_MAX, 403 .schan_val2 = 1, 404 .expected = "-214748364.7", 405 }, 406 { 407 .name = "overflow IIO_VAL_FRACTIONAL_LOG2, positive", 408 .numerator = S32_MAX, 409 .denominator = 4096, 410 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 411 .schan_val = 4096, 412 .schan_val2 = 16, 413 .expected = "32767.99998474121", 414 }, 415 { 416 .name = "overflow IIO_VAL_FRACTIONAL_LOG2, negative", 417 .numerator = S32_MAX, 418 .denominator = 4096, 419 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 420 .schan_val = -4096, 421 .schan_val2 = 16, 422 .expected = "-32767.99998474121", 423 }, 424 { 425 .name = "overflow IIO_VAL_INT_PLUS_NANO, positive", 426 .numerator = 2, 427 .denominator = 20, 428 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 429 .schan_val = 10, 430 .schan_val2 = S32_MAX, 431 .expected = "1.214748364", 432 }, 433 { 434 .name = "overflow IIO_VAL_INT_PLUS_NANO, negative", 435 .numerator = -2, 436 .denominator = 20, 437 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 438 .schan_val = 10, 439 .schan_val2 = S32_MAX, 440 .expected = "-1.214748364", 441 }, 442 { 443 .name = "overflow IIO_VAL_INT_PLUS_NANO, negative schan", 444 .numerator = 2, 445 .denominator = 20, 446 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 447 .schan_val = -10, 448 .schan_val2 = S32_MAX, 449 .expected = "-1.214748364", 450 }, 451 { 452 .name = "overflow IIO_VAL_INT_PLUS_MICRO, positive", 453 .numerator = 2, 454 .denominator = 20, 455 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 456 .schan_val = 10, 457 .schan_val2 = S32_MAX, 458 .expected = "215.748364", 459 }, 460 { 461 .name = "overflow IIO_VAL_INT_PLUS_MICRO, negative", 462 .numerator = -2, 463 .denominator = 20, 464 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 465 .schan_val = 10, 466 .schan_val2 = S32_MAX, 467 .expected = "-215.748364", 468 }, 469 { 470 .name = "overflow IIO_VAL_INT_PLUS_MICRO, negative schan", 471 .numerator = 2, 472 .denominator = 20, 473 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 474 .schan_val = -10, 475 .schan_val2 = S32_MAX, 476 .expected = "-215.748364", 477 }, 478 }; 479 480 const struct rescale_tc_data offset_cases[] = { 481 /* 482 * Typical use cases 483 */ 484 { 485 .name = "typical IIO_VAL_INT, positive", 486 .offset = 1234, 487 .schan_scale_type = IIO_VAL_INT, 488 .schan_val = 123, 489 .schan_val2 = 0, 490 .schan_off = 14, 491 .expected_off = "24", /* 23.872 */ 492 }, 493 { 494 .name = "typical IIO_VAL_INT, negative", 495 .offset = -1234, 496 .schan_scale_type = IIO_VAL_INT, 497 .schan_val = 12, 498 .schan_val2 = 0, 499 .schan_off = 14, 500 .expected_off = "-88", /* -88.83333333333333 */ 501 }, 502 { 503 .name = "typical IIO_VAL_FRACTIONAL, positive", 504 .offset = 1234, 505 .schan_scale_type = IIO_VAL_FRACTIONAL, 506 .schan_val = 12, 507 .schan_val2 = 34, 508 .schan_off = 14, 509 .expected_off = "3510", /* 3510.333333333333 */ 510 }, 511 { 512 .name = "typical IIO_VAL_FRACTIONAL, negative", 513 .offset = -1234, 514 .schan_scale_type = IIO_VAL_FRACTIONAL, 515 .schan_val = 12, 516 .schan_val2 = 34, 517 .schan_off = 14, 518 .expected_off = "-3482", /* -3482.333333333333 */ 519 }, 520 { 521 .name = "typical IIO_VAL_FRACTIONAL_LOG2, positive", 522 .offset = 1234, 523 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 524 .schan_val = 12, 525 .schan_val2 = 16, 526 .schan_off = 14, 527 .expected_off = "6739299", /* 6739299.333333333 */ 528 }, 529 { 530 .name = "typical IIO_VAL_FRACTIONAL_LOG2, negative", 531 .offset = -1234, 532 .schan_scale_type = IIO_VAL_FRACTIONAL_LOG2, 533 .schan_val = 12, 534 .schan_val2 = 16, 535 .schan_off = 14, 536 .expected_off = "-6739271", /* -6739271.333333333 */ 537 }, 538 { 539 .name = "typical IIO_VAL_INT_PLUS_NANO, positive", 540 .offset = 1234, 541 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 542 .schan_val = 10, 543 .schan_val2 = 123456789, 544 .schan_off = 14, 545 .expected_off = "135", /* 135.8951219647469 */ 546 }, 547 { 548 .name = "typical IIO_VAL_INT_PLUS_NANO, negative", 549 .offset = -1234, 550 .schan_scale_type = IIO_VAL_INT_PLUS_NANO, 551 .schan_val = 10, 552 .schan_val2 = 123456789, 553 .schan_off = 14, 554 .expected_off = "-107", /* -107.89512196474689 */ 555 }, 556 { 557 .name = "typical IIO_VAL_INT_PLUS_MICRO, positive", 558 .offset = 1234, 559 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 560 .schan_val = 10, 561 .schan_val2 = 123456789, 562 .schan_off = 14, 563 .expected_off = "23", /* 23.246438560723952 */ 564 }, 565 { 566 .name = "typical IIO_VAL_INT_PLUS_MICRO, negative", 567 .offset = -12345, 568 .schan_scale_type = IIO_VAL_INT_PLUS_MICRO, 569 .schan_val = 10, 570 .schan_val2 = 123456789, 571 .schan_off = 14, 572 .expected_off = "-78", /* -78.50185091745313 */ 573 }, 574 }; 575 576 static void case_to_desc(const struct rescale_tc_data *t, char *desc) 577 { 578 strcpy(desc, t->name); 579 } 580 581 KUNIT_ARRAY_PARAM(iio_rescale_scale, scale_cases, case_to_desc); 582 KUNIT_ARRAY_PARAM(iio_rescale_offset, offset_cases, case_to_desc); 583 584 /** 585 * iio_str_to_nano() - Parse a fixed-point string to get an 586 * IIO_VAL_INT_PLUS_NANO value 587 * @str: The string to parse 588 * @nano: The number as an integer 589 * 590 * Returns 0 on success, or a negative error code if the string cound not be 591 * parsed. 592 */ 593 static int iio_str_to_nano(const char *str, s64 *nano) 594 { 595 int tmp, tmp2; 596 int ret = 0; 597 598 /* 599 * iio_str_to_fixpoint() uses 10^8 here instead of 10^9 as fract_mult is 600 * the multiplier for the first decimal place. 601 */ 602 ret = iio_str_to_fixpoint(str, 100000000, &tmp, &tmp2); 603 if (ret < 0) 604 return ret; 605 606 if (tmp < 0) 607 tmp2 *= -1; 608 609 *nano = (s64)tmp * 1000000000UL + tmp2; 610 611 return ret; 612 } 613 614 /** 615 * iio_test_relative_error_ppm() - Compute relative error (in parts-per-million) 616 * between two fixed-point strings 617 * @real_str: The real value as a string 618 * @exp_str: The expected value as a string 619 * 620 * Returns a negative error code if the strings cound not be parsed, or the 621 * relative error in parts-per-million. 622 */ 623 static int iio_test_relative_error_ppm(const char *real_str, const char *exp_str) 624 { 625 s64 real, exp, err; 626 int ret; 627 628 ret = iio_str_to_nano(real_str, &real); 629 if (ret < 0) 630 return ret; 631 632 ret = iio_str_to_nano(exp_str, &exp); 633 if (ret < 0) 634 return ret; 635 636 if (!exp) { 637 pr_err("Expected value is null, relative error is undefined\n"); 638 return -EINVAL; 639 } 640 641 err = 1000000UL * abs(exp - real); 642 643 return (int)div64_u64(err, abs(exp)); 644 } 645 646 static void iio_rescale_test_scale(struct kunit *test) 647 { 648 struct rescale_tc_data *t = (struct rescale_tc_data *)test->param_value; 649 char *buff = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL); 650 struct rescale rescale; 651 int values[2]; 652 int rel_ppm; 653 int ret; 654 655 rescale.numerator = t->numerator; 656 rescale.denominator = t->denominator; 657 rescale.offset = t->offset; 658 values[0] = t->schan_val; 659 values[1] = t->schan_val2; 660 661 ret = rescale_process_scale(&rescale, t->schan_scale_type, 662 &values[0], &values[1]); 663 664 ret = iio_format_value(buff, ret, 2, values); 665 KUNIT_EXPECT_EQ(test, (int)strlen(buff), ret); 666 667 rel_ppm = iio_test_relative_error_ppm(buff, t->expected); 668 KUNIT_EXPECT_GE_MSG(test, rel_ppm, 0, "failed to compute ppm\n"); 669 670 KUNIT_EXPECT_EQ_MSG(test, rel_ppm, 0, 671 "\t real=%s" 672 "\texpected=%s\n", 673 buff, t->expected); 674 } 675 676 static void iio_rescale_test_offset(struct kunit *test) 677 { 678 struct rescale_tc_data *t = (struct rescale_tc_data *)test->param_value; 679 char *buff_off = kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL); 680 struct rescale rescale; 681 int values[2]; 682 int ret; 683 684 rescale.numerator = t->numerator; 685 rescale.denominator = t->denominator; 686 rescale.offset = t->offset; 687 values[0] = t->schan_val; 688 values[1] = t->schan_val2; 689 690 ret = rescale_process_offset(&rescale, t->schan_scale_type, 691 t->schan_val, t->schan_val2, t->schan_off, 692 &values[0], &values[1]); 693 694 ret = iio_format_value(buff_off, ret, 2, values); 695 KUNIT_EXPECT_EQ(test, (int)strlen(buff_off), ret); 696 697 KUNIT_EXPECT_STREQ(test, strim(buff_off), t->expected_off); 698 } 699 700 static struct kunit_case iio_rescale_test_cases[] = { 701 KUNIT_CASE_PARAM(iio_rescale_test_scale, iio_rescale_scale_gen_params), 702 KUNIT_CASE_PARAM(iio_rescale_test_offset, iio_rescale_offset_gen_params), 703 {} 704 }; 705 706 static struct kunit_suite iio_rescale_test_suite = { 707 .name = "iio-rescale", 708 .test_cases = iio_rescale_test_cases, 709 }; 710 kunit_test_suite(iio_rescale_test_suite); 711