os/linux-2.6-tag--devboard-R2_10-4/arch/cris/arch-v32/drivers/elphel/framepars.c

Go to the documentation of this file.

/*!********************************************************************************
*! FILE NAME  : framepars.c
*! DESCRIPTION: Handling of frame parameters, making use of FPGA i2c
*! and command sequencer that accepts commands up to 6 frames ahead.
*! This module includes parameter storage, code called from ISR,
*! from other kernel drivers as well as from the user space
*! Copyright (C) 2008 Elphel, Inc.
*! -----------------------------------------------------------------------------**
*!
*!  This program is free software: you can redistribute it and/or modify
*!  it under the terms of the GNU General Public License as published by
*!  the Free Software Foundation, either version 3 of the License, or
*!  (at your option) any later version.
*!
*!  This program is distributed in the hope that it will be useful,
*!  but WITHOUT ANY WARRANTY; without even the implied warranty of
*!  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*!  GNU General Public License for more details.
*!senssensor_common.hor_common.h
*!  You should have received a copy of the GNU General Public License
*!  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*! -----------------------------------------------------------------------------**
*!  $Log: framepars.c,v $
*!  Revision 1.1.1.1  2008/11/27 20:04:00  elphel
*!
*!
*!  Revision 1.41  2008/11/17 06:42:37  elphel
*!  added SETFRAMEREL - skipping specified number of frames from current (through lseek)
*!
*!  Revision 1.40  2008/11/14 07:09:48  elphel
*!  additional test to prevent "JUST_THIS" parameters to be written to the future-most frame (otherwise it can get stuck)
*!
*!  Revision 1.39  2008/11/13 05:40:45  elphel
*!  8.0.alpha16 - modified histogram storage, profiling
*!
*!  Revision 1.38  2008/11/05 02:01:25  elphel
*!  Added bit field manipulation in parameters
*!
*!  Revision 1.37  2008/11/02 00:31:25  elphel
*!  reduced required initialization steps
*!
*!  Revision 1.36  2008/10/29 04:18:28  elphel
*!  v.8.0.alpha10 made a separate structure for global parameters (not related to particular frames in a frame queue)
*!
*!  Revision 1.35  2008/10/25 19:59:48  elphel
*!  added lseek() calls to enable/disable daemons at events (compressed frame available, any frame available, histogram-Y and histograms-C available)
*!
*!  Revision 1.34  2008/10/23 18:25:40  elphel
*!  removed unneeded test condition before calling wait_event_interruptible()
*!
*!  Revision 1.33  2008/10/23 08:03:38  elphel
*!  cleanup
*!
*!  Revision 1.32  2008/10/21 21:28:26  elphel
*!  minor bug fix
*!
*!  Revision 1.31  2008/10/20 18:46:36  elphel
*!  all the functions for the same target frame are processed in the order regardless of latencies
*!
*!  Revision 1.30  2008/10/19 06:51:51  elphel
*!  rearranged initialization, added frame number reset (to avoid unlikely integer overflow)
*!
*!  Revision 1.29  2008/10/17 05:44:48  elphel
*!  fixing latencies
*!
*!  Revision 1.28  2008/10/15 22:28:56  elphel
*!  snapshot 8.0.alpha2
*!
*!  Revision 1.27  2008/10/12 06:13:10  elphel
*!  snapshot
*!
*!  Revision 1.26  2008/10/11 18:46:07  elphel
*!  snapshot
*!
*!  Revision 1.25  2008/10/10 17:06:59  elphel
*!  just a snapshot
*!
*!  Revision 1.24  2008/10/08 21:26:25  elphel
*!  snapsot 7.2.0.pre4 - first images (actually - second)
*!
*!  Revision 1.23  2008/10/06 08:31:08  elphel
*!  snapshot, first images
*!
*!  Revision 1.22  2008/10/05 05:13:33  elphel
*!  snapshot003
*!
*!  Revision 1.21  2008/10/04 16:10:12  elphel
*!  snapshot
*!
*!  Revision 1.20  2008/09/28 00:31:57  elphel
*!  snapshot
*!
*!  Revision 1.19  2008/09/25 00:58:11  elphel
*!  snapshot
*!
*!  Revision 1.18  2008/09/20 00:29:50  elphel
*!  moved driver major/minor numbers to a single file - include/asm-cris/elphel/driver_numbers.h
*!
*!  Revision 1.17  2008/09/19 04:37:25  elphel
*!  snapshot
*!
*!  Revision 1.16  2008/09/16 00:49:31  elphel
*!  snapshot
*!
*!  Revision 1.15  2008/09/12 20:40:11  elphel
*!  snapshot
*!
*!  Revision 1.14  2008/09/12 00:28:54  elphel
*!  typo fixed
*!
*!  Revision 1.13  2008/09/12 00:23:59  elphel
*!  removed cc353.c, cc353.h
*!
*!  Revision 1.12  2008/09/07 19:48:08  elphel
*!  snapshot
*!
*!  Revision 1.11  2008/09/05 23:20:26  elphel
*!  just a snapshot
*!
*!  Revision 1.10  2008/09/04 17:37:13  elphel
*!  documenting
*!
*!  Revision 1.9  2008/09/02 21:01:06  elphel
*!  just next...
*!
*!  Revision 1.8  2008/07/27 04:27:49  elphel
*!  next snapshot
*!
*!  Revision 1.7  2008/06/24 00:43:44  elphel
*!  just a snapshot
*!
*!  Revision 1.6  2008/06/20 03:54:19  elphel
*!  another snapshot
*!
*!  Revision 1.5  2008/06/19 02:17:36  elphel
*!  continuing work - just a snapshot
*!
*!  Revision 1.4  2008/06/16 06:51:21  elphel
*!  work in progress, intermediate commit
*!
*!  Revision 1.3  2008/06/10 00:03:14  elphel
*!  storing past frame data - subset of the frame parameters
*!
*!  Revision 1.2  2008/06/08 23:48:39  elphel
*!  minor cleanup
*!
*!  Revision 1.1  2008/05/26 23:33:00  elphel
*!  Added driver to handle multi-frame parameters
*!
*!
*/

//copied from cxi2c.c - TODO:remove unneeded


#include <linux/types.h> 
#include <asm/div64.h>  


#include <linux/module.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/autoconf.h>
#include <linux/vmalloc.h>

#include <asm/system.h>
#include <asm/byteorder.h> // endians
#include <asm/io.h>

#include <asm/irq.h>

#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm/elphel/driver_numbers.h>
#include <asm/elphel/c313a.h>
#include <asm/elphel/exifa.h>
#include "fpgactrl.h"  // defines port_csp0_adsensor_common.hdr, port_csp4_addr 
//#include "cc3x3.h"
#include "x3x3.h"           // hardware definitions


#include "sensor_common.h"
#include "framepars.h"
#include "param_depend.h" // specifies what functions should be called for different parameters changed
#include "cxdma.h" // x313_dma_init

#if ELPHEL_DEBUG
 #define MDF(x) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;}
 #define MDF2(x) { if (GLOBALPARS(G_DEBUG) & (1 <<2)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
 #define MDF5(x) { if (GLOBALPARS(G_DEBUG) & (1 <<5)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
 #define   D5(x) { if (GLOBALPARS(G_DEBUG) & (1 <<5)) {x ;} }
 #define MDF6(x) { if (GLOBALPARS(G_DEBUG) & (1 <<6)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
 #define   D6(x) { if (GLOBALPARS(G_DEBUG) & (1 <<6)) {x ;} }
 #define MDF7(x) { if (GLOBALPARS(G_DEBUG) & (1 <<7)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
 #define   D7(x) { if (GLOBALPARS(G_DEBUG) & (1 <<7)) {x ;} }
 #define MDF8(x) { if (GLOBALPARS(G_DEBUG) & (1 <<8)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
 #define   D8(x) { if (GLOBALPARS(G_DEBUG) & (1 <<8)) {x ;} }
 #define ELPHEL_DEBUG_THIS 0
// #define ELPHEL_DEBUG_THIS 1
#else
 #define MDF(x)
 #define MDF2(x)
 #define MDF5(x)
 #define D5(x)
 #define MDF6(x)
 #define D6(x)
 #define MDF7(x)
 #define D7(x)
 #define ELPHEL_DEBUG_THIS 0
#endif


#if ELPHEL_DEBUG_THIS
  #define MDD1(x) printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__); x ; udelay (ELPHEL_DEBUG_DELAY)
  #define MDF1(x) printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__); x
  #define D1(x) x
  #define D1I(x)

#else
  #define MDD1(x)
  #define MDF1(x)
  #define D1(x)
  #define D1I(x) x
#endif
//#define ELP_KERR(x) printk("%s:%d:%s: ERROR ",__FILE__,__LINE__,__FUNCTION__); x

#define  X3X3_FRAMEPARS_DRIVER_NAME "Elphel (R) Model 353 Frame Parameters device driver"

static struct framepars_all_t sFrameParsAll __attribute__ ((aligned (PAGE_SIZE)));   
unsigned long frameParsInitialized; 
#define  thisFrameNumber GLOBALPARS(G_THIS_FRAME) // Current frame number (may lag from the hardware)
#define  THISFRAMENUMBER GLOBALPARS(G_THIS_FRAME) // Current frame number (may lag from the hardware)

struct framepars_all_t  *frameparsall=NULL; 
struct framepars_t      *framepars=   NULL; 
struct framepars_past_t *pastpars=    NULL; 
unsigned long           *funcs2call=  NULL; 
unsigned long           *globalPars=  NULL; 

wait_queue_head_t framepars_wait_queue; 


struct framepars_pd {
    int                minor; 
    struct wait_queue *framepars_wait_queue; 
// something else to be added here?
};



void init_framepars_ptr(void) {
    frameparsall=&sFrameParsAll; 
    framepars = sFrameParsAll.framePars;
    pastpars =  sFrameParsAll.pastPars;
    funcs2call =sFrameParsAll.func2call.pars; 
    globalPars =sFrameParsAll.globalPars; 
}

int        framepars_open   (struct inode *inode, struct file *filp);
int        framepars_release(struct inode *inode, struct file *filp);
loff_t     framepars_lseek  (struct file * file, loff_t offset, int orig);
ssize_t    framepars_write  (struct file * file, const char * buf, size_t count, loff_t *off);
int        framepars_mmap   (struct file *file, struct vm_area_struct *vma);
static int __init framepars_init(void);

void initSequencers(void) {
  MDF2(printk ("\n"));
  X3X3_SEQ_RESET;
  X3X3_I2C_RESET_WAIT;
  initFramePars();
}


void resetFrameNumber(void) {
   int i;
   thisFrameNumber= X3X3_I2C_FRAME;
  MDF2(printk ("\n"));
// write absolute frame numbers
   for (i=thisFrameNumber; i<(thisFrameNumber+PARS_FRAMES); i++) framepars[i & PARS_FRAMES_MASK].pars[P_FRAME]=i;
}

void initFramePars(void) {
   int i;
   memset(framepars, 0, sizeof(framepars));
   resetFrameNumber();
   for (i=0; i < (sizeof(param_depend_tab)/8); i++) funcs2call[param_depend_tab[2*i]]=param_depend_tab[2*i+1];
   for (i=0; i < P_SENSOR_NUMREGS; i++)    funcs2call[P_SENSOR_REGS+i] = ONCHANGE_SENSORREGS; 
   frameParsInitialized=1;
}

void initGlobalPars(void) {
   memset(globalPars, 0, sizeof(globalPars));
   MDF(GLOBALPARS(G_DEBUG) = ELPHEL_DEBUG_STARTUP; printk("GLOBALPARS(G_DEBUG)=%lx\n",GLOBALPARS(G_DEBUG)));
}


inline unsigned long get_imageParamsThis    (int n) {
   return framepars[thisFrameNumber & PARS_FRAMES_MASK].pars[n] ;
}

inline unsigned long get_imageParamsPrev    (int n) {
   return framepars[(thisFrameNumber-1) & PARS_FRAMES_MASK].pars[n] ;
}

inline void set_imageParamsThis    (int n,unsigned long d) {
   framepars[thisFrameNumber & PARS_FRAMES_MASK].pars[n]=d ;
}

inline unsigned long get_globalParam  (int n) {
   return GLOBALPARS(n) ;
}
inline void          set_globalParam   (int n, unsigned long d) {
  GLOBALPARS(n)=d;
}

inline void          set_imageParamsR_all(int n, unsigned long d) {
  int i;
  for (i=0; i < PARS_FRAMES; i++) framepars[i].pars[n]=d;
}


void updateFramePars(int frame8, struct interframe_params_t * interframe_pars) {
  int findex_this,findex_prev,findex_future,findex_next;
  int index,index32;
  unsigned long bmask, bmask32;
  int pastParsIndex;
  while ((frame8 ^ thisFrameNumber) & PARS_FRAMES_MASK) {
    findex_this=  thisFrameNumber  & PARS_FRAMES_MASK;
    findex_prev=  (findex_this-1)  & PARS_FRAMES_MASK;
    findex_future= (findex_this-2)  & PARS_FRAMES_MASK; // farthest in the future
    findex_next=  (findex_this+1)  & PARS_FRAMES_MASK;
//    pastParsIndex= thisFrameNumber & PASTPARS_SAVE_ENTRIES_MASK;
    pastParsIndex= (thisFrameNumber-1) & PASTPARS_SAVE_ENTRIES_MASK; 
//    memcpy (pastpars[pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], sizeof(pastpars[0].past_pars));
    memcpy (pastpars[pastParsIndex].past_pars, &framepars[findex_prev].pars[PARS_SAVE_FROM], PARS_SAVE_COPY<<2);

    if (interframe_pars) { 
#if 0
      memcpy (interframe_pars,  &framepars[findex_prev].pars[P_GTAB_R], 24); 
      interframe_pars->height=  framepars[findex_prev].pars[P_ACTUAL_HEIGHT]; 
      interframe_pars->color=   framepars[findex_prev].pars[P_COLOR];
      interframe_pars->byrshift=framepars[findex_prev].pars[P_COLOR];
#endif
      memcpy (interframe_pars,  &framepars[findex_this].pars[P_GTAB_R], 24); 
      interframe_pars->height=  framepars[findex_this].pars[P_ACTUAL_HEIGHT]; 
      interframe_pars->color=   framepars[findex_this].pars[P_COLOR];
      interframe_pars->byrshift=framepars[findex_this].pars[P_COMPMOD_BYRSH];
    }
    if ((bmask32=framepars[findex_prev].modsince32)) {
     MDF7(printk("framepars[%d].modsince32=0x%lx\n",findex_prev,bmask32));
      for (index32=0; bmask32; index32++, bmask32 >>= 1) {
         if (bmask32 & 1) {
           for (index=(index32<<5),bmask=framepars[findex_prev].modsince[index32]; bmask; index++, bmask >>= 1)
             if (bmask & 1) {
               framepars[findex_prev].pars[index] = framepars[findex_future].pars[index];
     MDF7(printk("hw=%d framepars[%d].pars[%d]=framepars[%d].pars[%d]=0x%lx\n",frame8, findex_prev,index,findex_future,index,framepars[findex_future].pars[index]));
             }
           framepars[findex_prev].modsince[index32]=0; 
         }
      }
      framepars[findex_prev].modsince32=0;
    }
    if (framepars[findex_prev].mod32) memset(framepars[findex_prev].mod, 0, 32*4); 
    framepars[findex_prev].functions=0; 
    framepars[findex_prev].pars[P_FRAME]=thisFrameNumber+7; 

    if (framepars[findex_this].functions) { 
      if (!(get_globalParam(G_TASKLET_CTL) & (1 << TASKLET_CTL_IGNPAST))) {
        framepars[findex_next].functions |= framepars[findex_this].functions;
        if ((bmask32=framepars[findex_this].mod32)) {
          for (index32=0; bmask32; index32++, bmask32 >>= 1) {
            if (bmask32 & 1) {
              framepars[findex_next].mod[index32] |= framepars[findex_this].mod[index32];
            }
            framepars[findex_next].mod32 |= framepars[findex_this].mod32;
          }
        }
        MDF7(printk ("resubmitting past due functions = 0x%lx for frame=%ld (0x%x)\n",framepars[findex_this].functions,thisFrameNumber,findex_this));
      } else {
        MDF(printk ("Ignored past due functions = 0x%lx for frame=%ld (0x%x)\n",framepars[findex_this].functions,thisFrameNumber,findex_this));
      }
    }
    thisFrameNumber++;
  } 
}


inline void processParsASAP (struct sensorproc_t * sensorproc, int frame8) {
  unsigned long todo, mask , remain;
  int pars_ahead;  
  int frame_proc;   
  struct framepars_t * procpars;
  struct framepars_t * prevpars ; 
  unsigned long * p_nasap=& GLOBALPARS(G_CALLNASAP);
  int i;
  int rslt;
#if ELPHEL_DEBUG
  unsigned long allfunctions=framepars[0].functions  | framepars[1].functions | framepars[2].functions | framepars[3].functions |
                             framepars[4].functions | framepars[5].functions | framepars[6].functions | framepars[7].functions;
  if (allfunctions)       MDF6(printk("frame8=%d, functions: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", frame8, framepars[0].functions,framepars[1].functions,framepars[2].functions,framepars[3].functions,framepars[4].functions,framepars[5].functions,framepars[6].functions,framepars[7].functions));

#endif
  for (pars_ahead=0; pars_ahead <= 4;  pars_ahead++ ) {
    frame_proc=(frame8 + pars_ahead) & PARS_FRAMES_MASK;
    procpars  = &framepars[frame_proc];
    prevpars  = &framepars[(frame_proc-1) & PARS_FRAMES_MASK];
    i=0;
    mask=1;
    remain=0xffffffff;
    while ((todo=(pars_ahead)?
                   (p_nasap[pars_ahead] & (procpars->functions) & remain):
                   (procpars->functions & remain) )) { 

      while (!(todo & mask)) { 
        i++;
        mask   <<=1;
        remain <<=1;
      }
      MDF6(printk(" todo=0x%08lx (curr=0x%08lx) frame8=%d, pars_ahead=%d, frame_proc=%d i=%d, mask=0x%08lx\n", todo, procpars->functions, frame8,pars_ahead,frame_proc,i,mask));

      MDF6(printk(" %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", framepars[0].functions,framepars[1].functions,framepars[2].functions,framepars[3].functions,framepars[4].functions,framepars[5].functions,framepars[6].functions,framepars[7].functions));

      if (sensorproc->pgm_func[i]) {
        rslt=sensorproc->pgm_func[i]    ( &(sensorproc->sensor), procpars, prevpars, -1);
      } else rslt=0; 
      if ((rslt >= 0) && (sensorproc->pgm_func[i+32])) { 
        rslt=sensorproc->pgm_func[i+32] ( &(sensorproc->sensor), procpars, prevpars, -1);
      }
      if (rslt<0) printk("%s:%d:%s - error=%d",__FILE__,__LINE__,__FUNCTION__, rslt);
      procpars->functions &= ~mask;
      MDF6(printk(".functions=0x%08lx)\n", procpars->functions));
      i++;
      mask   <<=1;
      remain <<=1;
    }
  }
}
//#define G_CALLNASAP    119 // bitmask - what functions can be used not only in the current frame (ASAP) mode 
//#define G_CALLNEXT1      120 // bitmask of actions to be one   or more frames ahead of the programmed one (OR-ed with G_CALLNEXT2..G_CALLNEXT4) 
//#define G_CALLNEXT2      121 // bitmask of actions to be two   or more frames ahead of the programmed one (OR-ed with G_CALLNEXT3..G_CALLNEXT4)
//#define G_CALLNEXT3      122 // bitmask of actions to be three or more frames ahead of the programmed one (OR-ed with G_CALLNEXT4)
//#define G_CALLNEXT4      123 // bitmask of actions to be four  or more frames ahead of the programmed one


inline void processParsSeq (struct sensorproc_t * sensorproc, int frame8, int maxahead) {
  unsigned long todo, mask , remain;
  int job_ahead;   
  int pars_ahead;  
  int frame_proc;   
  struct framepars_t * procpars;
  struct framepars_t * prevpars ; 
  unsigned long * p_nasap=& GLOBALPARS(G_CALLNASAP);
  int seq_frame;  
  int i;
  int rslt;
  int max_par_ahead;
  int this_ahead;
  if (maxahead > (PARS_FRAMES-3)) maxahead = PARS_FRAMES-3; 




  for (job_ahead=0; job_ahead <= maxahead; job_ahead++ ) {
    max_par_ahead=min(5,(PARS_FRAMES-3) -job_ahead); 
    for (pars_ahead=0; pars_ahead < max_par_ahead;  pars_ahead++ ) {
      frame_proc=(frame8 + job_ahead + pars_ahead +1) & PARS_FRAMES_MASK; 
      procpars  = &framepars[frame_proc];
      if (procpars->functions &
                   p_nasap[pars_ahead] &  
                   p_nasap[0]) {
        prevpars  = &framepars[(frame_proc-1) & PARS_FRAMES_MASK];
//        seq_frame=  (frame8+job_ahead+1) & PARS_FRAMES_MASK;
        i=0;
        mask=1;
        remain=0xffffffff;
        while ((todo=procpars->functions &
                     p_nasap[0] & remain)) { 
          while (!(todo & mask)) { 
            i++;
            mask   <<=1;
            remain <<=1;
          }
          for (this_ahead=1; (p_nasap[this_ahead] & todo & mask) && (this_ahead <=4); this_ahead++); 
//          seq_frame=  (frame8 + job_ahead + this_ahead) & PARS_FRAMES_MASK;
          seq_frame=  (frame_proc+1-this_ahead) & PARS_FRAMES_MASK;

          MDF6(printk(" todo=0x%08lx (curr=0x%08lx) frame8=%d, frame_proc=%d, seq_frame=%d, i=%d, mask=0x%08lx\n", todo, procpars->functions, frame8,frame_proc,seq_frame,i,mask));
          MDF6(printk(" %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", framepars[0].functions,framepars[1].functions,framepars[2].functions,framepars[3].functions,framepars[4].functions,framepars[5].functions,framepars[6].functions,framepars[7].functions));

          if (sensorproc->pgm_func[i]) {
            rslt=sensorproc->pgm_func[i]    ( &(sensorproc->sensor), procpars, prevpars, seq_frame); 
          } else rslt=0; 
          if ((rslt >= 0) && (sensorproc->pgm_func[i+32])) { 
            rslt=sensorproc->pgm_func[i+32] ( &(sensorproc->sensor), procpars, prevpars, seq_frame);
          }
          if (rslt >= 0) {
            procpars->functions &= ~mask; 
          } else {
            MDF6(printk("Error - function result was %d\n", rslt));
          }
          i++;
          mask   <<=1;
          remain <<=1;
        }
      }
    }
  }
}

//TODO: "Do it later" should be the only reason not to erase todo bit
//#define P_CALLASAP       107 // bitmask - what functions work only in the current frame (ASAP) mode 

void processPars (struct sensorproc_t * sensorproc, int frame8, int maxahead) {
   frame8 &= PARS_FRAMES_MASK;
//   MDF6(printk("before first processParsASAP\n"));
   processParsASAP (sensorproc, frame8);
//   MDF6(printk("before processParsSeq\n"));
   processParsSeq (sensorproc, frame8, maxahead);
//   MDF6(printk("before second processParsASAP\n"));
   processParsASAP (sensorproc, frame8);
}

void schedule_pgm_func(int frame8, int func_num) {
   MDF1(printk(" frame8=%d, func_num=%d\n", frame8, func_num));
  framepars[frame8 & PARS_FRAMES_MASK].functions |= 1 << func_num;
}

void schedule_this_pgm_func(struct framepars_t * this_framepars, int func_num) {
  int frame8=this_framepars->pars[P_FRAME] & PARS_FRAMES_MASK;
   MDF1(printk(" frame8=%d, func_num=%d\n", frame8, func_num));
  framepars[frame8].functions |= 1 << func_num;
}


unsigned long getThisFrameNumber(void) { 
  return thisFrameNumber;
}


int setFrameParsStatic(int numPars, struct frameparspair_t * pars) { 
  int npar,nframe,index;
  for (npar=0; npar < numPars; npar++) {
    index=pars[npar].num;
    if (index > P_MAX_PAR) return -ERR_FRAMEPARS_BADINDEX;
    for (nframe=0; nframe < PARS_FRAMES; nframe++) {
      framepars[nframe].pars[index]=pars[npar].val;
    }
  }
  return 0;
}


int setFrameParsAtomic(unsigned long frameno, int maxLatency, int numPars, struct frameparspair_t * pars) {
  unsigned long flags;
  int npar,nframe;
  unsigned long val, bmask, bmask32;
  int index,bindex;
  if (!frameParsInitialized) {
     initSequencers(); 
  }
  int findex_this=  thisFrameNumber & PARS_FRAMES_MASK;
  int findex_prev= (findex_this-1)  & PARS_FRAMES_MASK;
  int findex_future=(findex_this-2)  & PARS_FRAMES_MASK; 
//  int frame8=       frameno         & PARS_FRAMES_MASK;
  int frame8;
  MDF2(printk (": frameno=0x%lx, findex_this=%d maxLatency=%d, numPars=%d\n",frameno, findex_this, maxLatency, numPars));
  D1I(local_irq_save(flags));
  PROFILE_NOW(6);
  if (maxLatency>=0) {
    if      (frameno <= (thisFrameNumber+maxLatency)) {
      D1I(local_irq_restore(flags));
      return -ERR_FRAMEPARS_TOOLATE;
    }
    else if (frameno >= (thisFrameNumber+ (PARS_FRAMES-1))) {
      D1I(local_irq_restore(flags));
      return -ERR_FRAMEPARS_TOOEARLY;
    }
  }
  for (npar=0; npar < numPars; npar++) {
    D5(printk(" --pars[%d].num=0x%lx, pars[%d].val=0x%lx",npar,pars[npar].num, npar, pars[npar].val));
//    frame8=      (pars[npar].num & FRAMEPAR_GLOBALS)? -1: (frameno  & PARS_FRAMES_MASK);
    frame8=      frameno  & PARS_FRAMES_MASK; 
    val=pars[npar].val;
    index= pars[npar].num & 0xffff;
    if (index> ((index >= FRAMEPAR_GLOBALS)? (P_MAX_GPAR+FRAMEPAR_GLOBALS): P_MAX_PAR)) {
      D1I(local_irq_restore(flags));
      return -ERR_FRAMEPARS_BADINDEX;
    }
    D5(printk(" index=0x%x, val=0x%lx",index, val));
    if (index >= FRAMEPAR_GLOBALS) { 
      if (pars[npar].num & FRAMEPAIR_MASK_BYTES) { 
        val= FRAMEPAIR_FRAME_MASK_NEW(pars[npar].num, GLOBALPARS(index), val);
      }
      GLOBALPARS(index)=val;
      D5(printk(" set GLOBALPARS(0x%x)=0x%lx\n",index,val));
    } else if (pars[npar].num  & FRAMEPAIR_FRAME_FUNC) {
      funcs2call[index] = val;
      D5(printk(" set funcs2call[0x%x]=0x%lx\n",index,val));
//    } else if ((frameno !=findex_prev) && (frameno != findex_future)) { /// do not write parameters in the future otherwise 
    } else if ((frame8 != findex_future) || ((pars[npar].num & FRAMEPAIR_JUST_THIS)==0)) { 
      if (pars[npar].num & FRAMEPAIR_MASK_BYTES) { 
        val= FRAMEPAIR_FRAME_MASK_NEW(pars[npar].num, framepars[frame8].pars[index], val);
      }
//TODO: optimize to use mask several parameters together
      D5(printk(" frame8=0x%x\n",frame8));
      if ((framepars[frame8].pars[index]!= val) || (pars[npar].num & FRAMEPAIR_FORCE_NEW)){
        bmask=   1 << (index & 31);
        bindex = index >> 5;
        bmask32= 1 << bindex;
        framepars[frame8].pars[index]       = val;
        framepars[frame8].mod[bindex]      |= bmask;
        framepars[frame8].mod32            |= bmask32;
        framepars[frame8].functions        |= funcs2call[index]; 
        D5(printk(" bindex=0x%x, bmask=0x%08lx, bmask32=0x%08lx, functions=0x%08lx\n",bindex, bmask, bmask32, framepars[frame8].functions));
        if ((pars[npar].num & FRAMEPAIR_JUST_THIS)==0) {
          MDF5(printk (":        ---   setting next frames"));
          for (nframe=(frame8+1) & PARS_FRAMES_MASK; (nframe != findex_prev) && (!(framepars[nframe].mod[bindex] & bmask)); nframe=(nframe+1) & PARS_FRAMES_MASK) {
            framepars[nframe].pars[index] = val;
            D5(printk (" %d",nframe));
          }
          frame8=(frame8-1) & PARS_FRAMES_MASK;
          D5(printk ("\n"));
        }
        for (nframe=frame8; nframe != findex_future; nframe=(nframe-1) & PARS_FRAMES_MASK) { 
          framepars[nframe].modsince[bindex] |= bmask;
          framepars[nframe].modsince32       |= bmask32;
        }
      }
    } else { 
      D1I(local_irq_restore(flags));
      ELP_KERR(printk("Tried to write JUST_THIS parameter (0x%lx) too far in the future", pars[npar].num));
      return -ERR_FRAMEPARS_TOOEARLY;
    }
  }
  if (!(get_globalParam(G_TASKLET_CTL) & (1<< TASKLET_CTL_NOSAME))) {
//    processParsSeq (sensorproc, thisFrameNumber & PARS_FRAMES_MASK, 0); ///maxahead=0, the rest will be processed after frame sync, from the tasklet
    MDF5(printk ("\n"));
    processPars (sensorproc, thisFrameNumber & PARS_FRAMES_MASK, 0); 
  }
  PROFILE_NOW(7);
  D1I(local_irq_restore(flags));
  return 0;
}
//#define FRAMEPAIR_JUST_THIS     0x40000 // write only to this frame, don't propagate
                                         // (like "single frame" - compressor, sensor) first write "stop", then - "single" with FRAMEPAIR_JUST_THIS
int setFramePar(struct framepars_t * this_framepars, unsigned long mindex, unsigned long val) {
  int frame8=  (this_framepars->pars[P_FRAME]) & PARS_FRAMES_MASK;
  unsigned long flags;
  int nframe;
  unsigned long bmask, bmask32 , bindex;
  int findex_this=  thisFrameNumber & PARS_FRAMES_MASK;
  int findex_prev= (findex_this-1)  & PARS_FRAMES_MASK;
  int findex_future=(findex_this-2)  & PARS_FRAMES_MASK;
  int index=    mindex & 0xffff;
  MDF8(printk (": thisFrameNumber=0x%lx frame8=%d index= %d (0x%lx), val=0x%lx\n", thisFrameNumber, frame8, index, mindex, val));
  D1I(local_irq_save(flags));

//  if (index > P_MAX_PAR) {
  if (index> ((index >= FRAMEPAR_GLOBALS)? (P_MAX_GPAR+FRAMEPAR_GLOBALS): P_MAX_PAR)) {
    D1I(local_irq_restore(flags));
    return -ERR_FRAMEPARS_BADINDEX;
  }
//TODO: optimize to use mask several parameters together
  if (index >= FRAMEPAR_GLOBALS) { 
    if (mindex & FRAMEPAIR_MASK_BYTES) { 
      val= FRAMEPAIR_FRAME_MASK_NEW(mindex, GLOBALPARS(index), val);
    }
    GLOBALPARS(index)=val;
  } else if (mindex  & FRAMEPAIR_FRAME_FUNC) { 
    funcs2call[index] = val;
//  } else {

  } else if ((frame8 != findex_future) || ((mindex & FRAMEPAIR_JUST_THIS)==0)) { 
    if (mindex & FRAMEPAIR_MASK_BYTES) { 
      val= FRAMEPAIR_FRAME_MASK_NEW(mindex, framepars[frame8].pars[index], val);
    }
    if ((framepars[frame8].pars[index]!= val) || (mindex & (FRAMEPAIR_FORCE_NEW | FRAMEPAIR_FORCE_PROC))){
      bmask=   1 << (index & 31);
      bindex = index >> 5;
      bmask32= 1 << bindex;
      framepars[frame8].pars[index]       = val;
      framepars[frame8].mod[bindex]      |= bmask;
      framepars[frame8].mod32            |= bmask32;
      if (mindex & FRAMEPAIR_FORCE_PROC){
        framepars[frame8].functions        |= funcs2call[index]; 
      }
      MDF8(printk(" bindex=0x%lx, bmask=0x%08lx, bmask32=0x%08lx, functions=0x%08lx\n",bindex, bmask, bmask32, framepars[frame8].functions)); 
      if ((mindex & FRAMEPAIR_JUST_THIS)==0) {
        MDF8(printk (":        ---   setting next frames"));
//        for (nframe=(frame8+1) & PARS_FRAMES_MASK; (nframe != findex_prev) && (!(framepars[frame8].mod[bindex] & bmask)); nframe=(nframe+1) & PARS_FRAMES_MASK) {
        for (nframe=(frame8+1) & PARS_FRAMES_MASK; (nframe != findex_prev) && (!(framepars[nframe].mod[bindex] & bmask)); nframe=(nframe+1) & PARS_FRAMES_MASK) {
          framepars[nframe].pars[index] = val;
          D8(printk (" %d",nframe));
        }
        frame8=(frame8-1) & PARS_FRAMES_MASK;  
      }
//      MDF1(printk("\n"));
      MDF8(printk (":        >>>   setting modsince"));
//    for (nframe=(frame8-1) & PARS_FRAMES_MASK; nframe != findex_future; nframe=(nframe-1) & PARS_FRAMES_MASK) {
      for (nframe=frame8;                        nframe != findex_future; nframe=(nframe-1) & PARS_FRAMES_MASK) { 
        framepars[nframe].modsince[bindex] |= bmask;
        framepars[nframe].modsince32       |= bmask32;
        D8(printk (" %d",nframe));
      }
      D8(printk ("\n"));
    } else { 
      D1I(local_irq_restore(flags));
      ELP_KERR(printk("Tried to write JUST_THIS parameter (0x%lx) too far in the future", mindex));
      return -ERR_FRAMEPARS_TOOEARLY;
    }
  }
  D1I(local_irq_restore(flags));
  return 0;
}
int setFramePars(struct framepars_t * this_framepars, int numPars, struct frameparspair_t * pars) {
  int frame8;
  unsigned long flags;
  int npar,nframe;
  unsigned long val, bmask, bmask32;
  int index,bindex;
  int findex_this=  thisFrameNumber & PARS_FRAMES_MASK;
  int findex_prev= (findex_this-1)  & PARS_FRAMES_MASK;
  int findex_future=(findex_this-2)  & PARS_FRAMES_MASK;
  MDF8(printk (": this_framepars=0x%x numPars=%d\n",(int) this_framepars, numPars));
  D1I(local_irq_save(flags));
  for (npar=0; npar < numPars; npar++) {
    frame8= (this_framepars->pars[P_FRAME]) & PARS_FRAMES_MASK;
    val=pars[npar].val;
    index= pars[npar].num & 0xffff;
    MDF8(printk (":    ---   frame8=%d index=%d (0x%x) val=0x%x\n", frame8, index, (int) pars[npar].num, (int) val));
    if (index> ((index >= FRAMEPAR_GLOBALS)? (P_MAX_GPAR+FRAMEPAR_GLOBALS): P_MAX_PAR)) {
      D1I(local_irq_restore(flags));
      ELP_KERR(printk(" bad index=%d > %d\n", index, P_MAX_PAR));
      return -ERR_FRAMEPARS_BADINDEX;
    }
    if (index >= FRAMEPAR_GLOBALS) { 
       if (pars[npar].num & FRAMEPAIR_MASK_BYTES) { 
         val= FRAMEPAIR_FRAME_MASK_NEW(pars[npar].num, GLOBALPARS(index), val);
       }
       GLOBALPARS(index)=val;
    } else if (pars[npar].num  & FRAMEPAIR_FRAME_FUNC) {
        funcs2call[index] = val;
//    } else {
    } else if ((frame8 != findex_future) || ((pars[npar].num & FRAMEPAIR_JUST_THIS)==0)) { 
       if (pars[npar].num & FRAMEPAIR_MASK_BYTES) { 
         val= FRAMEPAIR_FRAME_MASK_NEW(pars[npar].num, framepars[frame8].pars[index], val);
       }
//TODO: optimize to use mask several parameters together
      if ((framepars[frame8].pars[index]!= val) || (pars[npar].num & (FRAMEPAIR_FORCE_NEW | FRAMEPAIR_FORCE_PROC))){
        bmask=   1 << (index & 31);
        bindex = index >> 5;
        bmask32= 1 << bindex;
        framepars[frame8].pars[index]       = val;
        framepars[frame8].mod[bindex]      |= bmask;
        framepars[frame8].mod32            |= bmask32;
        if (pars[npar].num & FRAMEPAIR_FORCE_PROC){
          framepars[frame8].functions        |= funcs2call[index]; 
        }
        if ((pars[npar].num & FRAMEPAIR_JUST_THIS)==0) {
        MDF8(printk (":        ---   setting next frames"));
          for (nframe=(frame8+1) & PARS_FRAMES_MASK; (nframe != findex_prev) && (!(framepars[nframe].mod[bindex] & bmask)); nframe=(nframe+1) & PARS_FRAMES_MASK) {
            D8(printk (" %d",nframe));
            framepars[nframe].pars[index] = val;
          }
          frame8=(frame8-1) & PARS_FRAMES_MASK; 
          D8(printk ("\n"));
        }
//      for (nframe=(frame8-1) & PARS_FRAMES_MASK; nframe != findex_future; nframe=(nframe-1) & PARS_FRAMES_MASK) {
        for (nframe=frame8;                        nframe != findex_future; nframe=(nframe-1) & PARS_FRAMES_MASK) { 
          framepars[nframe].modsince[bindex] |= bmask;
          framepars[nframe].modsince32       |= bmask32;
        }
      }
    } else { 
      D1I(local_irq_restore(flags));
      ELP_KERR(printk("Tried to write JUST_THIS parameter (0x%lx) too far in the future", pars[npar].num));
      return -ERR_FRAMEPARS_TOOEARLY;
    }
  }
  D1I(local_irq_restore(flags));
  return 0;
}


static struct file_operations framepars_fops = {
   owner:    THIS_MODULE,
   llseek:   framepars_lseek,
   write:    framepars_write,
   open:     framepars_open,
   mmap:     framepars_mmap,
   release:  framepars_release
};

int framepars_open(struct inode *inode, struct file *filp) {
  int res;
  struct framepars_pd * privData;
  privData= (struct framepars_pd *) kmalloc(sizeof(struct framepars_pd),GFP_KERNEL);
  if (!privData) return -ENOMEM;
  filp->private_data = privData;
  privData-> minor=MINOR(inode->i_rdev);
  MDF1(printk(": minor=0x%x\n",privData-> minor));
  switch (privData-> minor) {
    case  CMOSCAM_MINOR_FRAMEPARS :
        inode->i_size = 0; //or return 8 - number of frame pages?
        return 0;
    default:
       kfree(filp->private_data); // already allocated
       return -EINVAL;
  }
  return res;
}

int framepars_release(struct inode *inode, struct file *filp) {
  int res=0;
  int p = MINOR(inode->i_rdev);
  MDF1(printk(": minor=0x%x\n",p));
  switch ( p ) {
    case  CMOSCAM_MINOR_FRAMEPARS :
        break;
    default:
        return -EINVAL; 
    }
  kfree(filp->private_data);
  return res;
}

loff_t framepars_lseek (struct file * file, loff_t offset, int orig) {
 unsigned long target_frame;
 MDF1(printk(" offset=0x%x, orig=0x%x\n",(int) offset, (int) orig));
   switch(orig) {
   case SEEK_SET:
     file->f_pos = offset;
     break;
   case SEEK_CUR:
     if (offset==0) return getThisFrameNumber(); 
     file->f_pos = getThisFrameNumber() + offset; 
     break;
   case SEEK_END:
     if (offset <= 0) {
        break;
     } else if (offset >= LSEEK_FRAME_WAIT_REL) {
       if (offset >=LSEEK_FRAME_WAIT_ABS) target_frame=offset-LSEEK_FRAME_WAIT_ABS;                     
       else                               target_frame=getThisFrameNumber()+offset-LSEEK_FRAME_WAIT_REL; 
       wait_event_interruptible (framepars_wait_queue,getThisFrameNumber()>=target_frame);
//       if (getThisFrameNumber()<target_frame) wait_event_interruptible (framepars_wait_queue,getThisFrameNumber()>=target_frame);
       return getThisFrameNumber(); 
     } else { 
        switch (offset & ~0x1f) {
          case  LSEEK_DAEMON_FRAME:  
            wait_event_interruptible (framepars_wait_queue, get_imageParamsThis(P_DAEMON_EN) & (1<<(offset & 0x1f)));
            break;
          default:
            switch (offset) {
              case LSEEK_GET_FPGA_TIME:
                X313_GET_FPGA_TIME( GLOBALPARS(G_SECONDS), GLOBALPARS(G_MICROSECONDS) );
                MDF2(printk("X313_GET_FPGA_TIME\n"));
                break;
              case LSEEK_SET_FPGA_TIME:    
                X313_SET_FPGA_TIME( GLOBALPARS(G_SECONDS) , GLOBALPARS(G_MICROSECONDS) );
                MDF2(printk("X313_SET_FPGA_TIME\n"));
                break;
              case LSEEK_FRAMEPARS_INIT:   
                MDF2(printk("LSEEK_FRAMEPARS_INIT\n"));
                initGlobalPars();
                initSequencers();
                break;
              case LSEEK_FRAME_RESET:     
                MDF2(printk("LSEEK_FRAME_RESET\n"));
                resetFrameNumber();
                break;
              case LSEEK_SENSORPROC:      
                MDF2(printk("LSEEK_SENSORPROC: framepars[0].functions=0x%08lx\n",framepars[0].functions));
                processPars (sensorproc, 0, 8);  
                break;
              case LSEEK_DMA_INIT:         
                MDF2(printk("LSEEK_DMA_INIT\n"));
                x313_dma_init();
                break;
              case LSEEK_DMA_STOP:         
                MDF2(printk("LSEEK_DMA_STOP\n"));
                x313_dma_stop();           
                break;
              case LSEEK_DMA_START:        
                MDF2(printk("LSEEK_DMA_START\n"));
                x313_dma_start();          
                break;
              case LSEEK_COMPRESSOR_RESET: 
                MDF2(printk("LSEEK_COMPRESSOR_RESET\n"));
                reset_compressor();
                break;
              case LSEEK_INTERRUPT_OFF:    
                MDF2(printk ("LSEEK_INTERRUPT_OFF\n"));
                camera_interrupts (0);
                break;
              case LSEEK_INTERRUPT_ON:     
                MDF2(printk ("LSEEK_INTERRUPT_ON\n"));
                camera_interrupts (1);
                break;
            }
        }
        break;
     }
     break;
   default:
      return -EINVAL;
   }
   return  file->f_pos ;
}

ssize_t framepars_write(struct file * file, const char * buf, size_t count, loff_t *off) {
   struct frameparspair_t   pars_static[256];
   struct frameparspair_t * pars = pars_static;
   struct framepars_pd * privData = (struct framepars_pd *) file->private_data;
   unsigned long frame=*off; 
   int           latency=-1;
   int           first=0;
   int           last;
   int           result;
   MDF1(printk(": file->f_pos=0x%x, *off=0x%x, count=0x%x\n", (int) file->f_pos, (int) *off, (int) count));
   count &= ~7; 
   switch (privData->minor) {
       case CMOSCAM_MINOR_FRAMEPARS :
         if (count>sizeof(pars_static)) 
            pars =     (struct frameparspair_t *) kmalloc(count, GFP_KERNEL);
         if (!pars) return -ENOMEM;
         count >>=3; 
         if(count) {
            if(copy_from_user((char *) pars, buf, count<<3)) {
              if (count>sizeof(pars_static)) kfree(pars);
              return -EFAULT;
           }
           while (first <count) {
             while ((first <count) && ((pars[first].num & 0xff00)==0xff00)) { // process special instructions
               switch (pars[first].num & 0xffff) {
                 case FRAMEPARS_SETFRAME:
                    frame= pars[first].val;
                    break;
                 case FRAMEPARS_SETFRAMEREL:
                    frame= pars[first].val+getThisFrameNumber();
                    break;
                 case FRAMEPARS_SETLATENCY:
                    latency= (pars[first].val & 0x80000000)? -1: pars[first].val;
                    break;
                 case FRAMEPARS_SETFPGATIME:  
                    X313_SET_FPGA_TIME( GLOBALPARS(G_SECONDS) , GLOBALPARS(G_MICROSECONDS) );
                    break;
                 case FRAMEPARS_GETFPGATIME:  
                    X313_GET_FPGA_TIME( GLOBALPARS(G_SECONDS) , GLOBALPARS(G_MICROSECONDS) );
                    break;
                 default:
                 printk("framepars_write: invalid special instruction: 0x%x\n", (int) pars[first].num);
               }
               first ++;
             }
             last=first+1;
             while ((last < count) && ((pars[last].num & 0xff00)!=0xff00)) last++; // skip to the end or next special instructions
             result=setFrameParsAtomic(frame, latency, last-first, &pars[first]);
             MDF1(printk("setFrameParsAtomic(%ld, %d, %d)\n", frame, latency, last-first));
             if (result <0) { 
               if (count>sizeof(pars_static)) kfree(pars);
               return -EFAULT;
             }
             first=last;
           }
         }
         if (count>sizeof(pars_static)) kfree(pars);
         return count<<3; 
       default: return -EINVAL;
  }
}

int framepars_mmap (struct file *file, struct vm_area_struct *vma) {
  int result;
  struct framepars_pd * privData = (struct framepars_pd *) file->private_data;
  MDF1(printk(": minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case  CMOSCAM_MINOR_FRAMEPARS :
           result=remap_pfn_range(vma,
                    vma->vm_start,
                   ((unsigned long) virt_to_phys(frameparsall)) >> PAGE_SHIFT, // Should be page-aligned
                    vma->vm_end-vma->vm_start,
                    vma->vm_page_prot);
           MDF1(printk("remap_pfn_range returned=%x\r\n",result));
           if (result) return -EAGAIN;
           return 0;
       default: return -EINVAL;
  }
}

static int __init framepars_init(void) {
   int res;
   init_framepars_ptr();
   initGlobalPars(); 
   frameParsInitialized=0;
   res = register_chrdev(FRAMEPARS_MAJOR, "framepars_operations", &framepars_fops);
   if(res < 0) {
     printk(KERN_ERR "\nframepars_init: couldn't get a major number %d.\n",FRAMEPARS_MAJOR);
     return res;
   }
   init_waitqueue_head(&framepars_wait_queue);
   printk(X3X3_FRAMEPARS_DRIVER_NAME" - %d \n",FRAMEPARS_MAJOR);
   return 0;
}


module_init(framepars_init);
MODULE_LICENSE("GPLv3.0");
MODULE_AUTHOR("Andrey Filippov <andrey@elphel.com>.");
MODULE_DESCRIPTION(X3X3_FRAMEPARS_DRIVER_NAME);

---