working on framepars

#ifndef _FRAMEPARS_H

#define _FRAMEPARS_H

#ifndef SENSOR_PORTS

	#include <elphel/c313a.h> // to get SENSOR_PORTS

#endif

//extern struct framepars_t (*framepars)[PARS_FRAMES];

extern struct framepars_t      *framepars;

extern struct framepars_past_t *pastpars;

extern unsigned long           *globalPars;

extern unsigned long           *multiSensIndex;

extern unsigned long           *multiSensRvrsIndex;

extern struct framepars_t      *aframepars[SENSOR_PORTS];

extern struct framepars_past_t *apastpars[SENSOR_PORTS];

extern unsigned long           *aglobalPars[SENSOR_PORTS];

extern unsigned long           *amultiSensIndex[SENSOR_PORTS];

extern unsigned long           *amultiSensRvrsIndex[SENSOR_PORTS];

extern wait_queue_head_t        framepars_wait_queue[SENSOR_PORTS];

extern wait_queue_head_t framepars_wait_queue;

///TODO: init framepars (zero parameters) before initscripts (not when detecting the sensors) - then initscript will be able to overwrite some

void init_framepars_ptr(void);

void initSequencers(void);         ///Move to sensorcommon? currently it is used through frameparsall file (lseek)

void initGlobalPars(void);   /// resets all global parameters but debug mask (if ELPHEL_DEBUG)

int  initMultiPars(void);  /// initialize structures for individual per-sensor parameters. Now only works for sensor registers using G_MULTI_REGSM. Should be called aftre/during sensor detection

void initFramePars(void);    ///initialize all parameters, set thisFrameNumber to frame8 (read from hardware, usually 0 after resetting i2c and cmd_seq)

void resetFrameNumber(void); /// reset this frame number (called from initFramePars(), also can be used to avoid frame number integer overflow)

void init_framepars_ptr(int sensor_port);

void initSequencers    (int sensor_port); ///Move to sensorcommon? currently it is used through frameparsall file (lseek)

void initGlobalPars    (int sensor_port); /// resets all global parameters but debug mask (if ELPHEL_DEBUG)

int  initMultiPars     (int sensor_port); /// initialize structures for individual per-sensor parameters. Now only works for sensor registers using G_MULTI_REGSM. Should be called aftre/during sensor detection

void initFramePars     (int sensor_port); ///initialize all parameters, set thisFrameNumber to frame8 (read from hardware, usually 0 after resetting i2c and cmd_seq)

void resetFrameNumber  (int sensor_port); /// reset this frame number (called from initFramePars(), also can be used to avoid frame number integer overflow)

unsigned long get_imageParamsThis (int n);

unsigned long get_imageParamsPrev (int n);

unsigned long get_imageParamsThis (int sensor_port, int n);

unsigned long get_imageParamsPrev (int sensor_port, int n);

void          set_imageParamsThis (int n,unsigned long d);

unsigned long get_globalParam     (int n);

void          set_imageParamsThis (int sensor_port, int n, unsigned long d);

unsigned long get_globalParam     (int sensor_port, int n);

void          set_globalParam   (int n, unsigned long d);

void          set_imageParamsR_all(int n, unsigned long d);

void update_frame_pars(void);

void updateFramePars(int frame8, struct interframe_params_t * frame_pars); /// called from ISR - advance thisFrameNumber to match hardware frame8, copy parameters as needed.

void          set_globalParam     (int sensor_port, int n, unsigned long d);

void          set_imageParamsR_all(int sensor_port, int n, unsigned long d);

void          updateFramePars     (int sensor_port, int frame8, struct interframe_params_t * frame_pars); /// called from ISR - advance thisFrameNumber to match hardware frame8, copy parameters as needed.

                                   /// frame8 usually is just next after thisFrameNumber

                                   /// frame_pars - pointer to structure (between frames in the frame buffer) to save a pointer to past parameters

int setFrameParsStatic(int numPars, struct frameparspair_t * pars);

int           setFrameParsStatic  (int sensor_port, int numPars, struct frameparspair_t * pars);

unsigned long getThisFrameNumber(void); /// just return current thisFrameNumber

unsigned long getThisFrameNumber  (int sensor_port); /// just return current thisFrameNumber

/// set parameters for the frame number frameno, knowing that they should be set not less than maxLatency ahead (may be sensor - dependent)

/// Parameters (numPars of them) will be updated all at once, with interrupts disabled

/// Return - 0 if OK, -ERR_FRAMEPARS_TOOEARLY or -ERR_FRAMEPARS_TOOLATE if it is too early or too late to set parameters (numPars may be 0 to just test)

/// TODO: Make (an "unlimited") future commands que based on lists and a tree frame index

int setFrameParsAtomic(unsigned long frameno, int maxLatency, int numPars, struct frameparspair_t * pars);

int setFrameParsAtomic            (int sensor_port, unsigned long frameno, int maxLatency, int numPars, struct frameparspair_t * pars);

/// set output/calculated parameter and propogate changes - will not trigger any actions

int setFramePar(struct framepars_t * this_framepars, unsigned long mindex, unsigned long val);

/// set output/calculated parameter and propagate changes - will not trigger any actions

int setFramePar                   (int sensor_port, struct framepars_t * this_framepars, unsigned long mindex, unsigned long val);

///same for several pars at once

int setFramePars(struct framepars_t * this_framepars, int numPars, struct frameparspair_t * pars);

int setFramePars                  (int sensor_port, struct framepars_t * this_framepars, int numPars, struct frameparspair_t * pars);

/// schedule pgm_func to be executed for selected frame

void schedule_pgm_func(int frame8, int func_num);

void schedule_pgm_func            (int sensor_port, int frame8, int func_num);

/// schedule pgm_func to be executed for the current frame

void schedule_this_pgm_func(struct framepars_t * this_framepars, int func_num);

void schedule_this_pgm_func       (int sensor_port, struct framepars_t * this_framepars, int func_num);

/// program acquisition, according to the parameters changed.

/// maxahead - how many frames ahead of time (start with most urgent, then 1 ahead, ...)

/// make maxahead - P_* parameter?

inline void processParsASAP (struct sensorproc_t * sensorproc, int frame8);

inline void processParsSeq (struct sensorproc_t * sensorproc, int frame8, int maxahead);

/* 393: See if sesnor port is needed here */

inline void processParsASAP      (int sensor_port, struct sensorproc_t * sensorproc, int frame8);

inline void processParsSeq       (int sensor_port, struct sensorproc_t * sensorproc, int frame8, int maxahead);

void processPars (struct sensorproc_t * sensorproc, int frame8, int maxahead);

void        processPars          (int sensor_port, struct sensorproc_t * sensorproc, int frame8, int maxahead);

///*** TODO: Add option (flag?) to write "single" (like single compress, single sensor) so it will not make all the next frames "single"

int         framepars_init       (struct platform_device *pdev);

 #define EDBG(x)

#endif

#define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))

// _IOC_TYPE, bits 8 to 15 in ioctl cmd

#define SENSORWIDTH_IBIS51300  1280

#define SENSORHEIGHT_IBIS51300 1024

/// Parameters related to multi-sensor (10359A) setup

#define MAX_SENSORS 3 // maximal number of sensor attached (modify some hard-wired constants below if this to be changed)

//! Parameters below are accessed through mmap, because of cache coherency problem it make sense to keep them compact (maybe group by 8 - cache line of 32 bytes)

//#define MAX_SENSORS 3 // maximal number of sensor attached (modify some hard-wired constants below if this to be changed)

/* Modified for 393 - using up to 4 sub-sensors (even as 10359 only supports 3 */

#define MAX_SENSORS  4        // maximal number of sensor attached (modify some hard-wired constants below if this to be changed)

#define SENSOR_PORTS 4        // Number of sensor ports (each has individual framepars_all_t

//! Parameters below are accessed through mmap, because of cache coherence problem it make sense to keep them compact (maybe group by 8 - cache line of 32 bytes)

#define P_SENSOR_RUN     4 // 0 - stop, 1 - single, 2 - run

  #define SENSOR_RUN_STOP   0

  #define SENSOR_RUN_SINGLE 1

#define P_MULTI_REGS          (P_M10359_REGS + P_M10359_NUMREGS) /// 32-words aligned

#define P_MAX_PAR         (P_MULTI_REGS + (MAX_SENSORS * P_MULTI_NUMREGS )) /// maximal # of used parameter+1

/* 393: Making P_MAX_PAR multiple of PAGE_SIZE/2, so framepars_all_t will be multiple of PAGE_SIZE*/

#ifndef PAGE_SIZE

	#define PAGE_SIZE 4096 // not using <asm/page.h> as this file may be used outside of kernel

#endif

#define P_MAX_PAR_ROUNDUP ROUND_UP (P_MAX_PAR , (PAGE_SIZE/8)) // half page in DWORDs

#ifdef SAFE_CHECK

  #define MULTIREG(x,n) ((((n)>=0) && ((n)<MAX_SENSORS) && ((x) >0) && ((x) < P_MAX_PAR) && (multiSensIndex[x] > 0))? (multiSensIndex[x]+(n)) : 0)

#else

//#define P_MAX_PAR        511 /// maximal # of used parameter

//#define P_MAX_GPAR      1023 // maximal # of global parameter

#define P_MAX_GPAR      2047 /// maximal # of global parameter - TODO: change name to NUM_GPAR and make it 2048

//#define P_MAX_GPAR      2047 /// maximal # of global parameter - TODO: change name to NUM_GPAR and make it 2048

#define NUM_GPAR        2048           /// maximal # of global parameter - TODO: change name to NUM_GPAR and make it 2048

#define P_MAX_GPAR      (NUM_GPAR - 1) /// maximal # of global parameter - TODO: change name to NUM_GPAR and make it 2048

#define PARS_SAVE_FROM   128 /// PARS_SAVE_NUM parameters starting from PARS_SAVE_FROM from "this" frame will be saved in circular buffer, PASTPARS_SAVE_ENTRIES entries

#define PARS_SAVE_COPY    16 /// number of parameters copied from future (framepars) to the past (pastpars)

#define GLOBALS_PRESERVE   0x20     /// number of parameters that are not erased during initGlobalPars

/// First 32 parameter values are not erased with initGlobalPars

#define GLOBALPARS(x) globalPars[(x)-FRAMEPAR_GLOBALS] // should work in drivers and applications

#define GLOBALPARS(p, x) (aglobalPars[p][(x)-FRAMEPAR_GLOBALS]) // should work in drivers and applications

#define G_DEBUG         (FRAMEPAR_GLOBALS + 2) /// Each bit turns on/off some debug outputs

#define G_TEST_CTL_BITS (FRAMEPAR_GLOBALS + 3) /// turn some features on/off in the drivers for debugging purposes

/// when the 3-bit counter is combined with the software variable to get the full 32-bit frame number

/// Each parameter page includes 927 parameter registers, as well as 97 bitmasks to speed up updates between frames

/// So if no parameters are changed - nothing to be copied from page to page

#define PARS_FRAMES                                  8      // number of frames handled in buffer

#define PARS_FRAMES_MASK     (PARS_FRAMES-1)               // currently 7

#define PASTPARS_SAVE_ENTRIES       (PARS_FRAMES << 8)     // 2048

#define PASTPARS_SAVE_ENTRIES_MASK ((PARS_FRAMES << 8)-1)  // 0x7ff

/* Modified for 393 : 16 hardware frames, aligning framepars_all_t to PAGE_SIZE*/

#define PARS_FRAMES                                  16 //    8      // number of frames handled in buffer

#define PARS_FRAMES_MASK     (PARS_FRAMES-1)               // currently 15t // 7

// Keeping the same size of past frames storage as in 353:

//#define PASTPARS_SAVE_ENTRIES       (PARS_FRAMES << 8)     // 2048

//#define PASTPARS_SAVE_ENTRIES_MASK ((PARS_FRAMES << 8)-1)  // 0x7ff

#define PASTPARS_SAVE_ENTRIES       (PARS_FRAMES << 7)     // 2048

#define PASTPARS_SAVE_ENTRIES_MASK ((PARS_FRAMES << 7)-1)  // 0x7ff

struct framepars_t {

        unsigned long pars[927];      // parameter values (indexed by P_* constants)

        unsigned long functions;      // each bit specifies function to be executed (triggered by some parameters change)

    unsigned long past_pars[PARS_SAVE_NUM];

};

// size should be PAGE_SIZE aligned

struct framepars_all_t {

    struct framepars_t      framePars[PARS_FRAMES];

    struct framepars_t      func2call;                             /// func2call.pars[] - each parameter has a 32-bit mask of what pgm_function to call - other fields not used

     unsigned long          globalPars[P_MAX_GPAR]; /// parameters that are not frame-related, their changes do not initiate any actions so they can be mmaped for both R/W

     unsigned long          globalPars[NUM_GPAR];                  /// parameters that are not frame-related, their changes do not initiate any actions so they can be mmaped for both R/W

    struct framepars_past_t pastPars [PASTPARS_SAVE_ENTRIES];

     unsigned long          multiSensIndex[P_MAX_PAR];     /// indexes of individual sensor register shadows (first of 3) - now for all parameters, not just sensor ones

     unsigned long          multiSensRvrsIndex[P_MAX_PAR]; /// reverse index (to parent) for the multiSensIndex in lower 16 bits, high 16 bits - sensor number

     unsigned long          multiSensIndex[P_MAX_PAR_ROUNDUP];     /// indexes of individual sensor register shadows (first of 3) - now for all parameters, not just sensor ones

     unsigned long          multiSensRvrsIndex[P_MAX_PAR_ROUNDUP]; /// reverse index (to parent) for the multiSensIndex in lower 16 bits, high 16 bits - sensor number

};

struct frameparspair_t {

#define HISTOGRAM_TABLE_OFFSET 52 /// Histogram tables data starts 44 bytes from the histogram page structure (for PHP raw histogram)

///TODO: Update when histogram_stuct_t is changed

struct histogram_stuct_t {

   unsigned long frame;                /// frame number correspoding to the current histogram

   unsigned long frame;                /// frame number corresponding to the current histogram

/// Color gains for the frame of the histogram

   union {

       unsigned long gains[4];

#define HUFFMAN_MINOR_CHN_2       0x42

#define HUFFMAN_MINOR_CHN_3       0x43

#define CMOSCAM_MINOR_FRAMEPARS_CHN_0  0x50

#define CMOSCAM_MINOR_FRAMEPARS_CHN_1  0x51

#define CMOSCAM_MINOR_FRAMEPARS_CHN_2  0x52

#define CMOSCAM_MINOR_FRAMEPARS_CHN_3  0x53

#define CMOSCAM_MINOR_RWTABLES    9

#define CMOSCAM_MINOR_CIRCBUF    11

#define CMOSCAM_MINOR_HISTOGRAM  12