description.c

   1 /*
   2  * Copyright (C) 2014 Intel Corporation.
   3  */
   4
   5 #include <stdlib.h>
   6 #include <ctype.h>
   7 #include <utils/Log.h>
   8 #include <cutils/properties.h>
   9 #include <hardware/sensors.h>
  10 #include "common.h"
  11 #include "enumeration.h"
  12 #include "description.h"
  13 #include "utils.h"
  14
  15 #define IIO_SENSOR_HAL_VERSION  1
  16
  17 #define MIN_ON_CHANGE_SAMPLING_PERIOD_US   200000 /* For on change sensors (temperature, proximity, ALS, etc.) report we support 5 Hz max (0.2 s min period) */
  18 #define MAX_ON_CHANGE_SAMPLING_PERIOD_US 10000000 /* 0.1 Hz min (10 s max period)*/
  19
  20 /*
  21  * About properties
  22  *
  23  * We acquire a number of parameters about sensors by reading properties.
  24  * The idea here is that someone (either a script, or daemon, sets them
  25  * depending on the set of sensors present on the machine.
  26  *
  27  * There are fallback paths in case the properties are not defined, but it is
  28  * highly desirable to at least have the following for each sensor:
  29  *
  30  * ro.iio.anglvel.name = Gyroscope
  31  * ro.iio.anglvel.vendor = Intel
  32  * ro.iio.anglvel.max_range = 35
  33  * ro.iio.anglvel.resolution = 0.002
  34  * ro.iio.anglvel.power = 6.1
  35  *
  36  * Besides these, we have a couple of knobs initially used to cope with Intel
  37  * Sensor Hub oddities, such as HID inspired units or firmware bugs:
  38  *
  39  * ro.iio.anglvel.transform = ISH
  40  * ro.iio.anglvel.quirks = init-rate
  41  *
  42  * The "terse" quirk indicates that the underlying driver only sends events
  43  * when the sensor reports a change. The HAL then periodically generates
  44  * duplicate events so the sensor behaves as a continously firing one.
  45  *
  46  * The "noisy" quirk indicates that the underlying driver has a unusually high
  47  * level of noise in its readings, and that the HAL has to accomodate it
  48  * somehow, e.g. in the magnetometer calibration code path.
  49  *
  50  * This one is used specifically to pass a calibration scale to ALS drivers:
  51  *
  52  * ro.iio.illuminance.name = CPLM3218x Ambient Light Sensor
  53  * ro.iio.illuminance.vendor = Capella Microsystems
  54  * ro.iio.illuminance.max_range = 167000
  55  * ro.iio.illuminance.resolution = 1
  56  * ro.iio.illuminance.power = .001
  57  * ro.iio.illuminance.illumincalib = 7400
  58  *
  59  * There's a 'opt_scale' specifier, documented as follows:
  60  *
  61  *  This adds support for a scaling factor that can be expressed
  62  *  using properties, for all sensors, on a channel basis. That
  63  *  scaling factor is applied after all other transforms have been
  64  *  applied, and is intended as a way to compensate for problems
  65  *  such as an incorrect axis polarity for a given sensor.
  66  *
  67  *  The syntax is <usual property prefix>.<channel>.opt_scale, e.g.
  68  *  ro.iio.accel.y.opt_scale = -1 to negate the sign of the y readings
  69  *  for the accelerometer.
  70  *
  71  *  For sensors using a single channel - and only those - the channel
  72  *  name is implicitly void and a syntax such as ro.iio.illuminance.
  73  *  opt_scale = 3 has to be used.
  74  *
  75  * 'panel' and 'rotation' specifiers can be used to express ACPI PLD placement
  76  * information ; if found they will be used in priority over the actual ACPI
  77  * data. That is intended as a way to verify values during development.
  78  *
  79  * It's possible to use the contents of the iio device name as a way to
  80  * discriminate between sensors. Several sensors of the same type can coexist:
  81  * e.g. ro.iio.temp.bmg160.name = BMG160 Thermometer will be used in priority
  82  * over ro.iio.temp.name = BMC150 Thermometer if the sensor for which we query
  83  * properties values happen to have its iio device name set to bmg160.
  84  */
  85
  86 int sensor_get_st_prop (int s, const char* sel, char val[MAX_NAME_SIZE])
  87 {
  88         char prop_name[PROP_NAME_MAX];
  89         char prop_val[PROP_VALUE_MAX];
  90         char extended_sel[PROP_VALUE_MAX];
  91
  92         int i                   = sensor[s].catalog_index;
  93         const char *prefix      = sensor_catalog[i].tag;
  94
  95         /* First try most specialized form, like ro.iio.anglvel.bmg160.name */
  96
  97         snprintf(extended_sel, PROP_NAME_MAX, "%s.%s",
  98                  sensor[s].internal_name, sel);
  99
 100         snprintf(prop_name, PROP_NAME_MAX, PROP_BASE, prefix, extended_sel);
 101
 102         if (property_get(prop_name, prop_val, "")) {
 103                 strncpy(val, prop_val, MAX_NAME_SIZE-1);
 104                 val[MAX_NAME_SIZE-1] = '\0';
 105                 return 0;
 106         }
 107
 108         /* Fall back to simple form, like ro.iio.anglvel.name */
 109
 110         sprintf(prop_name, PROP_BASE, prefix, sel);
 111
 112         if (property_get(prop_name, prop_val, "")) {
 113                 strncpy(val, prop_val, MAX_NAME_SIZE-1);
 114                 val[MAX_NAME_SIZE-1] = '\0';
 115                 return 0;
 116         }
 117
 118         return -1;
 119 }
 120
 121
 122 int sensor_get_prop (int s, const char* sel, int* val)
 123 {
 124         char buf[MAX_NAME_SIZE];
 125
 126         if (sensor_get_st_prop(s, sel, buf))
 127                 return -1;
 128
 129         *val = atoi(buf);
 130         return 0;
 131 }
 132
 133
 134 int sensor_get_fl_prop (int s, const char* sel, float* val)
 135 {
 136         char buf[MAX_NAME_SIZE];
 137
 138         if (sensor_get_st_prop(s, sel, buf))
 139                 return -1;
 140
 141         *val = (float) strtod(buf, NULL);
 142         return 0;
 143 }
 144
 145
 146 char* sensor_get_name (int s)
 147 {
 148         char buf[MAX_NAME_SIZE];
 149
 150         if (sensor[s].is_virtual) {
 151                 switch (sensor[s].type) {
 152                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 153                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 154                                 strcpy(buf, sensor[sensor[s].base[0]].friendly_name);
 155                                 snprintf(sensor[s].friendly_name,
 156                                          MAX_NAME_SIZE,
 157                                          "%s %s", "Uncalibrated", buf);
 158                                 return sensor[s].friendly_name;
 159
 160                         default:
 161                                 return "";
 162                 }
 163         }
 164
 165         if (sensor[s].friendly_name[0] != '\0' ||
 166                 !sensor_get_st_prop(s, "name", sensor[s].friendly_name))
 167                         return sensor[s].friendly_name;
 168
 169         /* If we got a iio device name from sysfs, use it */
 170         if (sensor[s].internal_name[0]) {
 171                 snprintf(sensor[s].friendly_name, MAX_NAME_SIZE, "S%d-%s",
 172                          s, sensor[s].internal_name);
 173         } else {
 174                 sprintf(sensor[s].friendly_name, "S%d", s);
 175         }
 176
 177         return sensor[s].friendly_name;
 178 }
 179
 180
 181 char* sensor_get_vendor (int s)
 182 {
 183         if (sensor[s].is_virtual) {
 184                 switch (sensor[s].type) {
 185                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 186                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 187                                 return sensor[sensor[s].base[0]].vendor_name;
 188                         break;
 189
 190                         default:
 191                                 return "";
 192
 193                 }
 194         }
 195
 196         if (sensor[s].vendor_name[0] ||
 197                 !sensor_get_st_prop(s, "vendor", sensor[s].vendor_name))
 198                         return sensor[s].vendor_name;
 199
 200         return "";
 201 }
 202
 203
 204 int sensor_get_version (__attribute__((unused)) int s)
 205 {
 206         return IIO_SENSOR_HAL_VERSION;
 207 }
 208
 209
 210 float sensor_get_max_range (int s)
 211 {
 212         if (sensor[s].is_virtual) {
 213                 switch (sensor[s].type) {
 214                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 215                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 216                                 return sensor[sensor[s].base[0]].max_range;
 217
 218                         default:
 219                                 return 0.0;
 220                 }
 221         }
 222
 223         if (sensor[s].max_range != 0.0 ||
 224                 !sensor_get_fl_prop(s, "max_range", &sensor[s].max_range))
 225                         return sensor[s].max_range;
 226
 227         /* Try returning a sensible value given the sensor type */
 228
 229         /* We should cap returned samples accordingly... */
 230
 231         switch (sensor[s].type) {
 232                 case SENSOR_TYPE_ACCELEROMETER:         /* m/s^2        */
 233                         return 50;
 234
 235                 case SENSOR_TYPE_MAGNETIC_FIELD:        /* micro-tesla  */
 236                         return 500;
 237
 238                 case SENSOR_TYPE_ORIENTATION:           /* degrees      */
 239                         return 360;
 240
 241                 case SENSOR_TYPE_GYROSCOPE:             /* radians/s    */
 242                         return 10;
 243
 244                 case SENSOR_TYPE_LIGHT:                 /* SI lux units */
 245                         return 50000;
 246
 247                 case SENSOR_TYPE_AMBIENT_TEMPERATURE:   /* °C          */
 248                 case SENSOR_TYPE_TEMPERATURE:           /* °C          */
 249                 case SENSOR_TYPE_PROXIMITY:             /* centimeters  */
 250                 case SENSOR_TYPE_PRESSURE:              /* hecto-pascal */
 251                 case SENSOR_TYPE_RELATIVE_HUMIDITY:     /* percent */
 252                         return 100;
 253
 254                 default:
 255                         return 0;
 256                 }
 257 }
 258
 259 static float sensor_get_min_freq (int s)
 260 {
 261         /*
 262          * Check if a low cap has been specified for this sensor sampling rate.
 263          * In some case, even when the driver supports lower rate, we still
 264          * wish to receive a certain number of samples per seconds for various
 265          * reasons (calibration, filtering, no change in power consumption...).
 266          */
 267
 268         float min_freq;
 269
 270         if (!sensor_get_fl_prop(s, "min_freq", &min_freq))
 271                 return min_freq;
 272
 273         return 0;
 274 }
 275
 276
 277 static float sensor_get_max_freq (int s)
 278 {
 279         float max_freq;
 280
 281         if (!sensor_get_fl_prop(s, "max_freq", &max_freq))
 282                 return max_freq;
 283
 284         return 1000;
 285 }
 286
 287 int sensor_get_cal_steps (int s)
 288 {
 289         int cal_steps;
 290         if (!sensor_get_prop(s, "cal_steps", &cal_steps))
 291                 return cal_steps;
 292
 293         return 0;
 294 }
 295
 296 float sensor_get_resolution (int s)
 297 {
 298         if (sensor[s].is_virtual) {
 299                 switch (sensor[s].type) {
 300                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 301                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 302                                 return sensor[sensor[s].base[0]].resolution;
 303
 304                         default:
 305                                 return 0;
 306                 }
 307         }
 308
 309         if (sensor[s].resolution != 0.0 ||
 310                 !sensor_get_fl_prop(s, "resolution", &sensor[s].resolution))
 311                         return sensor[s].resolution;
 312
 313         return 0;
 314 }
 315
 316
 317 float sensor_get_power (int s)
 318 {
 319
 320         if (sensor[s].is_virtual) {
 321                 switch (sensor[s].type) {
 322                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 323                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 324                                 return sensor[sensor[s].base[0]].power;
 325
 326                         default:
 327                                 return 0;
 328                 }
 329         }
 330
 331         /* mA used while sensor is in use ; not sure about volts :) */
 332         if (sensor[s].power != 0.0 ||
 333                 !sensor_get_fl_prop(s, "power", &sensor[s].power))
 334                         return sensor[s].power;
 335
 336         return 0;
 337 }
 338
 339
 340 float sensor_get_illumincalib (int s)
 341 {
 342         /* calibrating the ALS Sensor*/
 343         if (sensor[s].illumincalib != 0.0 ||
 344                 !sensor_get_fl_prop(s, "illumincalib", &sensor[s].illumincalib)) {
 345                         return sensor[s].illumincalib;
 346         }
 347
 348         return 0;
 349 }
 350
 351
 352 uint32_t sensor_get_quirks (int s)
 353 {
 354         char quirks_buf[MAX_NAME_SIZE];
 355
 356         /* Read and decode quirks property on first reference */
 357         if (!(sensor[s].quirks & QUIRK_ALREADY_DECODED)) {
 358                 quirks_buf[0] = '\0';
 359                 sensor_get_st_prop(s, "quirks", quirks_buf);
 360
 361                 if (strstr(quirks_buf, "init-rate"))
 362                         sensor[s].quirks |= QUIRK_INITIAL_RATE;
 363
 364                 if (strstr(quirks_buf, "continuous"))
 365                         sensor[s].quirks |= QUIRK_FORCE_CONTINUOUS;
 366
 367                 if (strstr(quirks_buf, "terse"))
 368                         sensor[s].quirks |= QUIRK_TERSE_DRIVER;
 369
 370                 if (strstr(quirks_buf, "noisy"))
 371                         sensor[s].quirks |= QUIRK_NOISY;
 372
 373                 sensor[s].quirks |= QUIRK_ALREADY_DECODED;
 374         }
 375
 376         return sensor[s].quirks;
 377 }
 378
 379
 380 int sensor_get_order (int s, unsigned char map[MAX_CHANNELS])
 381 {
 382         char buf[MAX_NAME_SIZE];
 383         int i;
 384         int count = sensor_catalog[sensor[s].catalog_index].num_channels;
 385
 386         if (sensor_get_st_prop(s, "order", buf))
 387                 return 0; /* No order property */
 388
 389         /* Assume ASCII characters, in the '0'..'9' range */
 390
 391         for (i=0; i<count; i++)
 392                 if (buf[i] - '0' >= count) {
 393                         ALOGE("Order index out of range for sensor %d\n", s);
 394                         return 0;
 395                 }
 396
 397         for (i=0; i<count; i++)
 398                 map[i] = buf[i] - '0';
 399
 400         return 1;       /* OK to use modified ordering map */
 401 }
 402
 403
 404 char* sensor_get_string_type (int s)
 405 {
 406         switch (sensor[s].type) {
 407                 case SENSOR_TYPE_ACCELEROMETER:
 408                         return SENSOR_STRING_TYPE_ACCELEROMETER;
 409
 410                 case SENSOR_TYPE_MAGNETIC_FIELD:
 411                         return SENSOR_STRING_TYPE_MAGNETIC_FIELD;
 412
 413                 case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 414                         return SENSOR_STRING_TYPE_MAGNETIC_FIELD_UNCALIBRATED;
 415
 416                 case SENSOR_TYPE_ORIENTATION:
 417                         return SENSOR_STRING_TYPE_ORIENTATION;
 418
 419                 case SENSOR_TYPE_GYROSCOPE:
 420                         return SENSOR_STRING_TYPE_GYROSCOPE;
 421
 422                 case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 423                         return SENSOR_STRING_TYPE_GYROSCOPE_UNCALIBRATED;
 424
 425                 case SENSOR_TYPE_LIGHT:
 426                         return SENSOR_STRING_TYPE_LIGHT;
 427
 428                 case SENSOR_TYPE_AMBIENT_TEMPERATURE:
 429                         return SENSOR_STRING_TYPE_AMBIENT_TEMPERATURE;
 430
 431                 case SENSOR_TYPE_TEMPERATURE:
 432                         return SENSOR_STRING_TYPE_TEMPERATURE;
 433
 434                 case SENSOR_TYPE_PROXIMITY:
 435                         return SENSOR_STRING_TYPE_PROXIMITY;
 436
 437                 case SENSOR_TYPE_PRESSURE:
 438                         return SENSOR_STRING_TYPE_PRESSURE;
 439
 440                 case SENSOR_TYPE_RELATIVE_HUMIDITY:
 441                         return SENSOR_STRING_TYPE_RELATIVE_HUMIDITY;
 442
 443                 default:
 444                         return "";
 445                 }
 446 }
 447
 448
 449 flag_t sensor_get_flags (int s)
 450 {
 451         flag_t flags = 0;
 452
 453         switch (sensor[s].type) {
 454                 case SENSOR_TYPE_LIGHT:
 455                 case SENSOR_TYPE_AMBIENT_TEMPERATURE:
 456                 case SENSOR_TYPE_TEMPERATURE:
 457                 case SENSOR_TYPE_RELATIVE_HUMIDITY:
 458                         flags |= SENSOR_FLAG_ON_CHANGE_MODE;
 459                         break;
 460
 461
 462                 case SENSOR_TYPE_PROXIMITY:
 463                         flags |= SENSOR_FLAG_WAKE_UP;
 464                         flags |= SENSOR_FLAG_ON_CHANGE_MODE;
 465                         break;
 466
 467                 default:
 468                         break;
 469                 }
 470         return flags;
 471 }
 472
 473
 474 static int get_cdd_freq (int s, int must)
 475 {
 476         switch (sensor[s].type) {
 477                 case SENSOR_TYPE_ACCELEROMETER:
 478                         return (must ? 100 : 200); /* must 100 Hz, should 200 Hz, CDD compliant */
 479
 480                 case SENSOR_TYPE_GYROSCOPE:
 481                         return (must ? 200 : 200); /* must 200 Hz, should 200 Hz, CDD compliant */
 482
 483                 case SENSOR_TYPE_MAGNETIC_FIELD:
 484                         return (must ? 10 : 50);   /* must 10 Hz, should 50 Hz, CDD compliant */
 485
 486                 case SENSOR_TYPE_LIGHT:
 487                 case SENSOR_TYPE_AMBIENT_TEMPERATURE:
 488                 case SENSOR_TYPE_TEMPERATURE:
 489                         return (must ? 1 : 2);     /* must 1 Hz, should 2Hz, not mentioned in CDD */
 490
 491                 default:
 492                         return 1; /* Use 1 Hz by default, e.g. for proximity */
 493         }
 494 }
 495
 496 /*
 497  * This value is defined only for continuous mode and on-change sensors. It is the delay between two sensor events corresponding to the lowest frequency that
 498  * this sensor supports. When lower frequencies are requested through batch()/setDelay() the events will be generated at this frequency instead. It can be used
 499  * by the framework or applications to estimate when the batch FIFO may be full. maxDelay should always fit within a 32 bit signed integer. It is declared as
 500  * 64 bit on 64 bit architectures only for binary compatibility reasons. Availability: SENSORS_DEVICE_API_VERSION_1_3
 501  */
 502 max_delay_t sensor_get_max_delay (int s)
 503 {
 504         char avail_sysfs_path[PATH_MAX];
 505         int dev_num     = sensor[s].dev_num;
 506         char freqs_buf[100];
 507         char* cursor;
 508         float min_supported_rate = 1000;
 509         float rate_cap;
 510         float sr;
 511
 512         /*
 513          * continuous, on-change: maximum sampling period allowed in microseconds.
 514          * one-shot, special : 0
 515          */
 516         switch (REPORTING_MODE(sensor_desc[s].flags)) {
 517                 case SENSOR_FLAG_ONE_SHOT_MODE:
 518                 case SENSOR_FLAG_SPECIAL_REPORTING_MODE:
 519                         return 0;
 520
 521                 case SENSOR_FLAG_ON_CHANGE_MODE:
 522                         return MAX_ON_CHANGE_SAMPLING_PERIOD_US;
 523
 524                 default:
 525                         break;
 526         }
 527
 528         if (sensor[s].is_virtual) {
 529                 switch (sensor[s].type) {
 530                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 531                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 532                                 return sensor_desc[sensor[s].base[0]].maxDelay;
 533                         default:
 534                                 return 0;
 535                 }
 536         }
 537         sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
 538
 539         if (sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf)) < 0) {
 540                 if (sensor[s].mode == MODE_POLL) {
 541                         /* The must rate */
 542                         min_supported_rate = get_cdd_freq(s, 1);
 543                 }
 544         } else {
 545                 cursor = freqs_buf;
 546                 while (*cursor && cursor[0]) {
 547
 548                         /* Decode a single value */
 549                         sr = strtod(cursor, NULL);
 550
 551                         if (sr < min_supported_rate)
 552                                 min_supported_rate = sr;
 553
 554                         /* Skip digits */
 555                         while (cursor[0] && !isspace(cursor[0]))
 556                                 cursor++;
 557
 558                         /* Skip spaces */
 559                         while (cursor[0] && isspace(cursor[0]))
 560                                 cursor++;
 561                 }
 562         }
 563
 564         /* Check if a minimum rate was specified for this sensor */
 565         rate_cap = sensor_get_min_freq(s);
 566
 567         if (min_supported_rate < rate_cap)
 568                 min_supported_rate = rate_cap;
 569
 570         /* return 0 for wrong values */
 571         if (min_supported_rate < 0.1)
 572                 return 0;
 573
 574         /* Return microseconds */
 575         return (max_delay_t) (1000000.0 / min_supported_rate);
 576 }
 577
 578
 579 int32_t sensor_get_min_delay (int s)
 580 {
 581         char avail_sysfs_path[PATH_MAX];
 582         int dev_num     = sensor[s].dev_num;
 583         char freqs_buf[100];
 584         char* cursor;
 585         float max_supported_rate = 0;
 586         float sr;
 587
 588         /* continuous, on change: minimum sampling period allowed in microseconds.
 589          * special : 0, unless otherwise noted
 590          * one-shot:-1
 591          */
 592         switch (REPORTING_MODE(sensor_desc[s].flags)) {
 593                 case SENSOR_FLAG_ON_CHANGE_MODE:
 594                         return MIN_ON_CHANGE_SAMPLING_PERIOD_US;
 595
 596                 case SENSOR_FLAG_SPECIAL_REPORTING_MODE:
 597                         return 0;
 598
 599                 case SENSOR_FLAG_ONE_SHOT_MODE:
 600                         return -1;
 601
 602                 default:
 603                         break;
 604         }
 605
 606         if (sensor[s].is_virtual) {
 607                 switch (sensor[s].type) {
 608                         case SENSOR_TYPE_GYROSCOPE_UNCALIBRATED:
 609                         case SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED:
 610                                 return sensor_desc[sensor[s].base[0]].minDelay;
 611                         default:
 612                                 return 0;
 613                 }
 614         }
 615
 616         sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
 617
 618         if (sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf)) < 0) {
 619                 if (sensor[s].mode == MODE_POLL) {
 620                         /* The should rate */
 621                         max_supported_rate = get_cdd_freq(s, 0);
 622                 }
 623         } else {
 624                 cursor = freqs_buf;
 625                 while (*cursor && cursor[0]) {
 626
 627                         /* Decode a single value */
 628                         sr = strtod(cursor, NULL);
 629
 630                         if (sr > max_supported_rate && sr <= sensor_get_max_freq(s))
 631                                 max_supported_rate = sr;
 632
 633                         /* Skip digits */
 634                         while (cursor[0] && !isspace(cursor[0]))
 635                                 cursor++;
 636
 637                         /* Skip spaces */
 638                         while (cursor[0] && isspace(cursor[0]))
 639                                 cursor++;
 640                 }
 641         }
 642
 643         /* return 0 for wrong values */
 644         if (max_supported_rate < 0.1)
 645                 return 0;
 646
 647         /* Return microseconds */
 648         return (int32_t) (1000000.0 / max_supported_rate);
 649 }