text: /*!
   * @section LICENSE
   *
   * (C) Copyright 2011~2014 Bosch Sensortec GmbH All Rights Reserved
   *
   * 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.
   *
   *------------------------------------------------------------------------------
   *  Disclaimer
   *
   * Common: Bosch Sensortec products are developed for the consumer goods
   * industry. They may only be used within the parameters of the respective valid
   * product data sheet.  Bosch Sensortec products are provided with the express
   * understanding that there is no warranty of fitness for a particular purpose.
   * They are not fit for use in life-sustaining, safety or security sensitive
   * systems or any system or device that may lead to bodily harm or property
   * damage if the system or device malfunctions. In addition, Bosch Sensortec
   * products are not fit for use in products which interact with motor vehicle
   * systems.  The resale and/or use of products are at the purchaser's own risk
   * and his own responsibility. The examination of fitness for the intended use
   * is the sole responsibility of the Purchaser.
   *
   * The purchaser shall indemnify Bosch Sensortec from all third party claims,
   * including any claims for incidental, or consequential damages, arising from
   * any product use not covered by the parameters of the respective valid product
   * data sheet or not approved by Bosch Sensortec and reimburse Bosch Sensortec
   * for all costs in connection with such claims.
   *
   * The purchaser must monitor the market for the purchased products,
   * particularly with regard to product safety and inform Bosch Sensortec without
   * delay of all security relevant incidents.
   *
   * Engineering Samples are marked with an asterisk (*) or (e). Samples may vary
   * from the valid technical specifications of the product series. They are
   * therefore not intended or fit for resale to third parties or for use in end
   * products. Their sole purpose is internal client testing. The testing of an
   * engineering sample may in no way replace the testing of a product series.
   * Bosch Sensortec assumes no liability for the use of engineering samples. By
   * accepting the engineering samples, the Purchaser agrees to indemnify Bosch
   * Sensortec from all claims arising from the use of engineering samples.
   *
   * Special: This software module (hereinafter called "Software") and any
   * information on application-sheets (hereinafter called "Information") is
   * provided free of charge for the sole purpose to support your application
   * work. The Software and Information is subject to the following terms and
   * conditions:
   *
   * The Software is specifically designed for the exclusive use for Bosch
   * Sensortec products by personnel who have special experience and training. Do
   * not use this Software if you do not have the proper experience or training.
   *
   * This Software package is provided `` as is `` and without any expressed or
   * implied warranties, including without limitation, the implied warranties of
   * merchantability and fitness for a particular purpose.
   *
   * Bosch Sensortec and their representatives and agents deny any liability for
   * the functional impairment of this Software in terms of fitness, performance
   * and safety. Bosch Sensortec and their representatives and agents shall not be
   * liable for any direct or indirect damages or injury, except as otherwise
   * stipulated in mandatory applicable law.
   *
   * The Information provided is believed to be accurate and reliable. Bosch
   * Sensortec assumes no responsibility for the consequences of use of such
   * Information nor for any infringement of patents or other rights of third
   * parties which may result from its use.
   *
   * @file         channel.h
   * @date         "Thu Mar 6 17:47:08 2014 +0800"
   * @commit       "09631c4"
   *
   * @brief
   *
   * @detail
   *
   */
  
  #ifndef __CHANNEL_H
  #define __CHANNEL_H
  
  #include <unistd.h>
  
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/ioctl.h>
  
  #include <linux/fs.h>
  
  #include <fcntl.h>
  #include <signal.h>
  #include <pthread.h>
  
  #include <errno.h>
  #include <stdlib.h>
  #include <stdio.h>
  #include <stdint.h>
  
  #include "configure.h"
  #include "options.h"
  
  #include "util_misc.h"
  
  #define INTV_PROC_MIN 5
  
  enum CHANNEL_STATE {
  	CHANNEL_STATE_SLEEP = 0,
  	CHANNEL_STATE_NORMAL,
  	CHANNEL_STATE_BG,
  };
  
  
  struct channel_cfg {
  	/* sensor provider */
  	char const *sp_name;
  
  	uint16_t availability:3;
  	/* deprecated, not used any more */
  	uint16_t calib_bg:1;
  	/* set to 1 if the delay makes no sense for
  	 * this sensor, e.g.: proximity, light sensors etc
  	 */
  	uint16_t no_delay:1;
  
  	/* channel does not need processing of
  	 * data by sensor_provider, i.e.: sp only
  	 * acts as an HW manager
  	 */
  	uint16_t bypass_proc:1;
  
  	/* NOTE: limitations */
  	uint16_t interval_min;
  	/* NOTE: limitations */
  	uint16_t interval_max;
  
  	/* deprecated, not used any more */
  	hw_dep_set_t dep_hw;
  };
  
  
  struct channel {
  	const char const *name;
  	/* NOTE: limitations */
  	const int32_t type;
  	/* id which identify a channel uniquely */
  	const int8_t handle;
  
  	struct channel_cfg cfg;
  
  	volatile int32_t prev_state:4;
  	volatile int32_t state:4;
  
  	/* deprecated */
  	int32_t data_status:4;
  	/* NOTE: limitations */
  	volatile int16_t interval;
  
  	/* NOTE: limitations */
  	uint32_t ts_last_ev;
  
  	struct sensor_provider *sp;
  	void *private_data;
  	struct list_node client;
  	pthread_mutex_t lock_state;
  
  	/* mandatory: */
  	int (*init)(struct channel *);
  	/* optional: enable algorithm support */
  	int (*enable)(struct channel *, int);
  	/* optional: */
  	void (*exit)();
  	/* mandatory: function to fetch output data from its sensor provider */
  	int (*get_data)(void *, int);
  	/* some sensors might be enabled multiple times */
  	/* optional */
  };
  
  
  struct data_filter {
  	/* returns the valid data which is put in @out */
  	int (*filter)(struct data_filter *df,
  			const void *in, int len_in, void *out, int len_out);
  
  	void *private_data;
  };
  
  extern int channel_cntl_init();
  int channel_get_handle_list(int8_t *p_list, int32_t size);
  extern void channel_cntl_destroy();
  extern int channel_get_state(int handle);
  extern int channel_get_cfg(int handle, struct channel_cfg *cfg);
  extern int channel_set_cfg(int handle, const struct channel_cfg *cfg);
  
  extern void channel_cntl_dump();
  
  extern int channel_init_a(struct channel *);
  extern void channel_destroy_a();
  extern int get_data_a(void *buf, int n);	/* acceleration */
  extern int channel_enable_a(int);
  extern void on_interval_changed_a(int *);
  
  extern int channel_init_g(struct channel *);
  extern void channel_destroy_g();
  extern int get_data_g(void *buf, int n);	/* gyro */
  extern int channel_enable_g(int);
  extern void on_interval_changed_g(int *);
  
  extern int channel_init_m(struct channel *);
  extern void channel_destroy_m();
  extern int get_data_m(void *buf, int n);	/* magnetic */
  extern int channel_enable_m(int);
  extern void on_interval_changed_m(int *);
  
  extern int channel_init_o(struct channel *);
  extern void channel_destroy_o();
  extern int get_data_o(void *buf, int n);	/* orientation */
  extern void on_interval_changed_o(int *);
  extern int channel_enable_o(int);
  
  extern int channel_init_vg(struct channel *);
  extern void channel_destroy_vg();
  extern int get_data_vg(void *buf, int n);	/* gravity */
  extern int channel_enable_vg(int);
  extern void on_interval_changed_vg(int *);
  
  extern int channel_init_vla(struct channel *);
  extern void channel_destroy_vla();
  extern int get_data_vla(void *buf, int n);	/* linear acc */
  extern int channel_enable_vla(int);
  extern void on_interval_changed_vla(int *);
  
  extern int channel_init_vrv(struct channel *);
  extern void channel_destroy_vrv();
  extern int get_data_vrv(void *buf, int n);	/* rotation vector */
  extern int channel_enable_vrv(int);
  extern void on_interval_changed_vrv(int *);
  
  #ifdef __FLIP_GESTURE__
  /* gesture flip vector */
  int channel_gest_flip_init(struct channel *ch);
  int channel_gest_flip_get_data(void *pbuf, int n);
  int channel_gest_flip_enable(struct channel *ch, int en);
  #endif
  
  #ifdef __UNCALIBRATED_VIRTUAL_SENSOR_SUPPORT__
  extern int channel_init_grv(struct channel *);
  extern int get_data_grv(void *buf, int n);
  extern int channel_init_gu(struct channel *);
  extern int get_data_gu(void *buf, int n);
  extern int channel_init_mu(struct channel *);
  extern int get_data_mu(void *buf, int n);
  #endif
  
  #if __HAL_VER__ >= __SENSORS_DEVICE_API_VERSION_1_1__
  extern int channel_init_geom_rv(struct channel *);
  extern int get_data_geom_rv(void *buf, int n);
  #endif
  
  #if __HAL_VER__ >= __SENSORS_DEVICE_API_VERSION_1_0__
  extern int channel_init_stc(struct channel *);
  extern int get_data_stc(void *buf, int n);
  extern int channel_stc_enable(struct channel *ch, int en);
  
  extern int channel_init_std(struct channel *);
  extern int get_data_std(void *buf, int n);
  extern int channel_std_enable(struct channel *ch, int en);
  
  #endif
  
  extern int channel_sgm_init(struct channel *);
  extern int channel_sgm_get_data(void *buf, int n);
  extern int channel_sgm_enable(struct channel *ch, int en);
  
  
  
  void fusion_proc_data(uint32_t ts);
  int get_hint_interval_fusion();
  
  
  int channel_get_num();
  struct channel *channel_get_ch(int handle);
  #endif
  