SensorHAL: Added ASM330LHH Android and Linux sensor Hal

#

# Copyright (C) 2013-2016 STMicroelectronics

# Denis Ciocca - Motion MEMS Product Div.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#/

ifneq ($(TARGET_SIMULATOR),true)

.PHONY: sensors-defconfig sensors-menuconfig sensors-cleanconf

CURRENT_DIRECTORY := $(call my-dir)

include $(CLEAR_VARS)

MAJOR_VERSION := $(shell echo $(PLATFORM_VERSION) | cut -f1 -d.)

MINOR_VERSION := $(shell echo $(PLATFORM_VERSION) | cut -f2 -d.)

VERSION_KK := $(shell test $(MAJOR_VERSION) -eq 4 -a $(MINOR_VERSION) -eq 4 && echo true)

VERSION_L := $(shell test $(MAJOR_VERSION) -eq 5 && echo true)

VERSION_M := $(shell test $(MAJOR_VERSION) -eq 6 && echo true)

VERSION_N := $(shell test $(MAJOR_VERSION) -eq 7 && echo true)

VERSION_O := $(shell test $(MAJOR_VERSION) -eq 8 && echo true)

ifeq ($(VERSION_KK),true)

export ST_HAL_ANDROID_VERSION=0

DEFCONFIG := android_KK_defconfig

endif # VERSION_KK

ifeq ($(VERSION_L),true)

export ST_HAL_ANDROID_VERSION=1

DEFCONFIG := android_L_defconfig

endif # VERSION_L

ifeq ($(VERSION_M),true)

export ST_HAL_ANDROID_VERSION=2

DEFCONFIG := android_M_defconfig

endif # VERSION_M

ifeq ($(VERSION_N),true)

export ST_HAL_ANDROID_VERSION=3

DEFCONFIG := android_N_defconfig

endif # VERSION_N

ifeq ($(VERSION_O),true)

export ST_HAL_ANDROID_VERSION=4

DEFCONFIG := android_O_defconfig

endif # VERSION_O

ifeq ("$(wildcard $(CURRENT_DIRECTORY)/linux/iio/events.h)","")

$(error ${\n}${\n}${\space}${\n}linux/iio/events.h file not found. Copy it from kernel source tree to linux/iio folder ${\n})

endif # KCONFIG_CONFIG_HAL

ifeq ("$(wildcard $(CURRENT_DIRECTORY)/linux/iio/types.h)","")

$(error ${\n}${\n}${\space}${\n}linux/iio/types.h file not found. Copy it from kernel source tree to linux/iio/ folder ${\n})

endif # KCONFIG_CONFIG_HAL

export KCONFIG_CONFIG_HAL=$(CURRENT_DIRECTORY)/hal_config

export ST_HAL_PATH=$(CURRENT_DIRECTORY)

define \n

endef

define \space

//////////////////////////////////////////////////////////////////

endef

configfile:

	$(if $(wildcard $(KCONFIG_CONFIG_HAL)), , $(warning ${\n}${\n}${\space}${\n}defconfig file not found. Used default one: `$(DEFCONFIG)`.${\n}${\space}${\n}) @$(MAKE) sensors-defconfig > NULL)

sensors-defconfig:

	cp $(CURRENT_DIRECTORY)/src/$(DEFCONFIG) $(KCONFIG_CONFIG_HAL)

	$(CURRENT_DIRECTORY)/tools/mkconfig $(CURRENT_DIRECTORY)/ > $(CURRENT_DIRECTORY)/configuration.h

sensors-menuconfig: configfile

	$(CURRENT_DIRECTORY)/tools/kconfig-mconf $(CURRENT_DIRECTORY)/Kconfig

	$(CURRENT_DIRECTORY)/tools/mkconfig $(CURRENT_DIRECTORY)/ > $(CURRENT_DIRECTORY)/configuration.h

sensors-cleanconf:

	$(if $(wildcard $(KCONFIG_CONFIG_HAL)), rm $(KCONFIG_CONFIG_HAL), )

	$(if $(wildcard $(KCONFIG_CONFIG_HAL).old), rm $(KCONFIG_CONFIG_HAL).old, )

	$(if $(wildcard $(CURRENT_DIRECTORY)/configuration.h), rm $(CURRENT_DIRECTORY)/configuration.h, )

ifeq ($(MAKECMDGOALS),)

MAKECMDGOALS := all_modules

endif

ifeq ($(filter sensors-defconfig sensors-menuconfig sensors-cleanconf,$(MAKECMDGOALS)),)

ifeq ("$(wildcard $(KCONFIG_CONFIG_HAL))","")

$(warning ${\n}${\n}${\space}${\n}defconfig file not found. Used default one: `$(DEFCONFIG)`.${\n}${\space}${\n})

$(shell cp $(CURRENT_DIRECTORY)/src/$(DEFCONFIG) $(KCONFIG_CONFIG_HAL))

$(shell $(CURRENT_DIRECTORY)/tools/mkconfig $(CURRENT_DIRECTORY)/ > $(CURRENT_DIRECTORY)/configuration.h)

endif # KCONFIG_CONFIG_HAL

include $(call all-makefiles-under, $(CURRENT_DIRECTORY))

endif # filter

endif # !TARGET_SIMULATOR

IDIR = -I. -I../../linux/

CC=$(CROSS_COMPILE)gcc

LD=$(CROSS_COMPILE)gcc

CFLAGS=$(IDIR) -DLOG_TAG=\"test_linux\"

LIB=-ldl -lpthread -lm -lrt

.PHONY: test_linux

all: test_linux

OBJ = $(patsubst %,$(ODIR)/%,$(_OBJ))

$(ODIR)/%.o: %.c

	$(CC) -c -o $@ $< $(CFLAGS)

test_linux: test_linux.o

	$(CC) -o $@ $^ $(CFLAGS) $(LIB)

clean:

	rm -f *.o 

/*

 * STMicroelectronics SensorHAL simple test

 *

 * Copyright 2017 STMicroelectronics Inc.

 *

 * Licensed under the Apache License, Version 2.0 (the "License").

 */

#undef ANDROID_LOG

#undef LOG_FILE

#include <asm/types.h>

#include <stdio.h>

#include <linux/limits.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <dlfcn.h>

#include <pthread.h>

#include <errno.h>

#include <signal.h>

#include <string.h>

#include <sys/wait.h>

#include <hardware/sensors.h>

#ifndef LOG_TAG

#define LOG_TAG "test_linux"

#endif

#ifdef ANDROID_LOG

#include <utils/Log.h>

#include <android/log.h>

#define tl_log(...) \

	__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)

#else /* ANDROID_LOG */

#ifdef LOG_FILE

#define LOG_FILENAME "/storage/emulated/0/test_linux.log"

#define tl_log(fmt, ...) do { \

	fprintf(logfd, "%s:%s:%s:%d > " fmt "\n", \

		    LOG_TAG, __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__); \

	} while(0);

#else /* LOG_FILE */

#define tl_log(fmt, ...) printf("%s:%s:%s:%d > " fmt "\n", \

		    LOG_TAG, __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)

#endif /* LOG_FILE */

#endif /* ANDROID_LOG */

/* Max event buffer for poll sensor */

#define BUFFER_EVENT	256

/* Defines to enable/disable sensors */

#define SENSOR_ENABLE	1

#define SENSOR_DISABLE	0

/* Translate sansor index from listo to handle */

#define HANDLE_FROM_INDEX(_i) (i + 1)

#define INVALID_HANDLE	-1

static struct sensors_module_t *hmi;

static struct hw_device_t *dev;

struct sensors_poll_device_t *poll_dev;

static struct sensor_t const* list;

static int sensor_num;

/* Path to SensorHAL in target filesystem */

static const char *hal_paths[] = {

	"/tmp/mnt/SensorHAL.so",

	"/system/vendor/lib64/hw/SensorHAL.so",

	"/system/vendor/lib/hw/SensorHAL.so",

};

static const char* types[] = {

	"Meta",

	"Acc",

	"Mag",

	"Orientation",

	"Gyro",

	"Light",

	"Press",

	"Temp",

	"Proximity",

	"Gravity",

	"Lin Acc",

	"Rot Vect",

};

/* Report sensor type in string format */

static const char *type_str(int type)

{

	int type_count = sizeof(types)/sizeof(char *);

	if (type < 0 || type >= type_count)

		return "unknown";

	return types[type];

}

static void dump_event(struct sensors_event_t *e)

{

	switch (e->type) {

	case SENSOR_TYPE_ACCELEROMETER:

		tl_log("event: x=%10.2f y=%10.2f z=%10.2f timestamp=%ld",

			e->acceleration.x, e->acceleration.y, e->acceleration.z,

			e->timestamp);

		break;

	case SENSOR_TYPE_MAGNETIC_FIELD:

		tl_log("event: x=%10.2f y=%10.2f z=%10.2f timestamp=%ld",

			e->magnetic.x, e->magnetic.y, e->magnetic.z,

			e->timestamp);

		break;

	case SENSOR_TYPE_GYROSCOPE:

		tl_log("event: x=%10.2f y=%10.2f z=%10.2f timestamp=%ld",

			e->gyro.x, e->gyro.y, e->gyro.z, e->timestamp);

		break;

	default:

		tl_log("Unhandled events %d", e->type);

		break;

	}

}

static void dump_sensor(const struct sensor_t *s)

{

	int i;

	tl_log("\nSensor List");

	for(i = 0; i < sensor_num; i++) {

		tl_log("\n\tName %s", s[i].name);

		tl_log("\tVendor %s", s[i].vendor);

		tl_log("\tHandle %d", s[i].handle);

		tl_log("\t\tType %s (%d)", type_str(s[i].type), s[i].type);

		tl_log("\t\tVersion %d", s[i].version);

		tl_log("\t\tMax Range %d", s[i].maxRange);

		tl_log("\t\tResolution %d", s[i].resolution);

		tl_log("\t\tPower %d", s[i].power);

		tl_log("\t\tMin Delay %d", s[i].minDelay);

		tl_log("\t\tFIFO Reserved Event %d", s[i].fifoReservedEventCount);

		tl_log("\t\tFIFO Max Event %d", s[i].fifoMaxEventCount);

	}

}

static int get_sensor(const struct sensor_t *s, int type,

		      struct sensor_t **sens)

{

	int i;

	for(i = 0; i < sensor_num; i++) {

		if (type == s[i].type) {

			*sens = (struct sensor_t *)&s[i];

			return HANDLE_FROM_INDEX(i);

		}

	}

	return INVALID_HANDLE;

}

static void run_sensors_poll_v0(int maxcount)

{

	int tot = 0;

	poll_dev = (struct sensors_poll_device_t *)dev;

	while (1) {

		sensors_event_t events[BUFFER_EVENT];

		int i, count;

		count = poll_dev->poll(poll_dev,

				events,

				sizeof(events)/sizeof(sensors_event_t));

		for(i = 0; i < count; i++)

			dump_event(&events[i]);

		tot += count;

		if (tot >= maxcount && maxcount != 0)

			break;

	}

}

static int sensor_set_delay(int handle, int64_t delay)

{

	return poll_dev->setDelay(poll_dev, handle, delay);

}

static int sensor_activate(int handle, int enable)

{

	return poll_dev->activate(poll_dev, handle, enable);

}

static int open_hal(char *lcl_path)

{

	void *hal;

	int err;

	const char *lh_path = NULL;

	if (!lcl_path) {

		unsigned i;

		for(i = 0; i < sizeof(hal_paths)/sizeof(const char*); i++) {

			if (!access(hal_paths[i], R_OK)) {

				lh_path = hal_paths[i];

				break;

			}

		}

		if (!lh_path) {

			fprintf(stderr, "ERROR: unable to find HAL\n");

			exit(1);

		}

	} else

		lh_path = lcl_path;

	hal = dlopen(lh_path, RTLD_NOW);

	if (!hal) {

		fprintf(stderr, "ERROR: unable to load HAL %s: %s\n", lh_path,

			dlerror());

		return -1;

	}

	hmi = dlsym(hal, HAL_MODULE_INFO_SYM_AS_STR);

	if (!hmi) {

		fprintf(stderr, "ERROR: unable to find %s entry point in HAL\n",

			HAL_MODULE_INFO_SYM_AS_STR);

		return -1;

	}

	tl_log("HAL loaded: name %s vendor %s version %d.%d id %s",

	       hmi->common.name, hmi->common.author,

	       hmi->common.version_major, hmi->common.version_minor,

	       hmi->common.id);

	err = hmi->common.methods->open((struct hw_module_t *)hmi,

					SENSORS_HARDWARE_POLL, &dev);

	if (err) {

		fprintf(stderr, "ERROR: failed to initialize HAL: %d\n", err);

		exit(1);

	}

	poll_dev = (struct sensors_poll_device_t *)dev;

	return 0;

}

int main(int argc, char **argv)

{

	int sindex = 0;

	int num_sample = 50;

	int ret;

	int handle;

	struct sensor_t *sensor = NULL;

	int test_sensor_type[] = {

		SENSOR_TYPE_ACCELEROMETER,

		SENSOR_TYPE_GYROSCOPE,

		-1,

	};

	ret = open_hal(NULL);

	if (ret) {

		fprintf(stderr, "ERROR: unable to open SensorHAL\n");

		exit(1);

	}

	sensor_num = hmi->get_sensors_list(hmi, &list);

	if (!sensor_num) {

		fprintf(stderr, "ERROR: no sensors available\n");

		exit(1);

	}

	/* Dump sensor list */

	dump_sensor(list);

	while(test_sensor_type[sindex] != -1) {

		/* Activate sensor */

		handle = get_sensor(list, test_sensor_type[sindex], &sensor);

		if (handle != INVALID_HANDLE && sensor) {

			tl_log("Activating %s sensor (handle %d)", sensor->name, handle);

			sensor_activate(handle, SENSOR_ENABLE);

			/* Start polling data */

			tl_log("Polling %s sensor (handle %d)", sensor->name, handle);

			run_sensors_poll_v0(num_sample);

			/* Deactivate sensor */

			tl_log("Deactivating %s sensor (handle %d)", sensor->name, handle);

			sensor_activate(handle, SENSOR_DISABLE);

		}

	sindex++;

	}

	return 0;

}

	Android STMicroelectronics SensorHAL Documentation

In order to correctly use Android SensorHAL, modifications at Android code

are necessaries.

Linux device drivers permissions:

	First at all, SensorHAL needs to read/write sysfs files and char devices

	of IIO drivers.

	device/{vendor}/{product}/uevent.{board}.rc file modification is mandatory,

	you can find an example in this folder with 'uevent.example.rc'.

Factory calibration option:

	If you build the HAL using Factory calibration option, modifications of

	SELinux policy are necessary in order to read/write /persist and

	/data filesystem.

	You can find an example of modifications into the folder factory_calibration.

	Those modifications will touch:

		- device/{vendor}/{product}/BoardConfig.mk (modification)

		- device/{vendor}/{product}/init.{board}.rc (modification)

		- device/{vendor}/{product}/sepolicy/file.te (modification)

		- device/{vendor}/{product}/sepolicy/file_contexts (modification)

		- device/{vendor}/{product}/sepolicy/STSensors.te (add)

Selftest tool manual:

	If you build HAL enabling Selftest functions, an executable will be

	available and installed into /system/bin/STSensor_selftest.

	Using this binaty you will be able to execute easly selftest,

	based only on Android sensor handle. No information about device

	driver will be used.

	You can run binary directly in your device using adb shell. All sensors

	must be switched off in order to execute the test.

# Add STSensors.te SELinux policy

BOARD_SEPOLICY_UNION += \

       STSensors.te