OSDN -- Open-Source-Software-Entwicklung und Downloads
Übersetzungsstatus von Deutsch translation status for de

Android-x86
Fork
Spenden

  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

hardware-intel-libsensors: Commit

hardware/intel/libsensors


Commit MetaInfo

Revision6dd7dd1b4b8fb2e833671956ad936cbd635ed4db (tree)
Zeit2015-08-12 00:18:12
Autorbuildslave <sys_buildbot@inte...>
Commiterbuildslave

Log Message

Merge branch e35fc5677585eb789efb5c02e2de084fbedcd67d into android/master

Change-Id: I6d82ee93caa92676ff671d9b706ce7ee100aaed9
Tracked-On: https://jira01.devtools.intel.com/browse/CACTUS-3894

Ändern Zusammenfassung

Diff

--- a/Android.mk
+++ b/Android.mk
@@ -38,7 +38,7 @@ LOCAL_LDFLAGS := -Wl,--gc-sections
3838 LOCAL_SHARED_LIBRARIES := liblog libcutils libdl
3939 LOCAL_PRELINK_MODULE := false
4040 LOCAL_SRC_FILES := $(src_files)
41-
41+LOCAL_PROPRIETARY_MODULE := true
4242 include $(BUILD_SHARED_LIBRARY)
4343
4444 include $(CLEAR_VARS)
@@ -48,6 +48,7 @@ LOCAL_CFLAGS := -DLOG_TAG=\"Sensors\" -fvisibility=hidden
4848 LOCAL_SHARED_LIBRARIES := liblog libcutils libdl
4949 LOCAL_SRC_FILES := sens.c
5050 LOCAL_MODULE_TAGS := eng
51+LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_EXECUTABLES)
5152 include $(BUILD_EXECUTABLE)
5253
5354 endif
@@ -74,7 +75,7 @@ LOCAL_LDFLAGS := -Wl,--gc-sections
7475 LOCAL_SHARED_LIBRARIES := liblog libcutils
7576 LOCAL_PRELINK_MODULE := false
7677 LOCAL_SRC_FILES := $(activity_src_files)
77-
78+LOCAL_PROPRIETARY_MODULE := true
7879 include $(BUILD_SHARED_LIBRARY)
7980
8081 include $(CLEAR_VARS)
@@ -84,6 +85,7 @@ LOCAL_CFLAGS := -DLOG_TAG=\"Activity\" -fvisibility=hidden
8485 LOCAL_SHARED_LIBRARIES := liblog libcutils libdl
8586 LOCAL_SRC_FILES := activity.c
8687 LOCAL_MODULE_TAGS := eng
88+LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_EXECUTABLES)
8789 include $(BUILD_EXECUTABLE)
8890
8991 endif
--- a/common.h
+++ b/common.h
@@ -280,6 +280,12 @@ typedef struct
280280 */
281281 float mounting_matrix[9];
282282
283+ /** Count of available frequencies */
284+ int avail_freqs_count;
285+
286+ /** Array of available frequencies */
287+ float* avail_freqs;
288+
283289 /*
284290 * Event counter - will be used to check if we have a significant sample for noisy sensors. We want to make sure we do not send any wrong
285291 * events before filtering kicks in. We can also use it for statistics.
--- a/control.c
+++ b/control.c
@@ -36,11 +36,14 @@ static int poll_fd; /* epoll instance covering all enabled sensors */
3636
3737 static int active_poll_sensors; /* Number of enabled poll-mode sensors */
3838
39+static int flush_event_fd[2]; /* Pipe used for flush signaling */
40+
3941 /* We use pthread condition variables to get worker threads out of sleep */
4042 static pthread_condattr_t thread_cond_attr [MAX_SENSORS];
4143 static pthread_cond_t thread_release_cond [MAX_SENSORS];
4244 static pthread_mutex_t thread_release_mutex [MAX_SENSORS];
4345
46+#define FLUSH_REPORT_TAG 900
4447 /*
4548 * We associate tags to each of our poll set entries. These tags have the following values:
4649 * - a iio device number if the fd is a iio character device fd
@@ -302,6 +305,8 @@ void build_sensor_report_maps (int dev_num)
302305 known_channels++;
303306 }
304307
308+ sensor_update_max_range(s);
309+
305310 /* Stop sampling - if we are recovering from hal restart */
306311 enable_buffer(dev_num, 0);
307312 setup_trigger(s, "\n");
@@ -733,29 +738,18 @@ extern float sensor_get_max_freq (int s);
733738
734739 static float select_closest_available_rate(int s, float requested_rate)
735740 {
736- char avail_sysfs_path[PATH_MAX];
737- char freqs_buf[100];
738- char* cursor;
739741 float sr;
742+ int j;
740743 float selected_rate = 0;
741- float max_rate_from_prop;
744+ float max_rate_from_prop = sensor_get_max_freq(s);
742745 int dev_num = sensor[s].dev_num;
743746
744- sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
745- if (sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf)) <= 0) {
747+ if (!sensor[s].avail_freqs_count)
746748 return requested_rate;
747- }
748749
749- max_rate_from_prop = sensor_get_max_freq(s);
750- cursor = freqs_buf;
750+ for (j = 0; j < sensor[s].avail_freqs_count; j++) {
751751
752- /* Decode allowed sampling rates string, ex: "10 20 50 100" */
753-
754- /* While we're not at the end of the string */
755- while (*cursor && cursor[0]) {
756-
757- /* Decode a single value */
758- sr = strtod(cursor, NULL);
752+ sr = sensor[s].avail_freqs[j];
759753
760754 /* If this matches the selected rate, we're happy. Have some tolerance for rounding errors and avoid needless jumps to higher rates */
761755 if ((fabs(requested_rate - sr) <= 0.01) && (sr <= max_rate_from_prop)) {
@@ -774,14 +768,6 @@ static float select_closest_available_rate(int s, float requested_rate)
774768 if (sr > requested_rate) {
775769 return selected_rate;
776770 }
777-
778- /* Skip digits */
779- while (cursor[0] && !isspace(cursor[0]))
780- cursor++;
781-
782- /* Skip spaces */
783- while (cursor[0] && isspace(cursor[0]))
784- cursor++;
785771 }
786772
787773 /* Check for wrong values */
@@ -875,15 +861,10 @@ static int sensor_set_rate (int s, float requested_rate)
875861 * frequency and current sampling rate are different */
876862 if (sysfs_read_float(hrtimer_sampling_path, &sr) != -1 && sr != cur_sampling_rate)
877863 cur_sampling_rate = -1;
878- }
879-
880- /* Check if we have contraints on allowed sampling rates */
881-
882- if (!(sensor_get_quirks(s) & QUIRK_HRTIMER)) {
864+ } else {
883865 arb_sampling_rate = select_closest_available_rate(s, arb_sampling_rate);
884866 }
885867
886-
887868 /* Record the rate that was agreed upon with the sensor taken in isolation ; this avoid uncontrolled ripple effects between colocated sensor rates */
888869 sensor[s].semi_arbitrated_rate = arb_sampling_rate;
889870
@@ -917,7 +898,7 @@ static int sensor_set_rate (int s, float requested_rate)
917898 if (trig_sensors_per_dev[dev_num])
918899 enable_buffer(dev_num, 0);
919900
920- if (sensor_get_quirks(s) & QUIRK_HRTIMER) {
901+ if (sensor[s].hrtimer_trigger_name[0] != '\0') {
921902 sysfs_write_float(sysfs_path, select_closest_available_rate(s, arb_sampling_rate));
922903 } else {
923904 sysfs_write_float(sysfs_path, arb_sampling_rate);
@@ -1654,6 +1635,12 @@ await_event:
16541635 /* Get report from acquisition thread */
16551636 integrate_thread_report(ev[i].data.u32);
16561637 break;
1638+ case FLUSH_REPORT_TAG:
1639+ {
1640+ char flush_event_content;
1641+ read(flush_event_fd[0], &flush_event_content, sizeof(flush_event_content));
1642+ break;
1643+ }
16571644
16581645 default:
16591646 ALOGW("Unexpected event source!\n");
@@ -1693,18 +1680,21 @@ int sensor_set_delay (int s, int64_t ns)
16931680
16941681 int sensor_flush (int s)
16951682 {
1683+ char flush_event_content = 0;
16961684 /* If one shot or not enabled return -EINVAL */
16971685 if (sensor_desc[s].flags & SENSOR_FLAG_ONE_SHOT_MODE || !is_enabled(s))
16981686 return -EINVAL;
16991687
17001688 sensor[s].meta_data_pending++;
1689+ write(flush_event_fd[1], &flush_event_content, sizeof(flush_event_content));
17011690 return 0;
17021691 }
17031692
17041693
17051694 int allocate_control_data (void)
17061695 {
1707- int i;
1696+ int i, ret;
1697+ struct epoll_event ev = {0};
17081698
17091699 for (i=0; i<MAX_DEVICES; i++) {
17101700 device_fd[i] = -1;
@@ -1718,6 +1708,21 @@ int allocate_control_data (void)
17181708 return -1;
17191709 }
17201710
1711+ ret = pipe(flush_event_fd);
1712+ if (ret) {
1713+ ALOGE("Cannot create flush_event_fd");
1714+ return -1;
1715+ }
1716+
1717+ ev.events = EPOLLIN;
1718+ ev.data.u32 = FLUSH_REPORT_TAG;
1719+ ret = epoll_ctl(poll_fd, EPOLL_CTL_ADD, flush_event_fd[0] , &ev);
1720+ if (ret == -1) {
1721+ ALOGE("Failed adding %d to poll set (%s)\n",
1722+ flush_event_fd[0], strerror(errno));
1723+ return -1;
1724+ }
1725+
17211726 return poll_fd;
17221727 }
17231728
--- a/description.c
+++ b/description.c
@@ -11,6 +11,7 @@
1111 #include "enumeration.h"
1212 #include "description.h"
1313 #include "utils.h"
14+#include "transform.h"
1415
1516 #define IIO_SENSOR_HAL_VERSION 1
1617
@@ -218,6 +219,60 @@ int sensor_get_version (__attribute__((unused)) int s)
218219 return IIO_SENSOR_HAL_VERSION;
219220 }
220221
222+void sensor_update_max_range(int s)
223+{
224+ if (sensor[s].max_range)
225+ return;
226+
227+ if (sensor[s].num_channels && sensor[s].channel[0].type_info.realbits) {
228+ switch (sensor[s].type) {
229+ case SENSOR_TYPE_MAGNETIC_FIELD:
230+ sensor[s].max_range = (1ULL << sensor[s].channel[0].type_info.realbits) *
231+ CONVERT_MICROTESLA_TO_GAUSS(sensor[s].resolution) +
232+ (sensor[s].offset || sensor[s].channel[0].offset);
233+ sensor[s].max_range = CONVERT_GAUSS_TO_MICROTESLA(sensor[s].max_range);
234+ break;
235+ case SENSOR_TYPE_PROXIMITY:
236+ break;
237+ default:
238+ sensor[s].max_range = (1ULL << sensor[s].channel[0].type_info.realbits) *
239+ sensor[s].resolution + (sensor[s].offset || sensor[s].channel[0].offset);
240+ break;
241+ }
242+ }
243+
244+ if (!sensor[s].max_range) {
245+ /* Try returning a sensible value given the sensor type */
246+ /* We should cap returned samples accordingly... */
247+ switch (sensor[s].type) {
248+ case SENSOR_TYPE_ACCELEROMETER: /* m/s^2 */
249+ sensor[s].max_range = 50;
250+ break;
251+ case SENSOR_TYPE_MAGNETIC_FIELD: /* micro-tesla */
252+ sensor[s].max_range = 500;
253+ break;
254+ case SENSOR_TYPE_ORIENTATION: /* degrees */
255+ sensor[s].max_range = 360;
256+ break;
257+ case SENSOR_TYPE_GYROSCOPE: /* radians/s */
258+ sensor[s].max_range = 10;
259+ break;
260+ case SENSOR_TYPE_LIGHT: /* SI lux units */
261+ sensor[s].max_range = 50000;
262+ break;
263+ case SENSOR_TYPE_AMBIENT_TEMPERATURE: /* °C */
264+ case SENSOR_TYPE_TEMPERATURE: /* °C */
265+ case SENSOR_TYPE_PROXIMITY: /* centimeters */
266+ case SENSOR_TYPE_PRESSURE: /* hecto-pascal */
267+ case SENSOR_TYPE_RELATIVE_HUMIDITY: /* percent */
268+ sensor[s].max_range = 100;
269+ break;
270+ }
271+ }
272+
273+ if (sensor[s].max_range)
274+ sensor_desc[s].maxRange = sensor[s].max_range;
275+}
221276
222277 float sensor_get_max_range (int s)
223278 {
@@ -236,39 +291,10 @@ float sensor_get_max_range (int s)
236291 !sensor_get_fl_prop(s, "max_range", &sensor[s].max_range))
237292 return sensor[s].max_range;
238293
239- /* Try returning a sensible value given the sensor type */
240-
241- /* We should cap returned samples accordingly... */
242-
243- switch (sensor_desc[s].type) {
244- case SENSOR_TYPE_ACCELEROMETER: /* m/s^2 */
245- return 50;
246-
247- case SENSOR_TYPE_MAGNETIC_FIELD: /* micro-tesla */
248- return 500;
249-
250- case SENSOR_TYPE_ORIENTATION: /* degrees */
251- return 360;
252-
253- case SENSOR_TYPE_GYROSCOPE: /* radians/s */
254- return 10;
255-
256- case SENSOR_TYPE_LIGHT: /* SI lux units */
257- return 50000;
258-
259- case SENSOR_TYPE_AMBIENT_TEMPERATURE: /* °C */
260- case SENSOR_TYPE_TEMPERATURE: /* °C */
261- case SENSOR_TYPE_PROXIMITY: /* centimeters */
262- case SENSOR_TYPE_PRESSURE: /* hecto-pascal */
263- case SENSOR_TYPE_RELATIVE_HUMIDITY: /* percent */
264- return 100;
265-
266- default:
267- return 0;
268- }
294+ return 0;
269295 }
270296
271-static float sensor_get_min_freq (int s)
297+float sensor_get_min_freq (int s)
272298 {
273299 /*
274300 * Check if a low cap has been specified for this sensor sampling rate.
@@ -319,10 +345,18 @@ float sensor_get_resolution (int s)
319345 }
320346
321347 if (sensor[s].resolution != 0.0 ||
322- !sensor_get_fl_prop(s, "resolution", &sensor[s].resolution))
323- return sensor[s].resolution;
348+ !sensor_get_fl_prop(s, "resolution", &sensor[s].resolution)) {
349+ return sensor[s].resolution;
350+ }
324351
325- return 0;
352+ sensor[s].resolution = sensor[s].scale;
353+ if (!sensor[s].resolution && sensor[s].num_channels)
354+ sensor[s].resolution = sensor[s].channel[0].scale;
355+
356+ if (sensor[s].type == SENSOR_TYPE_MAGNETIC_FIELD)
357+ sensor[s].resolution = CONVERT_GAUSS_TO_MICROTESLA(sensor[s].resolution);
358+
359+ return sensor[s].resolution ? : 1;
326360 }
327361
328362
@@ -433,6 +467,35 @@ int sensor_get_order (int s, unsigned char map[MAX_CHANNELS])
433467 return 1; /* OK to use modified ordering map */
434468 }
435469
470+int sensor_get_available_frequencies (int s)
471+{
472+ int dev_num = sensor[s].dev_num, err, i;
473+ char avail_sysfs_path[PATH_MAX], freqs_buf[100];
474+ char *p, *end;
475+ float f;
476+
477+ sensor[s].avail_freqs_count = 0;
478+ sensor[s].avail_freqs = 0;
479+
480+ sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
481+
482+ err = sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf));
483+ if (err < 0)
484+ return 0;
485+
486+ for (p = freqs_buf, f = strtof(p, &end); p != end; p = end, f = strtof(p, &end))
487+ sensor[s].avail_freqs_count++;
488+
489+ if (sensor[s].avail_freqs_count) {
490+ sensor[s].avail_freqs = (float*) calloc(sensor[s].avail_freqs_count, sizeof(float));
491+
492+ for (p = freqs_buf, f = strtof(p, &end), i = 0; p != end; p = end, f = strtof(p, &end), i++)
493+ sensor[s].avail_freqs[i] = f;
494+ }
495+
496+ return 0;
497+}
498+
436499 int sensor_get_mounting_matrix (int s, float mm[9])
437500 {
438501 int dev_num = sensor[s].dev_num, err, i;
@@ -585,13 +648,9 @@ static int get_cdd_freq (int s, int must)
585648 */
586649 max_delay_t sensor_get_max_delay (int s)
587650 {
588- char avail_sysfs_path[PATH_MAX];
589- int dev_num = sensor[s].dev_num;
590- char freqs_buf[100];
591- char* cursor;
651+ int dev_num = sensor[s].dev_num, i;
592652 float min_supported_rate;
593653 float rate_cap;
594- float sr;
595654
596655 /*
597656 * continuous, on-change: maximum sampling period allowed in microseconds.
@@ -622,33 +681,14 @@ max_delay_t sensor_get_max_delay (int s)
622681 switch (sensor[s].mode) {
623682 case MODE_TRIGGER:
624683 /* For interrupt-based devices, obey the list of supported sampling rates */
625- sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
626- if (!(sensor_get_quirks(s) & QUIRK_HRTIMER) &&
627- sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf)) > 0) {
628-
684+ if (sensor[s].avail_freqs_count) {
629685 min_supported_rate = 1000;
630- cursor = freqs_buf;
631-
632- while (*cursor && cursor[0]) {
633-
634- /* Decode a single value */
635- sr = strtod(cursor, NULL);
636-
637- if (sr < min_supported_rate)
638- min_supported_rate = sr;
639-
640- /* Skip digits */
641- while (cursor[0] && !isspace(cursor[0]))
642- cursor++;
643-
644- /* Skip spaces */
645- while (cursor[0] && isspace(cursor[0]))
646- cursor++;
686+ for (i = 0; i < sensor[s].avail_freqs_count; i++) {
687+ if (sensor[s].avail_freqs[i] < min_supported_rate)
688+ min_supported_rate = sensor[s].avail_freqs[i];
647689 }
648-
649690 break;
650691 }
651-
652692 /* Fall through ... */
653693
654694 default:
@@ -671,17 +711,24 @@ max_delay_t sensor_get_max_delay (int s)
671711 return (max_delay_t) (1000000.0 / min_supported_rate);
672712 }
673713
714+float sensor_get_max_static_freq(int s)
715+{
716+ float max_from_prop = sensor_get_max_freq(s);
717+
718+ /* If we have max specified via a property use it */
719+ if (max_from_prop != ANDROID_MAX_FREQ) {
720+ return max_from_prop;
721+ } else {
722+ /* The should rate */
723+ return get_cdd_freq(s, 0);
724+ }
725+}
674726
675727 int32_t sensor_get_min_delay (int s)
676728 {
677- char avail_sysfs_path[PATH_MAX];
678- int dev_num = sensor[s].dev_num;
679- char freqs_buf[100];
680- char* cursor;
729+ int dev_num = sensor[s].dev_num, i;
681730 float max_supported_rate = 0;
682731 float max_from_prop = sensor_get_max_freq(s);
683- float sr;
684- int hrtimer_quirk_enabled = sensor_get_quirks(s) & QUIRK_HRTIMER;
685732
686733 /* continuous, on change: minimum sampling period allowed in microseconds.
687734 * special : 0, unless otherwise noted
@@ -711,10 +758,8 @@ int32_t sensor_get_min_delay (int s)
711758 }
712759 }
713760
714- sprintf(avail_sysfs_path, DEVICE_AVAIL_FREQ_PATH, dev_num);
715-
716- if (hrtimer_quirk_enabled || sysfs_read_str(avail_sysfs_path, freqs_buf, sizeof(freqs_buf)) < 0) {
717- if (hrtimer_quirk_enabled || (sensor[s].mode == MODE_POLL)) {
761+ if (!sensor[s].avail_freqs_count) {
762+ if (sensor[s].mode == MODE_POLL) {
718763 /* If we have max specified via a property use it */
719764 if (max_from_prop != ANDROID_MAX_FREQ)
720765 max_supported_rate = max_from_prop;
@@ -723,22 +768,11 @@ int32_t sensor_get_min_delay (int s)
723768 max_supported_rate = get_cdd_freq(s, 0);
724769 }
725770 } else {
726- cursor = freqs_buf;
727- while (*cursor && cursor[0]) {
728-
729- /* Decode a single value */
730- sr = strtod(cursor, NULL);
731-
732- if (sr > max_supported_rate && sr <= max_from_prop)
733- max_supported_rate = sr;
734-
735- /* Skip digits */
736- while (cursor[0] && !isspace(cursor[0]))
737- cursor++;
738-
739- /* Skip spaces */
740- while (cursor[0] && isspace(cursor[0]))
741- cursor++;
771+ for (i = 0; i < sensor[s].avail_freqs_count; i++) {
772+ if (sensor[s].avail_freqs[i] > max_supported_rate &&
773+ sensor[s].avail_freqs[i] <= max_from_prop) {
774+ max_supported_rate = sensor[s].avail_freqs[i];
775+ }
742776 }
743777 }
744778
--- a/description.h
+++ b/description.h
@@ -34,6 +34,7 @@ char* sensor_get_name (int s);
3434 char* sensor_get_vendor (int s);
3535 int sensor_get_version (int s);
3636 float sensor_get_max_range (int s);
37+void sensor_update_max_range (int s);
3738 float sensor_get_resolution (int s);
3839 float sensor_get_power (int s);
3940 flag_t sensor_get_flags (int s);
@@ -45,6 +46,7 @@ int sensor_get_prop (int s, const char* sel, int* val);
4546 int sensor_get_fl_prop (int s, const char* sel, float* val);
4647 int sensor_get_order (int s,unsigned char map[MAX_CHANNELS]);
4748 int sensor_get_mounting_matrix(int s,float mounting_matrix[9]);
49+int sensor_get_available_frequencies(int s);
4850 int sensor_get_cal_steps (int s);
4951 char* sensor_get_string_type (int s);
5052 int sensor_get_st_prop (int s, const char* sel, char val[MAX_NAME_SIZE]);
--- a/entry.c
+++ b/entry.c
@@ -25,7 +25,7 @@ static int activate (__attribute__((unused)) struct sensors_poll_device_t* dev,
2525 if (init_count == 0 || handle < 0 || handle >= sensor_count)
2626 return -EINVAL;
2727
28- entry_ts = get_timestamp_boot();
28+ entry_ts = get_timestamp_thread();
2929
3030 /*
3131 * The Intel sensor hub seems to have trouble enabling sensors before
@@ -49,7 +49,7 @@ static int activate (__attribute__((unused)) struct sensors_poll_device_t* dev,
4949
5050 ret = sensor_activate(handle, enabled, 0);
5151
52- elapsed_ms = (int) ((get_timestamp_boot() - entry_ts) / 1000000);
52+ elapsed_ms = (int) ((get_timestamp_thread() - entry_ts) / 1000000);
5353
5454 if (elapsed_ms) {
5555 if (enabled)
--- a/enumeration.c
+++ b/enumeration.c
@@ -655,6 +655,8 @@ static int add_sensor (int dev_num, int catalog_index, int mode)
655655 sensor[s].channel[c].raw_path_present = (access(sysfs_path, R_OK) != -1);
656656 }
657657
658+ sensor_get_available_frequencies(s);
659+
658660 if (sensor_get_mounting_matrix(s, sensor[s].mounting_matrix))
659661 sensor[s].quirks |= QUIRK_MOUNTING_MATRIX;
660662 else
@@ -882,12 +884,16 @@ static void update_sensor_matching_trigger_name (char name[MAX_NAME_SIZE], int*
882884 }
883885 }
884886
887+extern float sensor_get_max_static_freq(int s);
888+extern float sensor_get_min_freq (int s);
889+
885890 static int create_hrtimer_trigger(int s, int trigger)
886891 {
887892 struct stat dir_status;
888893 char buf[MAX_NAME_SIZE];
889894 char hrtimer_path[PATH_MAX];
890895 char hrtimer_name[MAX_NAME_SIZE];
896+ float min_supported_rate = 1, min_rate_cap, max_supported_rate;
891897
892898 snprintf(buf, MAX_NAME_SIZE, "hrtimer-%s-hr-dev%d", sensor[s].internal_name, sensor[s].dev_num);
893899 snprintf(hrtimer_name, MAX_NAME_SIZE, "%s-hr-dev%d", sensor[s].internal_name, sensor[s].dev_num);
@@ -904,6 +910,27 @@ static int create_hrtimer_trigger(int s, int trigger)
904910
905911 strncpy (sensor[s].hrtimer_trigger_name, hrtimer_name, MAX_NAME_SIZE);
906912 sensor[s].trigger_nr = trigger;
913+
914+ max_supported_rate = sensor_get_max_static_freq(s);
915+
916+ /* set 0 for wrong values */
917+ if (max_supported_rate < 0.1) {
918+ max_supported_rate = 0;
919+ }
920+
921+ sensor[s].max_supported_rate = max_supported_rate;
922+ sensor_desc[s].minDelay = max_supported_rate ? (int32_t) (1000000.0 / max_supported_rate) : 0;
923+
924+ /* Check if a minimum rate was specified for this sensor */
925+ min_rate_cap = sensor_get_min_freq(s);
926+
927+ if (min_supported_rate < min_rate_cap) {
928+ min_supported_rate = min_rate_cap;
929+ }
930+
931+ sensor[s].min_supported_rate = min_supported_rate;
932+ sensor_desc[s].maxDelay = (max_delay_t) (1000000.0 / min_supported_rate);
933+
907934 return 0;
908935 }
909936
--- a/transform.c
+++ b/transform.c
@@ -41,8 +41,6 @@
4141 #define CONVERT_M_Y (-CONVERT_M)
4242 #define CONVERT_M_Z (CONVERT_M)
4343
44-#define CONVERT_GAUSS_TO_MICROTESLA(x) ((x) * 100)
45-
4644 /* Conversion of orientation data to degree units */
4745 #define CONVERT_O (1.0 / 64)
4846 #define CONVERT_O_A (CONVERT_O)
--- a/transform.h
+++ b/transform.h
@@ -7,6 +7,9 @@
77
88 #include "common.h"
99
10+#define CONVERT_GAUSS_TO_MICROTESLA(x) ((x) * 100)
11+#define CONVERT_MICROTESLA_TO_GAUSS(x) ((x) / 100)
12+
1013 void select_transform (int s);
1114 float acquire_immediate_float_value (int s, int c);
1215 uint64_t acquire_immediate_uint64_value (int s, int c);
--- a/utils.c
+++ b/utils.c
@@ -189,33 +189,36 @@ int sysfs_read_str(const char path[PATH_MAX], char *buf, int buf_len)
189189 }
190190
191191
192-int64_t get_timestamp_realtime (void)
192+int64_t get_timestamp (clockid_t clock_id)
193193 {
194194 struct timespec ts = {0};
195- clock_gettime(CLOCK_REALTIME, &ts);
196195
197- return 1000000000LL * ts.tv_sec + ts.tv_nsec;
196+ if (!clock_gettime(clock_id, &ts))
197+ return 1000000000LL * ts.tv_sec + ts.tv_nsec;
198+ else /* in this case errno is set appropriately */
199+ return -1;
198200 }
199201
202+int64_t get_timestamp_realtime (void)
203+{
204+ return get_timestamp(CLOCK_REALTIME);
205+}
200206
201207 int64_t get_timestamp_boot (void)
202208 {
203- struct timespec ts = {0};
204- clock_gettime(CLOCK_BOOTTIME, &ts);
205-
206- return 1000000000LL * ts.tv_sec + ts.tv_nsec;
209+ return get_timestamp(CLOCK_BOOTTIME);
207210 }
208211
212+int64_t get_timestamp_thread (void)
213+{
214+ return get_timestamp(CLOCK_THREAD_CPUTIME_ID);
215+}
209216
210217 int64_t get_timestamp_monotonic (void)
211218 {
212- struct timespec ts = {0};
213- clock_gettime(CLOCK_MONOTONIC, &ts);
214-
215- return 1000000000LL * ts.tv_sec + ts.tv_nsec;
219+ return get_timestamp(CLOCK_MONOTONIC);
216220 }
217221
218-
219222 void set_timestamp (struct timespec *out, int64_t target_ns)
220223 {
221224 out->tv_sec = target_ns / 1000000000LL;
--- a/utils.h
+++ b/utils.h
@@ -21,6 +21,7 @@ int sysfs_read_uint64(const char path[PATH_MAX], uint64_t *value);
2121 void set_timestamp (struct timespec *out, int64_t target_ns);
2222
2323 int64_t get_timestamp_boot (void);
24+int64_t get_timestamp_thread (void);
2425 int64_t get_timestamp_realtime (void);
2526 int64_t get_timestamp_monotonic (void);
2627
Show on old repository browser