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

Go to the documentation of this file.

/*!********************************************************************************
*! FILE NAME  : pgm_functions.c
*! DESCRIPTION: sensor/FPGA programming functions, called from
*! IRQ/tasklet
*! 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.
*!
*!  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: pgm_functions.c,v $
*!  Revision 1.1.1.1  2008/11/27 20:04:00  elphel
*!
*!
*!  Revision 1.32  2008/11/27 09:27:31  elphel
*!  Support fro new parameters (vignetting correction related)
*!
*!  Revision 1.31  2008/11/14 01:01:40  elphel
*!  fixed new bug in pgm_gammaload
*!
*!  Revision 1.30  2008/11/13 05:40:45  elphel
*!  8.0.alpha16 - modified histogram storage, profiling
*!
*!  Revision 1.29  2008/11/03 18:43:18  elphel
*!  8.0.alpha12 with working apps/astreamer
*!
*!  Revision 1.28  2008/10/31 18:26:32  elphel
*!  Adding support for constants like SENSOR_REGS32 (defined constant plus 32 to simplify referencing sensor registers from PHP
*!
*!  Revision 1.27  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.26  2008/10/23 08:08:05  elphel
*!  corrected histogram window size setup (data written to FPGA is actual window size -2 for both width and height)
*!
*!  Revision 1.25  2008/10/22 05:29:03  elphel
*!  Rev. 8.0.alpha5 - working on external trigger mode - moved programming away from the sequencer that can only pass 24 data bits
*!
*!  Revision 1.24  2008/10/21 04:03:39  elphel
*!  bug fix (missing break in switch)
*!
*!  Revision 1.23  2008/10/20 18:45:07  elphel
*!  just more debug printk
*!
*!  Revision 1.22  2008/10/18 06:14:21  elphel
*!  8.0.alpha4 - removed some obsolete parameters, renumbered others, split P_FLIP into P_FLIPH and P_FLIPV (different latencies because of bad frames), pgm_window-> pgm_window, pgm_window_safe
*!
*!  Revision 1.21  2008/10/17 05:44:48  elphel
*!  fixing latencies
*!
*!  Revision 1.20  2008/10/12 06:13:10  elphel
*!  snapshot
*!
*!  Revision 1.19  2008/10/11 18:46:07  elphel
*!  snapshot
*!
*!  Revision 1.18  2008/10/08 21:26:25  elphel
*!  snapsot 7.2.0.pre4 - first images (actually - second)
*!
*!  Revision 1.17  2008/10/06 08:33:03  elphel
*!  snapshot, first images
*!
*!  Revision 1.15  2008/10/05 05:13:33  elphel
*!  snapshot003
*!
*!  Revision 1.14  2008/10/04 16:10:12  elphel
*!  snapshot
*!
*!  Revision 1.13  2008/09/28 00:31:57  elphel
*!  snapshot
*!
*!  Revision 1.12  2008/09/25 00:58:12  elphel
*!  snapshot
*!
*!  Revision 1.11  2008/09/22 22:55:49  elphel
*!  snapshot
*!
*!  Revision 1.10  2008/09/19 04:37:26  elphel
*!  snapshot
*!
*!  Revision 1.9  2008/09/16 00:49:32  elphel
*!  snapshot
*!
*!  Revision 1.8  2008/09/12 20:40:13  elphel
*!  snapshot
*!
*!  Revision 1.7  2008/09/12 00:23:59  elphel
*!  removed cc353.c, cc353.h
*!
*!  Revision 1.6  2008/09/05 23:21:32  elphel
*!  snapshot
*!
*!  Revision 1.4  2008/09/04 17:37:13  elphel
*!  documenting
*!
*!  Revision 1.3  2008/07/29 01:15:06  elphel
*!  another snapshot
*!
*!  Revision 1.2  2008/07/27 23:25:07  elphel
*!  next snapshot
*!
*!  Revision 1.1  2008/07/27 04:27:49  elphel
*!  next snapshot
*!
*!
*/

// TODO:remove unneeded
#include <linux/types.h> 
#include <asm/div64.h>   

#include <linux/module.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/c313a.h>
#include <asm/elphel/exifa.h>
#include "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr 
#include "fpga_sdram.h" // use a single fpga_initSDRAM(void)
#include "fpgaconfi2c.h"  //to control clocks
//#include "cc3x3.h"
#include "fpga_io.h"
#include "x3x3.h"           // hardware definitions
#include "framepars.h"
#include "sensor_common.h"
#include "gamma_tables.h"
#include "quantization_tables.h"
#include "latency.h"
#include "pgm_functions.h"
#include "cxdma.h"         // is_dma_on()
#include "jpeghead.h"      // to program FPGA Huffman tables

#if ELPHEL_DEBUG
// #define MDF2(x) { if (GLOBALPARS(G_DEBUG) & (1 <<2)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__ );x ;} }
 #define MDF3(x) { if (GLOBALPARS(G_DEBUG) & (1 <<3)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__ );x ;} }
 #define MDF9(x) { if (GLOBALPARS(G_DEBUG) & (1 <<9)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__ );x ;} }
 #define MDF16(x) { if (GLOBALPARS(G_DEBUG) & (1 <<16)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__ );x ;} }
 #define ELPHEL_DEBUG_THIS 0
// #define ELPHEL_DEBUG_THIS 1
#else
// #define MDF2(x)
 #define MDF3(x)
 #define MDF9(x)
 #define MDF16(x)
 #define ELPHEL_DEBUG_THIS 0
#endif

#if ELPHEL_DEBUG_THIS
  #define MDF1(x) printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__ );x
  #define MD1(x)  printk("%s:%d: ",__FILE__,__LINE__ );x
  #define MD12(x) printk("%s:%d: ",__FILE__,__LINE__ );x
#else
  #define MDF1(x)
  #define MD1(x)
  #define MD12(x)
#endif


  int pgm_recalcseq     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8); 
  int pgm_detectsensor  (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_sensorphase   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_i2c           (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_initsensor    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_afterinit     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_window        (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_window_safe   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
inline int pgm_window_common (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_exposure      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_gains         (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_triggermode   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_sensorin      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_sensorstop    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_sensorrun     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_gamma         (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_hist          (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_aexp          (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_quality       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_memsensor     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_memcompressor (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_limitfps      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_compmode      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_focusmode     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_trigseq       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_irq           (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_comprestart   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_compstop      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_compctl       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_gammaload     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_sensorregs    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);
  int pgm_prescal       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8);

int init_pgm_proc(void) {
  int i;
  MDF1(printk("\n"));
  for (i=0;i<64;i++) sensorproc->pgm_func[i]=NULL;
  sensorproc->pgm_func[onchange_recalcseq]=    &pgm_recalcseq;     
  sensorproc->pgm_func[onchange_detectsensor]= &pgm_detectsensor;  
  sensorproc->pgm_func[onchange_sensorphase]=  &pgm_sensorphase;   
  sensorproc->pgm_func[onchange_i2c]=          &pgm_i2c;           
  sensorproc->pgm_func[onchange_initsensor]=   &pgm_initsensor;    
  sensorproc->pgm_func[onchange_afterinit]=    &pgm_afterinit;     
  sensorproc->pgm_func[onchange_window]=       &pgm_window;        
  sensorproc->pgm_func[onchange_window_safe]=  &pgm_window_safe;   
  sensorproc->pgm_func[onchange_exposure]=     &pgm_exposure;      
  sensorproc->pgm_func[onchange_gains]=        &pgm_gains;         
  sensorproc->pgm_func[onchange_triggermode]=  &pgm_triggermode;   
  sensorproc->pgm_func[onchange_sensorin]=     &pgm_sensorin;      
  sensorproc->pgm_func[onchange_sensorstop]=   &pgm_sensorstop;    
  sensorproc->pgm_func[onchange_sensorrun]=    &pgm_sensorrun;     
  sensorproc->pgm_func[onchange_gamma]=        &pgm_gamma;         
  sensorproc->pgm_func[onchange_hist]=         &pgm_hist;          
  sensorproc->pgm_func[onchange_aexp]=         &pgm_aexp;          
  sensorproc->pgm_func[onchange_quality]=      &pgm_quality;       
  sensorproc->pgm_func[onchange_memsensor]=    &pgm_memsensor;     
  sensorproc->pgm_func[onchange_memcompressor]=&pgm_memcompressor; 
  sensorproc->pgm_func[onchange_limitfps]=     &pgm_limitfps;      
  sensorproc->pgm_func[onchange_compmode]=     &pgm_compmode;      
  sensorproc->pgm_func[onchange_focusmode]=    &pgm_focusmode;     
  sensorproc->pgm_func[onchange_trigseq]=      &pgm_trigseq;       
  sensorproc->pgm_func[onchange_irq]=          &pgm_irq;           
  sensorproc->pgm_func[onchange_comprestart]=  &pgm_comprestart;   
  sensorproc->pgm_func[onchange_compstop]=     &pgm_compstop;      
  sensorproc->pgm_func[onchange_compctl]=      &pgm_compctl;       
  sensorproc->pgm_func[onchange_gammaload]=    &pgm_gammaload;     
  sensorproc->pgm_func[onchange_sensorregs]=   &pgm_sensorregs;    
  sensorproc->pgm_func[onchange_prescal]=      &pgm_prescal;       
return 0;
}
//int add_sensor_proc(int index, int (*sens_func)(struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8)) { /// initialize array of functions that program different 
int add_sensor_proc(int index, int (*sens_func)(struct sensor_t * ,  struct framepars_t * , struct framepars_t *, int )) {
  MDF1(printk("index=0x%x\n",index));
  sensorproc->pgm_func[32+(index & 0x1f)]=       sens_func;
return 0;
}

int pgm_detectsensor   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= 0) return -1; 
  if (thispars->pars[P_SENSOR]) return 0; 




  camera_interrupts (0);
  MDF1(printk("Disabled camera interrupts\n"));
//  f1=imageParamsR[P_CLK_SENSOR]=20000000; setClockFreq(1, imageParamsR[P_CLK_SENSOR]); X3X3_RSTSENSDCM;
   int was_sensor_freq=getClockFreq(1); 
   setFramePar(thispars, P_CLK_FPGA,  getClockFreq(0)); 
   setFramePar(thispars, P_CLK_SENSOR,  20000000);
   setClockFreq(1, thispars->pars[P_CLK_SENSOR]);
   udelay (100);// 0.0001 sec to stabilize clocks
   X3X3_RSTSENSDCM; 
   udelay (50000);// 0.05 sec to stabilize clocks
   CCAM_DCLK_ON;
   CCAM_CNVEN_OFF;
   CCAM_NEGRST;  
   CCAM_MRST_ON;
   CCAM_TRIG_INT;
   CCAM_TIMESTAMP_NORMAL;
   udelay (100); 

   printk("removing MRST from the sensor\r\n");
   CCAM_MRST_OFF;
   CCAM_ARST_OFF;
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
   printk("trying MT9X001\r\n");
   if (thispars->pars[P_SENSOR]) mt9x001_pgm_detectsensor(sensor,  thispars, prevpars, frame8);  // try Micron 5.0 Mpixel - should return sensor type
#endif
#define ENABLE_OLD_SENSORS 1
#ifdef ENABLE_OLD_SENSORS
   if (thispars->pars[P_SENSOR]==0)  { // no - it is not MT9P001)
   CCAM_CNVEN_ON;
        port_csp0_addr[X313_WA_DCDC] = 0x44; // 48 - enough, 41 - ok - was 0x61; //
        printk ("sensor power set low\r\n ");
     udelay (10000); // Wait voltage to come up (~10 ms)
        printk ("will set to 0x41\r\n");
     udelay (10000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x41; // 
        printk ("will set to 0x30\r\n");
     udelay (10000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x30; //
        printk ("will set to 0x28\r\n");
     udelay (10000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x28; //
        printk ("will set to 0x24\r\n");
     udelay (10000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x24; //
        printk ("will set to 0x22\r\n");
     udelay (10000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x22; //
     udelay (100000); // to find the problem
        port_csp0_addr[X313_WA_DCDC] = 0x10; // now - full frequency (same as 0x21). Slow that down if the sensor clock is above 20MHz (i.e.0x22 for 40MHz)
        printk (".. full\r\n");
     udelay (10000); // Wait voltage to stabilize
     CCAM_POSRST;  //set positive MRST polarity (default)
     udelay (100); // apply clock before removing MRST
     CCAM_MRST_OFF;
   }
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
   if (thispars->pars[P_SENSOR]==0) kac1310_pgm_detectsensor(sensor,  thispars, prevpars, frame8);  
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
   if (thispars->pars[P_SENSOR]==0) ibis1300_pgm_detectsensor(sensor,  thispars, prevpars, frame8); 
#endif
   if (thispars->pars[P_SENSOR]==0) {
     CCAM_NEGRST;  //set negative MRST polarity
printk ("Inverted MRST\n");
      udelay (100);
   }
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
   printk("trying MT9X001\n");
   if (thispars->pars[P_SENSOR]==0) mt9x001_pgm_detectsensor(sensor,  thispars, prevpars, frame8);  // try Micron 1.3/2.0/3.0 Mpixel
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
   if (thispars->pars[P_SENSOR]==0) kac5000_pgm_detectsensor(sensor,  thispars, prevpars, frame8);  // try KAC-5000
#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
   if (thispars->pars[P_SENSOR]==0) zr32112_pgm_detectsensor(sensor,  thispars, prevpars, frame8); // try ZR32112
#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
   if (thispars->pars[P_SENSOR]==0) zr32212_pgm_detectsensor(sensor,  thispars, prevpars, frame8); // try ZR32212
#endif
#endif // *************** temporary disabling other sensors ********************

   if (thispars->pars[P_SENSOR]==0) {
     sensor->sensorType=SENSOR_NONE;                 
     printk("No image sensor found\r\n");
   }
   setFramePar(thispars, P_SENSOR_WIDTH,   sensor->imageWidth);  
   setFramePar(thispars, P_SENSOR_HEIGHT,  sensor->imageHeight); 
//   setFramePar(thispars, P_SENSOR,         sensor->sensorType); ///already set
   if (sensor->i2c_period==0) sensor->i2c_period=2500;           
   int qperiod=thispars->pars[P_I2C_QPERIOD];
   if (qperiod==0) qperiod=(sensor->i2c_period * (thispars->pars[P_CLK_FPGA]/1000))/4000000;
   setFramePar(thispars, P_I2C_QPERIOD | FRAMEPAIR_FORCE_NEWPROC,  qperiod); 
   int i2cbytes=thispars->pars[P_I2C_BYTES];
   if (i2cbytes==0) i2cbytes=sensor->i2c_bytes;
   setFramePar(thispars, P_I2C_BYTES | FRAMEPAIR_FORCE_NEWPROC,  i2cbytes); 

   if ((was_sensor_freq < sensor->minClockFreq) || (was_sensor_freq > sensor->maxClockFreq)) was_sensor_freq=sensor->nomClockFreq;
   setFramePar(thispars, P_CLK_SENSOR | FRAMEPAIR_FORCE_NEWPROC,  was_sensor_freq); 
//#define P_SENSOR_PHASE  74 // packed, low 16 bit - signed fine phase, bits [18:17] - 90-degrees shift
   int phase=thispars->pars[P_SENSOR_PHASE];
   if (phase==0) phase= (((int) sensor->sensorPhase90) << 16) | ((0x10000 + ((int)  sensor->sensorPhase)) & 0xffff);
   setFramePar(thispars, P_SENSOR_PHASE | FRAMEPAIR_FORCE_NEWPROC,  phase); 
   setFramePar(thispars, P_IRQ_SMART | FRAMEPAIR_FORCE_NEWPROC,  3);        

   camera_interrupts (1);
   return 0;
}



int pgm_initsensor   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= 0) return -1; 

  return 0;
}


/*
#define AFTERINIT_SET(p,v)        { pars_to_update[nupdate  ].num=(p) | FRAMEPAIR_FORCE_NEW; \
                                        pars_to_update[nupdate++].val=(v);}
#define AFTERINIT_UPDATE(p)       { pars_to_update[nupdate  ].num=(p) | FRAMEPAIR_FORCE_NEW; \
                                        pars_to_update[nupdate++].val=thispars->pars[(p)];}
#define AFTERINIT_UPDATE_SET(p,v) { pars_to_update[nupdate  ].num=(p) | FRAMEPAIR_FORCE_NEW; \
                                        pars_to_update[nupdate++].val=thispars->pars[(p)]?thispars->pars[(p)]:(v);}
*/
//#define SETFRAMEPARS_SET(p,v)

int pgm_afterinit  (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
//  struct frameparspair_t * pars_to_update[20]; /// 16 needed, increase if more entries will be added
  struct frameparspair_t pars_to_update[24]; 
  int nupdate=0;
  MDF3(printk(" frame8=%d\n",frame8));
  int woi_width=thispars->pars[P_WOI_WIDTH];
  int woi_height=thispars->pars[P_WOI_HEIGHT];
  if ((woi_width == 0) || (woi_height == 0)) { 
    woi_width= sensor->imageWidth;
    woi_height=sensor->imageHeight;
  }
  SETFRAMEPARS_SET(P_WOI_WIDTH | FRAMEPAIR_FORCE_NEW, woi_width);
  SETFRAMEPARS_SET(P_WOI_HEIGHT | FRAMEPAIR_FORCE_NEW, woi_height);
  SETFRAMEPARS_UPDATE(P_WOI_LEFT | FRAMEPAIR_FORCE_NEW);
  SETFRAMEPARS_UPDATE(P_WOI_TOP | FRAMEPAIR_FORCE_NEW);
  SETFRAMEPARS_UPDATE(P_FLIPH | FRAMEPAIR_FORCE_NEW); 
  SETFRAMEPARS_UPDATE(P_FLIPV | FRAMEPAIR_FORCE_NEW); 

  SETFRAMEPARS_UPDATE_SET(P_HISTWND_RWIDTH | FRAMEPAIR_FORCE_NEW, 0x8000);  
  SETFRAMEPARS_UPDATE_SET(P_HISTWND_RHEIGHT | FRAMEPAIR_FORCE_NEW, 0x8000); 
  SETFRAMEPARS_UPDATE_SET(P_HISTWND_RLEFT | FRAMEPAIR_FORCE_NEW, 0x8000);   
  SETFRAMEPARS_UPDATE_SET(P_HISTWND_RTOP | FRAMEPAIR_FORCE_NEW, 0x8000);    

  SETFRAMEPARS_UPDATE_SET(P_DCM_HOR | FRAMEPAIR_FORCE_NEW,  1);
  SETFRAMEPARS_UPDATE_SET(P_DCM_VERT | FRAMEPAIR_FORCE_NEW, 1);
  SETFRAMEPARS_UPDATE_SET(P_BIN_HOR | FRAMEPAIR_FORCE_NEW,  1);
  SETFRAMEPARS_UPDATE_SET(P_BIN_VERT | FRAMEPAIR_FORCE_NEW, 1);
  SETFRAMEPARS_UPDATE_SET(P_GAINR | FRAMEPAIR_FORCE_NEW, 0x100); 
  SETFRAMEPARS_UPDATE_SET(P_GAING | FRAMEPAIR_FORCE_NEW, 0x100); 
  SETFRAMEPARS_UPDATE_SET(P_GAINB | FRAMEPAIR_FORCE_NEW, 0x100); 
  SETFRAMEPARS_UPDATE_SET(P_GAINGB | FRAMEPAIR_FORCE_NEW,0x100); 

  SETFRAMEPARS_UPDATE(P_BAYER | FRAMEPAIR_FORCE_NEW);

  if (thispars->pars[P_EXPOS]) {
    SETFRAMEPARS_UPDATE(P_EXPOS | FRAMEPAIR_FORCE_NEW);
  } else if (thispars->pars[P_VEXPOS]) {
    SETFRAMEPARS_UPDATE(P_VEXPOS | FRAMEPAIR_FORCE_NEW);
  } else {
    SETFRAMEPARS_SET(P_EXPOS | FRAMEPAIR_FORCE_NEW, 10000); 
  }
  SETFRAMEPARS_UPDATE(P_TRIG | FRAMEPAIR_FORCE_NEW); 


  if (nupdate)  setFramePars(thispars, nupdate, pars_to_update);  
  return 0;
}

int pgm_sensorphase(struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  struct frameparspair_t pars_to_update[4]; 
  int nupdate=0;

  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= 0) return -1; 
  int was_sensor_freq=getClockFreq(1); 
  if (unlikely(thispars->pars[P_CLK_SENSOR] > sensor->maxClockFreq))  SETFRAMEPARS_SET(P_CLK_SENSOR,  sensor->maxClockFreq);
  if (thispars->pars[P_CLK_SENSOR] != was_sensor_freq) {
    if (unlikely(setClockFreq(1, thispars->pars[P_CLK_SENSOR])<0)) { 
      setClockFreq(1, was_sensor_freq);
       SETFRAMEPARS_SET(P_CLK_SENSOR,  was_sensor_freq);
    }
    X3X3_RSTSENSDCM; 
    if (sensor->needReset & SENSOR_NEED_RESET_CLK) schedule_this_pgm_func(thispars, onchange_initsensor);
  }
  int  hact_shift= 0.004 * (sensor->hact_delay/(1000000000.0/thispars->pars[P_CLK_SENSOR])) + 0.5;
  MD12(printk ("hact_shift=%d\r\n",hact_shift));
  if (hact_shift>3) hact_shift=3;
  CCAM_SET_HACT_PHASE(hact_shift) ; 















   if (thispars->pars[P_SENSOR_PHASE]) {
     X3X3_RSTSENSDCM; 
     int sensor_phase90=(thispars->pars[P_SENSOR_PHASE]>>16)&3;
     int sensor_phase=   thispars->pars[P_SENSOR_PHASE] & 0xffff;
     if (sensor_phase>0x8000) sensor_phase-=0x10000; 
   MD12(printk("sensor_phase=0x%x sensor_phase90=0x%x\r\n", sensor_phase, sensor_phase90 ));
     int i;
     for (i=sensor_phase90;i>0;i--) X3X3_SENSDCM_INC90 ;  
     if      (sensor_phase > 0) for (i=sensor_phase; i > 0; i--) {X3X3_SENSDCM_INC ; udelay(1); }
     else if (sensor_phase < 0) for (i=sensor_phase; i < 0; i++) {X3X3_SENSDCM_DEC ; udelay(1); }
     if (sensor->needReset & SENSOR_NEED_RESET_PHASE) schedule_this_pgm_func(thispars, onchange_initsensor);
   }
  if (nupdate)  setFramePars(thispars, nupdate, pars_to_update);  
  return 0;
}


int pgm_exposure   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  return 0;
}

int pgm_i2c        (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  X3X3_SEQ_SEND1(fpga_addr,   X313_I2C_CMD,  X3X3_SET_I2C_BYTES(thispars->pars[P_I2C_BYTES]+1) |
                                              X3X3_SET_I2C_DLY  (thispars->pars[P_I2C_QPERIOD]));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_I2C_CMD, (int) (X3X3_SET_I2C_BYTES(thispars->pars[P_I2C_BYTES]+1) | X3X3_SET_I2C_DLY  (thispars->pars[P_I2C_QPERIOD]))  ));

  return 0;
}



int pgm_window      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  return pgm_window_common (sensor,  thispars, prevpars, frame8);
}
int pgm_window_safe (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  return pgm_window_common (sensor,  thispars, prevpars, frame8);
}
inline int pgm_window_common (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  int dv,dh,bv,bh,width,height,timestamp_len,oversize,pfh,pf_stripes,ah, left,top,is_color;
  MDF3(printk(" frame8=%d\n",frame8));
  oversize=thispars->pars[P_OVERSIZE];
  is_color=1;
  struct frameparspair_t pars_to_update[18]; 
  int nupdate=0;

  switch (thispars->pars[P_COLOR] & 0x0f){
     case COLORMODE_MONO6:
     case COLORMODE_MONO4:
      is_color=0;
  } 
  if (FRAMEPAR_MODIFIED(P_FLIPH)) {
    if (unlikely((thispars->pars[P_FLIPH] & sensor->flips & 1)!=thispars->pars[P_FLIPH])) { 
       SETFRAMEPARS_SET(P_FLIPH, (thispars->pars[P_FLIPH] & sensor->flips & 1));
    }
  }
  if (FRAMEPAR_MODIFIED(P_FLIPV)) {
    if (unlikely((thispars->pars[P_FLIPV] & (sensor->flips>>1) & 1)!=thispars->pars[P_FLIPV])) { 
       SETFRAMEPARS_SET(P_FLIPV, (thispars->pars[P_FLIPV] & (sensor->flips >> 1 ) & 1));
    }
  }
  dh = thispars->pars[P_DCM_HOR];
  if (FRAMEPAR_MODIFIED(P_DCM_HOR)) {
    if (dh<1) dh=1; else if (dh>32) dh=32;
    while ((dh>1) && !(sensor->dcmHor  & (1 << (dh-1)))) dh--; 
    if (unlikely(dh!=thispars->pars[P_DCM_HOR])) SETFRAMEPARS_SET(P_DCM_HOR, dh);
  }
  dv = thispars->pars[P_DCM_VERT];
  if (FRAMEPAR_MODIFIED(P_DCM_VERT)) {
    if (dv<1) dv=1; else if (dv>32) dv=32;
    while ((dv>1) && !(sensor->dcmVert  & (1 << (dv-1)))) dv--; 
    if (unlikely(dv!=thispars->pars[P_DCM_HOR])) SETFRAMEPARS_SET(P_DCM_VERT, dv); 
  }
  bh = thispars->pars[P_BIN_HOR];
  if (FRAMEPAR_MODIFIED(P_BIN_HOR)) {
    if (bh<1) bh=1; else if (bh>dh) bh=dh;
    while ((bh>1) && !(sensor->binHor  & (1 << (bh-1)))) bh--; 
    if (unlikely(bh!=thispars->pars[P_BIN_HOR])) SETFRAMEPARS_SET(P_DCM_HOR, bh); 
  }
  bv = thispars->pars[P_BIN_VERT];
  if (FRAMEPAR_MODIFIED(P_BIN_VERT)) {
    if (bv<1) bv=1; else if (bv>dv) bv=dv;
    while ((bv>1) && !(sensor->binVert  & (1 << (bv-1)))) bv--; 
    if (unlikely(bv!=thispars->pars[P_BIN_VERT])) SETFRAMEPARS_SET(P_DCM_VERT, bv); 
  }
  timestamp_len = (((thispars->pars[P_PF_HEIGHT] >> 16) & 3)==2)? X313_TIMESTAMPLEN*dh : 0;
  width=thispars->pars[P_WOI_WIDTH];
  if ((!oversize) && (width > sensor->imageWidth)) width= sensor->imageWidth;
  width= (((width/dh) + timestamp_len)/X313_TILEHOR)*X313_TILEHOR-timestamp_len; 

  while (width < sensor->minWidth) width+=X313_TILEHOR;
  if (unlikely(thispars->pars[P_ACTUAL_WIDTH] != (width+timestamp_len))) {
       SETFRAMEPARS_SET(P_ACTUAL_WIDTH, width+timestamp_len); 
  }
  if (unlikely(thispars->pars[P_SENSOR_PIXH] != width+X313_MARGINS))
       SETFRAMEPARS_SET(P_SENSOR_PIXH,  width+X313_MARGINS); 
  width*=dh;
  if (unlikely(thispars->pars[P_WOI_WIDTH] != width))
       SETFRAMEPARS_SET(P_WOI_WIDTH, width);  

  pfh = (thispars->pars[P_PF_HEIGHT] & 0xffff);
  height=thispars->pars[P_WOI_HEIGHT];
//  pf_stripes;
  if(pfh > 0) {
     if (pfh < sensor->minHeight)  pfh =  sensor->minHeight;
     if (pfh & 1) pfh++;
     if (height > X313_MAXHEIGHT*dv) height=X313_MAXHEIGHT*dv;
     pf_stripes = height / (pfh * dv);
     if(pf_stripes < 1) pf_stripes = 1;
     if (unlikely(thispars->pars[P_SENSOR_PIXV] != pfh)) SETFRAMEPARS_SET(P_SENSOR_PIXV,  pfh);
  } else {
       if ((!oversize ) && (height > sensor->imageHeight)) height=sensor->imageHeight;
       height= ((height/dv)/X313_TILEVERT) * X313_TILEVERT; 

       while (height < sensor->minHeight) height+=X313_TILEVERT;
       if (unlikely(thispars->pars[P_SENSOR_PIXV] != height+X313_MARGINS))
           SETFRAMEPARS_SET(P_SENSOR_PIXV,  height+X313_MARGINS); 
       height*=dv;
       pf_stripes = 0;
       pfh = 0;
  }
  if (unlikely((thispars->pars[P_PF_HEIGHT] & 0xffff) != pfh))
        SETFRAMEPARS_SET(P_PF_HEIGHT, (thispars->pars[P_PF_HEIGHT] & 0xffff0000 ) | pfh );
  if (unlikely(thispars->pars[P_WOI_HEIGHT] != height))
        SETFRAMEPARS_SET(P_WOI_HEIGHT, height); 

  ah=height/dv;
  if (unlikely(thispars->pars[P_ACTUAL_HEIGHT] != ah))
        SETFRAMEPARS_SET(P_ACTUAL_HEIGHT, ah); 

  left = thispars->pars[P_WOI_LEFT];
  if (!oversize) { 
    if (is_color)                    left &= 0xfffe;
    if ((left + width + X313_MARGINS) > sensor->clearWidth) { 
         left = sensor->clearWidth - width - X313_MARGINS;
         if (is_color)               left &= 0xfffe;
    }
    if (left & 0x8000) left = 0;
  }
  if (unlikely(thispars->pars[P_WOI_LEFT] != left)) SETFRAMEPARS_SET(P_WOI_LEFT, left);

  top = thispars->pars[P_WOI_TOP];
  if (!oversize) { 
    if (is_color)                    top &= 0xfffe;
    if ((top + height + X313_MARGINS) > sensor->clearHeight) { 
         top = sensor->clearHeight - height - X313_MARGINS;
         if (is_color)               top &= 0xfffe;
    }
    if (top & 0x8000) top = 0;
  }
  if (unlikely(thispars->pars[P_WOI_TOP] != top)) SETFRAMEPARS_SET(P_WOI_TOP, top);
  if (nupdate)  setFramePars(thispars, nupdate, pars_to_update);  
  return 0;
}



int pgm_limitfps   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  struct frameparspair_t pars_to_update[8]; 
  int nupdate=0;
  int async=(thispars->pars[P_TRIG] & 4)?1:0;
  int cycles;  
  int min_period;  
  int period=0;
  cycles=thispars->pars[P_TILES]; 
#if USELONGLONG
  uint64_t ull_min_period;
  uint64_t ull_period;
#endif
  MDF9(printk(" tiles=%d(0x%x)\n",cycles,cycles));
  
  switch (thispars->pars[P_COLOR] & 0x0f){
     case COLORMODE_MONO6:
     case COLORMODE_COLOR:
     case COLORMODE_JP46:
     case COLORMODE_JP46DC:
     case COLORMODE_COLOR20:
        cycles*=6; 
        break;
     default:
        cycles*=4;
  } 
  cycles  *=64 *2; //cycles per frame (64 pixels/block, 2 clock cycles/pixel)
  MDF9(printk(" cycles=%d(0x%x)\n",cycles,cycles));
  cycles += thispars->pars[P_FPGA_XTRA]; // extra cycles needed for the compressor to start/finish the frame;
  MDF9(printk(" cycles with P_FPGA_XTRA =%d(0x%x)\n",cycles,cycles));


#if USELONGLONG
  ull_min_period=(((long long) cycles) * ((long long) thispars->pars[P_CLK_SENSOR]));
  __div64_32(&ull_min_period, thispars->pars[P_CLK_FPGA]);
  min_period= ull_min_period;
  MDF9(printk("min_period =%d(0x%x)\n",min_period,min_period));
//  min_period = (((long long) cycles) * ((long long) thispars->pars[P_CLK_SENSOR])) / ((long long) thispars->pars[P_CLK_FPGA]);
#else
  if (cycles <          (1<<16) ) {
     min_period = (cycles * (thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12);
  } else   if (cycles < (1<<18) ) {
     min_period = (((cycles>>2) * (thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12)) << 2 ;
  } else   if (cycles < (1<<20) ) {
     min_period = (((cycles>>4) * (thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12)) << 4 ;
  } else   if (cycles < (1<<22) ) {
     min_period = (((cycles>>6) * (thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12)) << 6 ;
  } else   if (cycles < (1<<24) ) {
     min_period = (((cycles>>8) * (thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12)) << 8 ;
  } else {
     min_period = (((cycles>>10) *(thispars->pars[P_CLK_SENSOR] >> 12)) / (thispars->pars[P_CLK_FPGA]>>12)) << 10 ;
  }
  MDF9(printk("min_period =%d(0x%x)\n",min_period,min_period));
#endif
  if (thispars->pars[P_FPSFLAGS]) {
#if USELONGLONG
    ull_period=(((long long) thispars->pars[P_CLK_SENSOR]) * (long long) 1000);
    __div64_32(&ull_period, thispars->pars[P_FP1000SLIM]);
    period= ull_period;
  MDF9(printk("period =%d(0x%x)\n",period,period));
//    period=(((long long) thispars->pars[P_CLK_SENSOR]) * (long long) 1000)/((long long) thispars->pars[P_FP1000SLIM]);
#else
    period=125*(( thispars->pars[P_CLK_SENSOR] << 3) / thispars->pars[P_FP1000SLIM]); 
  MDF9(printk("period =%d(0x%x)\n",period,period));
#endif
  }
  MDF1(printk(" period=%d\n",period));
  if ((thispars->pars[P_FPSFLAGS] & 1) && (period>min_period)) min_period=period;
  if (min_period != thispars->pars[P_PERIOD_MIN]) SETFRAMEPARS_SET(P_PERIOD_MIN, min_period);  
  if (((thispars->pars[P_FPSFLAGS] & 2)==0) || (period < min_period)) period=0x7fffffff; 
  if (period != thispars->pars[P_PERIOD_MAX]) SETFRAMEPARS_SET(P_PERIOD_MAX, period);         

  if (async && (thispars->pars[P_TRIG_PERIOD] >=256)) { // <256 - single trig
    if (thispars->pars[P_TRIG_PERIOD] < min_period) SETFRAMEPARS_SET(P_TRIG_PERIOD, min_period);  
    if ((thispars->pars[P_FPSFLAGS] & 2) && (thispars->pars[P_TRIG_PERIOD] > period)) {
       SETFRAMEPARS_SET(P_TRIG_PERIOD, period);  
    }
  }
  if (nupdate)  setFramePars(thispars, nupdate, pars_to_update);  

  return 0;
}

int pgm_gains      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  return 0;
}

int pgm_triggermode(struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  int async=(thispars->pars[P_TRIG] & 4)?1:0;
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_DCR0, X353_DCR0(SENSTRIGEN,async));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_DCR1, X353_DCR1(EARLYTRIG, (async && thispars->pars[P_EARLY_TIMESTAMP])?1:0));

  return 0;
}

int pgm_sensorin   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SENSFPN, X313_SENSFPN_D( \
                         (thispars->pars[P_FPGATEST]), \
                         (thispars->pars[P_FPNS]),  \
                         (thispars->pars[P_FPNM]),     \
                         ((thispars->pars[P_BITS]>8)?1:0), \
                          thispars->pars[P_SHIFTL]));

  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SENSFPN, (int) (X313_SENSFPN_D( \
                         (thispars->pars[P_FPGATEST]), \
                         (thispars->pars[P_FPNS]),  \
                         (thispars->pars[P_FPNM]),     \
                         ((thispars->pars[P_BITS]>8)?1:0), \
                          thispars->pars[P_SHIFTL]))));


  int n_scan_lines;
  if ((thispars->pars[P_PF_HEIGHT] & 0xffff)>0) n_scan_lines= \
       (thispars->pars[P_ACTUAL_HEIGHT] & 0xfff) | ((thispars->pars[P_ACTUAL_HEIGHT]/(thispars->pars[P_PF_HEIGHT] &  0xffff))<<16);
  else n_scan_lines= thispars->pars[P_ACTUAL_HEIGHT]+X313_MARGINS+thispars->pars[P_OVERLAP];
  X3X3_SEQ_SEND1 (fpga_addr,  X313_WA_NLINES, n_scan_lines);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_NLINES, (int) n_scan_lines));
  if (FRAMEPAR_MODIFIED(P_BAYER) || FRAMEPAR_MODIFIED(P_FLIPH) || FRAMEPAR_MODIFIED(P_FLIPV)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_DCR0, X353_DCR0(BAYER_PHASE,thispars->pars[P_BAYER] ^ ((thispars->pars[P_FLIPH] & 1) | ((thispars->pars[P_FLIPV] & 1)<<1)) ^ sensor->bayer)); 
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int)X313_WA_DCR0, (int)X353_DCR0(BAYER_PHASE,thispars->pars[P_BAYER] ^ ((thispars->pars[P_FLIPH] & 1) | ((thispars->pars[P_FLIPV] & 1)<<1)) ^ sensor->bayer) ));

  }
  return 0;
}

int pgm_sensorrun(struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_data=0;
  switch (thispars->pars[P_SENSOR_RUN] & 3) {
    case 1: fpga_data=4; break;
    case 2:
    case 3: fpga_data=5; break;
  }
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
// only start/single, stopping will be handled by the pgm_sensorstop
  if (fpga_data) {
     X3X3_SEQ_SEND1(fpga_addr,  X313_WA_TRIG, fpga_data);
     MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_TRIG, (int) fpga_data));
  }
  return 0;
}

int pgm_sensorstop (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_data=0;
  switch (thispars->pars[P_SENSOR_RUN] & 3) {
    case 1: fpga_data=4; break;
    case 2:
    case 3: fpga_data=5; break;
  }
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
// only start/single, stopping will be handled by the pgm_sensorstop
  if ((thispars->pars[P_SENSOR_RUN] & 3)==0){
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_TRIG, fpga_data);
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_TRIG, (int) fpga_data));
  }
  return 0;
}

int pgm_gamma      (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d, (getThisFrameNumber() & PARS_FRAMES_MASK)= %ld\n",frame8, getThisFrameNumber() & PARS_FRAMES_MASK));
  MDF3(printk(" frame8=%d, thispars->pars[P_GTAB_*]=0x%lx 0x%lx 0x%lx 0x%lx, thispars->pars[P_FRAME]=0x%lx"
              " get_locked_hash32(*)=0x%lx 0x%lx 0x%lx 0x%lx\n",
frame8, thispars->pars[P_GTAB_R],thispars->pars[P_GTAB_R+1],thispars->pars[P_GTAB_R+2],thispars->pars[P_GTAB_R+3],thispars->pars[P_FRAME],
get_locked_hash32(0),get_locked_hash32(1),get_locked_hash32(2),get_locked_hash32(3)));


  MDF16(printk(" frame8=%d, thispars->pars[P_GTAB_*]=0x%lx 0x%lx 0x%lx 0x%lx, thispars->pars[P_FRAME]=0x%lx\n",frame8, thispars->pars[P_GTAB_R],thispars->pars[P_GTAB_R+1],thispars->pars[P_GTAB_R+2],thispars->pars[P_GTAB_R+3],thispars->pars[P_FRAME]));
  if (frame8 >= PARS_FRAMES) return -1; 

#if 0
  if ((frame8>=0) && (frame8!=((getThisFrameNumber()+1) & PARS_FRAMES_MASK))) {
    MDF3(printk("too early\n"));
    return -ERR_PGM_TRYAGAINLATER;
  }
#endif
  int color, rslt;
  struct frameparspair_t pars_to_update[4]; 
  int nupdate=0;
  struct {
    unsigned short scale;
    unsigned short hash16;
  } gamma32;
  unsigned long * pgamma32= (unsigned long *) & gamma32;
  for (color=0; color<4; color++) {

     if (get_locked_hash32(color)!=thispars->pars[P_GTAB_R+color]) { 
       *pgamma32=thispars->pars[P_GTAB_R+color];
       rslt=set_gamma_table (gamma32.hash16, gamma32.scale, NULL,  GAMMA_MODE_HARDWARE, color); 
       if (rslt<=0) SETFRAMEPARS_SET(P_GTAB_R+color, get_locked_hash32(color)); 
     }
  }
  if (nupdate) {
     setFramePars(thispars, nupdate, pars_to_update);  
     MDF3(printk("had to restore back %d gamma tables (color components) \n",nupdate));
     return -1;
  }
  return 0;
}



int pgm_hist       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  struct {
    long left;
    long width;
    long top;
    long height;
  } hist_setup_data;
  struct frameparspair_t pars_to_update[4]={
   {P_HISTWND_LEFT, 0},
   {P_HISTWND_WIDTH, 0},
   {P_HISTWND_TOP, 0},
   {P_HISTWND_HEIGHT, 0}
  };
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  hist_setup_data.width=  ((thispars->pars[P_HISTWND_RWIDTH] * thispars->pars[P_ACTUAL_WIDTH])>>16) & 0xffe;
  if (hist_setup_data.width<2) hist_setup_data.width=2;
  else if (hist_setup_data.width > thispars->pars[P_ACTUAL_WIDTH]) hist_setup_data.width = thispars->pars[P_ACTUAL_WIDTH];
  hist_setup_data.left=  ((thispars->pars[P_HISTWND_RLEFT] * (thispars->pars[P_ACTUAL_WIDTH]-hist_setup_data.width)) >>16) & 0xffe;
  if (hist_setup_data.left> (thispars->pars[P_ACTUAL_WIDTH]-hist_setup_data.width)) hist_setup_data.left = thispars->pars[P_ACTUAL_WIDTH]-hist_setup_data.width;

  hist_setup_data.height=  ((thispars->pars[P_HISTWND_RHEIGHT] * thispars->pars[P_ACTUAL_HEIGHT])>>16) & 0xffe;
  if (hist_setup_data.height<2) hist_setup_data.height=2;
  else if (hist_setup_data.height > thispars->pars[P_ACTUAL_HEIGHT]) hist_setup_data.height = thispars->pars[P_ACTUAL_HEIGHT];
  hist_setup_data.top=  ((thispars->pars[P_HISTWND_RTOP] * (thispars->pars[P_ACTUAL_HEIGHT]-hist_setup_data.height)) >>16) & 0xffe;
  if (hist_setup_data.top > (thispars->pars[P_ACTUAL_HEIGHT]-hist_setup_data.height)) hist_setup_data.top = thispars->pars[P_ACTUAL_HEIGHT]-hist_setup_data.height;

  if ((hist_setup_data.left   != thispars->pars[P_HISTWND_LEFT]) ||
      (hist_setup_data.width  != thispars->pars[P_HISTWND_WIDTH]) ||
      (hist_setup_data.top    != thispars->pars[P_HISTWND_TOP]) ||
      (hist_setup_data.height != thispars->pars[P_HISTWND_HEIGHT])) {
      X3X3_SEQ_SEND1(fpga_addr,  X313_WA_HIST_LEFT,   hist_setup_data.left);
      X3X3_SEQ_SEND1(fpga_addr,  X313_WA_HIST_WIDTH,  hist_setup_data.width-2);
      X3X3_SEQ_SEND1(fpga_addr,  X313_WA_HIST_TOP,    hist_setup_data.top);
      X3X3_SEQ_SEND1(fpga_addr,  X313_WA_HIST_HEIGHT, hist_setup_data.height-2);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_HIST_LEFT,   (int) hist_setup_data.left));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_HIST_WIDTH,  (int) hist_setup_data.width-2));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_HIST_TOP,    (int) hist_setup_data.top));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_HIST_HEIGHT, (int) hist_setup_data.height-2));
      pars_to_update[0].val=hist_setup_data.left;
      pars_to_update[1].val=hist_setup_data.width;
      pars_to_update[2].val=hist_setup_data.top;
      pars_to_update[3].val=hist_setup_data.height;
     setFramePars(thispars, 4, pars_to_update);  
  } 
  return 0;
}


int pgm_aexp       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
//TODO:
  MDF3(printk(" frame8=%d\n",frame8));
  return 0;
}

int pgm_quality    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);

  if ((thispars->pars[P_COMPMOD_QTAB]=set_qtable_fpga(thispars->pars[P_QUALITY]))>=0) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD,   COMPCMD_QTAB(thispars->pars[P_COMPMOD_QTAB]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_COMP_CMD, (int) COMPCMD_QTAB(thispars->pars[P_COMPMOD_QTAB])));
    return 0;
  } else return -1;
}

int pgm_memsensor     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  int ntilex,ntiley,goodEOL,padlen, imgsz,sa;
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  ntilex=((thispars->pars[P_ACTUAL_WIDTH]+X313_MARGINS+7)>>3);
  ntiley=thispars->pars[P_ACTUAL_HEIGHT]+(((thispars->pars[P_PF_HEIGHT] & 0xffff)>0)?0:X313_MARGINS);
  MDF3(printk("ntilex=0x%x ntiley=0x%x\n",ntilex,ntiley));
  if ((thispars->pars[P_PF_HEIGHT] & 0xffff)==0) { 
    if(!thispars->pars[P_BGFRAME] && ((thispars->pars[P_FPNS]!=0) || (thispars->pars[P_FPNM]!=0))) {
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH1_CTL1, X313_SDCHAN_REG1(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1)));
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH1_CTL2, X313_SDCHAN_REG2(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1)));
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH1_CTL0, X313_SDCHAN_REG0(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1)));
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_EN_D(1)); 
       MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH1_CTL1, (int) X313_SDCHAN_REG1(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1))));
       MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH1_CTL2, (int) X313_SDCHAN_REG2(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1))));
       MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH1_CTL0, (int) X313_SDCHAN_REG0(0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1))));
       MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SD_MODE, (int) X313_CHN_EN_D(1)));

    } else  {
        X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_DIS_D(1));
        MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SD_MODE, (int) X313_CHN_DIS_D(1)));
    }
  } else  {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_DIS_D(1));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SD_MODE, (int) X313_CHN_DIS_D(1)));
  }

  if ((thispars->pars[P_BITS]==8) && (!thispars->pars[P_BGFRAME])) { 
    ntilex=((thispars->pars[P_ACTUAL_WIDTH]+X313_MARGINS+15)>>4);
    goodEOL=((thispars->pars[P_ACTUAL_WIDTH] & 0x0f) == 0) && ((thispars->pars[P_ACTUAL_WIDTH] & 0x1f0) != 0);
    if (goodEOL) ntilex--;
  MDF3(printk("ntilex=0x%x ntiley=0x%x goodEOL=0x%x\n",ntilex,ntiley,goodEOL));
  }
  MDF3(printk("ntilex=0x%x ntiley=0x%x\n",ntilex,ntiley));

  if (thispars->pars[P_OVERLAP]>0) ntiley=(ntiley<<1); 
  padlen=((ntilex+31)>>5) << 8;
//  imgsz=((padlen * (thispars->pars[P_ACTUAL_HEIGHT]+X313_MARGINS) * thispars->pars[P_PAGE_ACQ]) << ((thispars->pars(P_TRIG) & 1)?1:0)); /// mostly rotten too
  imgsz=padlen * ntiley;
  MDF3(printk("imgsz=0x%x, padlen=0x%x\n",imgsz,padlen));
  if (thispars->pars[P_IMGSZMEM]!= imgsz)  setFramePar(thispars, P_IMGSZMEM, imgsz);  
  sa=X313_MAP_FRAME + (imgsz * thispars->pars[P_PAGE_ACQ]);  
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH0_CTL1, X313_SDCHAN_REG1(0,1,1, sa, (ntilex-1), (ntiley-1)));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH0_CTL1, (int) X313_SDCHAN_REG1(0,1,1, sa, (ntilex-1), (ntiley-1))  ));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH0_CTL2, X313_SDCHAN_REG2(0,1,1, sa, (ntilex-1), (ntiley-1)));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH0_CTL2, (int) X313_SDCHAN_REG2(0,1,1, sa, (ntilex-1), (ntiley-1))  ));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH0_CTL0, X313_SDCHAN_REG0(0,1,1, sa, (ntilex-1), (ntiley-1))); 
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH0_CTL0, (int) X313_SDCHAN_REG0(0,1,1, sa, (ntilex-1), (ntiley-1))  ));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_EN_D(0));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SD_MODE, (int) X313_CHN_EN_D(0)  ));
  return 0;
}

int pgm_memcompressor (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  int ntilex,ntiley,sa,pf;
//  struct frameparspair_t * pars_to_update[4]={
  struct frameparspair_t pars_to_update[4]={
   {P_SDRAM_CHN20, 0},
   {P_SDRAM_CHN21, 0},
   {P_SDRAM_CHN22, 0},
   {P_TILES, 0}
  };
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
//  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  ntilex=((thispars->pars[P_ACTUAL_WIDTH]+X313_MARGINS-1)>>4);
  ntiley=thispars->pars[P_ACTUAL_HEIGHT]; 
  sa=X313_MAP_FRAME + ( thispars->pars[P_IMGSZMEM] * thispars->pars[P_PAGE_READ]); 
  pf=((thispars->pars[P_PF_HEIGHT] & 0xffff)>0)?1:0; // when mode==1, wnr means "photofinish" in fpga
  int depend=((thispars->pars[P_SENSOR_RUN] & 3)==SENSOR_RUN_STOP) ? 0 : 1;
  MDF9(printk(" thispars->pars[P_SENSOR_RUN]=0x%x,  depend=%d)\n", (int)thispars->pars[P_SENSOR_RUN], depend));
  pars_to_update[1].val=X313_SDCHAN_REG1(1,pf,depend, sa, (ntilex-1), (ntiley-16));
  pars_to_update[2].val=X313_SDCHAN_REG2(1,pf,depend, sa, (ntilex-1), (ntiley-16));
  pars_to_update[0].val=X313_SDCHAN_REG0(1,pf,depend, sa, (ntilex-1), (ntiley-16));
  pars_to_update[3].val=ntilex*(ntiley>>4);

  setFramePars(thispars, 4, pars_to_update);
  return 0;
}

int pgm_compmode   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (!jpeg_htable_is_programmed()) jpeg_htable_fpga_pgm ();
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  int comp_cmd=0;
  struct frameparspair_t pars_to_update[4]; 
  int nupdate=0;

  if (FRAMEPAR_MODIFIED(P_COLOR)) {
    switch (thispars->pars[P_COLOR] & 0x0f){
     case COLORMODE_MONO6:    comp_cmd |= COMPCMD_DEMOS(DEMOS_MONO6);    break;
     case COLORMODE_COLOR:    comp_cmd |= COMPCMD_DEMOS(DEMOS_COLOR18);  break;
     case COLORMODE_JP46:     comp_cmd |= COMPCMD_DEMOS(DEMOS_JP46);     break;
     case COLORMODE_JP46DC:   comp_cmd |= COMPCMD_DEMOS(DEMOS_JP46DC);   break;
     case COLORMODE_COLOR20:  comp_cmd |= COMPCMD_DEMOS(DEMOS_COLOR20);  break;
     case COLORMODE_JP4:      comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4);      break;
     case COLORMODE_JP4DC:    comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4DC);    break;
     case COLORMODE_JP4DIFF:  comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4DIFF);  break;
     case COLORMODE_JP4HDR:   comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4HDR);   break;
     case COLORMODE_JP4DIFF2: comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4DIFF2); break;
     case COLORMODE_JP4HDR2:  comp_cmd |= COMPCMD_DEMOS(DEMOS_JP4HDR2);  break;
     case COLORMODE_MONO4:    comp_cmd |= COMPCMD_DEMOS(DEMOS_MONO4);    break;
    } 
  }
  MDF3(printk("comp_cmd=0x%x\n",comp_cmd));
  if (FRAMEPAR_MODIFIED(P_COMPMOD_BYRSH)) {
    comp_cmd |= COMPCMD_BAYERSHIFT(thispars->pars[P_COMPMOD_BYRSH]);
  }

  if (FRAMEPAR_MODIFIED(P_COMPMOD_TILSH)) {
    comp_cmd |= COMPCMD_TILESHIFT(thispars->pars[P_COMPMOD_TILSH]);
  }

  if (FRAMEPAR_MODIFIED(P_COMPMOD_DCSUB)) {
    comp_cmd |= COMPCMD_DCSUB(thispars->pars[P_COMPMOD_DCSUB]);
  }

  if (FRAMEPAR_MODIFIED(P_FOCUS_SHOW)) {
    comp_cmd |= COMPCMD_FOCUS(thispars->pars[ P_FOCUS_SHOW]);
  }

  if (comp_cmd) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD, comp_cmd);
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_COMP_CMD, (int) comp_cmd));
  } else {
    MDF3(printk("  comp_cmd==0, does not need to be sent\n"));
  }
  if (FRAMEPAR_MODIFIED(P_COLOR_SATURATION_BLUE) || FRAMEPAR_MODIFIED(P_COLOR_SATURATION_RED)) {
    int csb=(thispars->pars[P_COLOR_SATURATION_BLUE]* DEFAULT_COLOR_SATURATION_BLUE)/100;
    int csr=(thispars->pars[P_COLOR_SATURATION_RED] * DEFAULT_COLOR_SATURATION_RED)/100;
    if (unlikely(csb>1023)) {
       csb=102300/DEFAULT_COLOR_SATURATION_BLUE;
       SETFRAMEPARS_SET(P_COLOR_SATURATION_BLUE, csb);
    }
    if (unlikely(csr>1023)) {
       csr=102300/DEFAULT_COLOR_SATURATION_RED;
       SETFRAMEPARS_SET(P_COLOR_SATURATION_RED, csr);
    }
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COLOR_SAT, ((DEFAULT_COLOR_SATURATION_BLUE*thispars->pars[P_COLOR_SATURATION_BLUE])/100) |
                               (((DEFAULT_COLOR_SATURATION_RED *thispars->pars[P_COLOR_SATURATION_RED])/100)<<12));

    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%lx)\n", (int)fpga_addr, (int) X313_WA_COLOR_SAT, (int)((DEFAULT_COLOR_SATURATION_BLUE*thispars->pars[P_COLOR_SATURATION_BLUE])/100) | (((DEFAULT_COLOR_SATURATION_RED *thispars->pars[P_COLOR_SATURATION_RED])/100)<<12)));


  }
  if (FRAMEPAR_MODIFIED(P_ZBINROUND)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_QUANTIZER_MODE,thispars->pars[P_ZBINROUND]);
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_QUANTIZER_MODE, (int)thispars->pars[P_ZBINROUND]));
  }

  if (nupdate)  setFramePars(thispars, nupdate, pars_to_update);  
  return 0;
}


int pgm_focusmode  (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  struct {
    long left;
    long right;
    long top;
    long bottom;
    long totalwidth;
    long filter_no;
    long show1;
  } focus_setup_data;
//  struct frameparspair_t * pars_to_update[5]={
  struct frameparspair_t pars_to_update[5]={
   {P_FOCUS_TOTWIDTH, 0},
   {P_FOCUS_LEFT, 0},
   {P_FOCUS_WIDTH, 0},
   {P_FOCUS_TOP, 0},
   {P_FOCUS_HEIGHT, 0}
  };
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= 0) return -1; 
  focus_setup_data.totalwidth=thispars->pars[P_ACTUAL_WIDTH]& 0xfff0; // anyway should be 16x
  focus_setup_data.show1=       thispars->pars[P_FOCUS_SHOW1];
  focus_setup_data.left=  ((((thispars->pars[P_RFOCUS_LEFT] * (0x10000-thispars->pars[P_RFOCUS_WIDTH])) >>16)* thispars->pars[P_ACTUAL_WIDTH])>>16) & 0xff8;
  focus_setup_data.right=(focus_setup_data.left+((thispars->pars[P_RFOCUS_WIDTH]*thispars->pars[P_ACTUAL_WIDTH])>>16) -8);
  if (focus_setup_data.right<0) {
    focus_setup_data.right=0;
    focus_setup_data.left=8;
  } else if (focus_setup_data.right >  0xfff) focus_setup_data.right = 0xfff;
  focus_setup_data.right &=0xff8;
  focus_setup_data.top=  ((((thispars->pars[P_RFOCUS_TOP] * (0x10000-thispars->pars[P_RFOCUS_HEIGHT])) >>16)* thispars->pars[P_ACTUAL_HEIGHT])>>16) & 0xff8;
  focus_setup_data.bottom=(focus_setup_data.top+((thispars->pars[P_RFOCUS_HEIGHT]*thispars->pars[P_ACTUAL_HEIGHT])>>16) -8);
  if (focus_setup_data.bottom<0) {
   focus_setup_data.bottom=0;
   focus_setup_data.top=8;
  } else if (focus_setup_data.bottom >  0xfff) focus_setup_data.bottom = 0xfff;
  focus_setup_data.bottom &=0xff8;
  focus_setup_data.filter_no=thispars->pars[P_FOCUS_FILTER];
  if   (focus_setup_data.filter_no > 14) focus_setup_data.filter_no=14;
  if ((focus_setup_data.totalwidth!=thispars->pars[P_FOCUS_TOTWIDTH]) ||
      (focus_setup_data.left   != thispars->pars[P_FOCUS_LEFT]) ||
      (focus_setup_data.right  != (focus_setup_data.left+thispars->pars[P_FOCUS_WIDTH] -8)) ||
      (focus_setup_data.top    != thispars->pars[P_FOCUS_TOP]) ||
      (focus_setup_data.bottom != (focus_setup_data.top+thispars->pars[P_FOCUS_HEIGHT] -8)) ||
      FRAMEPAR_MODIFIED(P_FOCUS_FILTER) ||
      FRAMEPAR_MODIFIED(P_FOCUS_SHOW1) ) {
     fpga_table_write_nice (CX313_FPGA_TABLES_FOCUSPARS, sizeof(focus_setup_data)/sizeof(focus_setup_data.left), (unsigned long *) &focus_setup_data);
     pars_to_update[0].val=focus_setup_data.totalwidth;
     pars_to_update[1].val=focus_setup_data.left;
     pars_to_update[2].val=focus_setup_data.right-focus_setup_data.left+8;
     pars_to_update[3].val=focus_setup_data.top;
     pars_to_update[4].val=focus_setup_data.bottom-focus_setup_data.top+8;

     setFramePars(thispars, 5, pars_to_update);  
  } 
  return 0;
}



int pgm_trigseq    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  if (frame8 >= 0) return -1; 
//  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  if (FRAMEPAR_MODIFIED(P_TRIG_CONDITION)) {
//    X3X3_SEQ_SEND1(fpga_addr, X313_WA_CAMSYNCTRIG, thispars->pars[P_TRIG_CONDITION]);
//    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_CAMSYNCTRIG, (int)thispars->pars[P_TRIG_CONDITION]));
    port_csp0_addr[X313_WA_CAMSYNCTRIG] = thispars->pars[P_TRIG_CONDITION];
    MDF3(printk("  port_csp0_addr[0x%x]=0x%x\n",  (int) X313_WA_CAMSYNCTRIG, (int)thispars->pars[P_TRIG_CONDITION]));
  }
  if (FRAMEPAR_MODIFIED(P_TRIG_DELAY)) {
//    X3X3_SEQ_SEND1(fpga_addr, X313_WA_CAMSYNCDLY, thispars->pars[P_TRIG_DELAY]);
//    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_CAMSYNCDLY, (int) thispars->pars[P_TRIG_DELAY]));
    port_csp0_addr[X313_WA_CAMSYNCDLY] = thispars->pars[P_TRIG_DELAY];
    MDF3(printk("  port_csp0_addr[0x%x]=0x%x\n",  (int) X313_WA_CAMSYNCDLY, (int) thispars->pars[P_TRIG_DELAY]));
  }
  if (FRAMEPAR_MODIFIED(P_TRIG_OUT)) {
//    X3X3_SEQ_SEND1(fpga_addr, X313_WA_CAMSYNCOUT, thispars->pars[P_TRIG_OUT]);
//    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_CAMSYNCOUT, (int) thispars->pars[P_TRIG_OUT]));
    port_csp0_addr[X313_WA_CAMSYNCOUT] = thispars->pars[P_TRIG_OUT];
    MDF3(printk("  port_csp0_addr[0x%x]=0x%x\n",  (int) X313_WA_CAMSYNCOUT, (int) thispars->pars[P_TRIG_OUT]));
  }
  if (FRAMEPAR_MODIFIED(P_TRIG_PERIOD)) {
//    X3X3_SEQ_SEND1(fpga_addr, X313_WA_CAMSYNCPER, thispars->pars[P_TRIG_PERIOD]);
//    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_CAMSYNCPER, (int)thispars->pars[P_TRIG_PERIOD]));
    port_csp0_addr[X313_WA_CAMSYNCPER] = thispars->pars[P_TRIG_PERIOD];
    MDF3(printk("  port_csp0_addr[0x%x]=0x%x\n",  (int) X313_WA_CAMSYNCPER, (int)thispars->pars[P_TRIG_PERIOD]));
  }
  return 0;
}


int pgm_irq     (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  X3X3_SEQ_SEND1(fpga_addr,   X313_WA_SMART_IRQ,  (2 | ((thispars->pars[P_IRQ_SMART] & 1)?1:1)) | \
                                                  (8 | ((thispars->pars[P_IRQ_SMART] & 2)?4:0)));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SMART_IRQ, (int) ( (2 | ((thispars->pars[P_IRQ_SMART] & 1)?1:1)) | \
                                                  (8 | ((thispars->pars[P_IRQ_SMART] & 2)?4:0)))));

  return 0;
}

//#define P_CALLASAP       107 // bitmask - what functions work only in the current frame (ASAP) mode 
//G_CALLNASAP
int pgm_recalcseq  (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  int safe= thispars->pars[P_SKIP_FRAMES]?1:0; 
  int async=(thispars->pars[P_TRIG] & 4)?1:0;
  int nooverlap=(thispars->pars[P_TRIG] & 8)?1:0;
  int i,b,d;
  struct frameparspair_t pars[5]= {
    {G_CALLNEXT+1,0},
    {G_CALLNEXT+2,0},
    {G_CALLNEXT+3,0},
    {G_CALLNEXT+4,0},
    {G_CALLNASAP,0}};
  MDF3(printk(" frame8=%d, safe=%d, async=%d, nooverlap=%d\n",frame8, safe, async, nooverlap));
  for (i=0; i < (sizeof(ahead_tab)/sizeof(ahead_tab[0])); i+=7) {
    b=ahead_tab[i];
    d=ahead_tab[i+1+(nooverlap?5:(1+((async?2:0)+(safe?1:0))))]; 
    if ((d>0) && (d <=4 )) {
      pars[d-1].val |= (1<<b);
    }
    if (!ahead_tab[i+1]) { 
      pars[4].val |= (1<<b);
    }

  }

  for (i=2; i>=0; i--) {
      pars[i].val |= pars[i+1].val;
  }
  GLOBALPARS(G_CALLNEXT+1)=pars[0].val;
  GLOBALPARS(G_CALLNEXT+2)=pars[1].val;
  GLOBALPARS(G_CALLNEXT+3)=pars[2].val;
  GLOBALPARS(G_CALLNEXT+4)=pars[3].val;
  GLOBALPARS(G_CALLNASAP)= pars[4].val;
  return 0;
}

int pgm_comprestart(struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 

  if (thispars->pars[P_COMPRESSOR_RUN]==0) return 0; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL1,   thispars->pars[P_SDRAM_CHN21]);
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL2,   thispars->pars[P_SDRAM_CHN22]);
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL0,   thispars->pars[P_SDRAM_CHN20]);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH2_CTL1,   (int) thispars->pars[P_SDRAM_CHN21]));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH2_CTL2,   (int) thispars->pars[P_SDRAM_CHN22]));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SDCH2_CTL0,   (int) thispars->pars[P_SDRAM_CHN20]));

  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_EN_D(0));
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_SD_MODE, (int) X313_CHN_EN_D(0)));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_MCUNUM, thispars->pars[P_TILES]-1);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_MCUNUM, (int) thispars->pars[P_TILES]-1));
  X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD, (thispars->pars[P_COMPRESSOR_RUN]==2) ? COMPCMD_RUN : COMPCMD_SINGLE);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_COMP_CMD, (int) ((thispars->pars[P_COMPRESSOR_RUN]==2) ? COMPCMD_RUN : COMPCMD_SINGLE)));
  return 0;
}

int pgm_compstop    (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  MDF3(printk(" frame8=%d\n",frame8));
//  if (frame8 & ~PARS_FRAMES_MASK) return -1; /// wrong frame (can be only -1 or 0..7)
  if (frame8 >= PARS_FRAMES) return -1; 
  X3X3_SEQ_SEND1(fpga_addr, X313_WA_COMP_CMD, COMPCMD_STOP);
  MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int)  X313_WA_COMP_CMD, (int) COMPCMD_STOP));
  return 0;
}


int pgm_compctl   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d, prevpars->pars[P_COMPRESSOR_RUN]=%d, thispars->pars[P_COMPRESSOR_RUN]=%d \n",frame8, (int) prevpars->pars[P_COMPRESSOR_RUN], (int) thispars->pars[P_COMPRESSOR_RUN]));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  if ((prevpars->pars[P_COMPRESSOR_RUN]==0) && (thispars->pars[P_COMPRESSOR_RUN]!=0)) { 

    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL1,   thispars->pars[P_SDRAM_CHN21]);
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL2,   thispars->pars[P_SDRAM_CHN22]);
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SDCH2_CTL0,   thispars->pars[P_SDRAM_CHN20]);

    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_SD_MODE, X313_CHN_EN_D(2));
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_MCUNUM, thispars->pars[P_TILES]-1);
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_SDCH2_CTL1, (int)thispars->pars[P_SDRAM_CHN21]));
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_SDCH2_CTL2, (int)thispars->pars[P_SDRAM_CHN22]));
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_SDCH2_CTL0, (int)thispars->pars[P_SDRAM_CHN20]));
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_SD_MODE, (int)thispars->pars[P_SDRAM_CHN21]));
    MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int)X313_WA_MCUNUM, (int)(thispars->pars[P_TILES]-1)));
  }
  if ((prevpars->pars[P_COMPRESSOR_RUN] != thispars->pars[P_COMPRESSOR_RUN]) || (thispars->pars[P_COMPRESSOR_RUN]==COMPRESSOR_RUN_SINGLE))  
    switch (thispars->pars[P_COMPRESSOR_RUN]) {
     case COMPRESSOR_RUN_STOP:
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD, COMPCMD_STOP);
       MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int) X313_WA_COMP_CMD, (int) COMPCMD_STOP));
      break;
     case COMPRESSOR_RUN_SINGLE:
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD, COMPCMD_SINGLE);
       if (!x313_is_dma_on()) x313_dma_start();
       MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int) X313_WA_COMP_CMD, (int) COMPCMD_SINGLE));
       break;
     case COMPRESSOR_RUN_CONT:
       X3X3_SEQ_SEND1(fpga_addr,  X313_WA_COMP_CMD, COMPCMD_RUN);
       if (!x313_is_dma_on()) x313_dma_start();
       MDF9(printk(" X3X3_SEQ_SEND1(0x%x,  0x%x,  0x%x)\n", (int)fpga_addr, (int) X313_WA_COMP_CMD, (int) COMPCMD_RUN));
       break;
    }
  return 0;
}


int pgm_gammaload  (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  struct frameparspair_t pars_to_update[4]; 
  int nupdate=0;
  MDF3(printk(" frame8=%d, (getThisFrameNumber() & PARS_FRAMES_MASK)= %ld, thispars->pars[P_GTAB_R]=0x%lx, thispars->pars[P_FRAME]=0x%lx\n",frame8, getThisFrameNumber() & PARS_FRAMES_MASK, thispars->pars[P_GTAB_R],thispars->pars[P_FRAME]));

//  framepars[frame8 & PARS_FRAMES_MASK].functions |= 1 << func_num;
  struct framepars_t * nextspars=&framepars[(thispars->pars[P_FRAME]+1) & PARS_FRAMES_MASK];
  MDF3(printk(" nextframe=%d, nextspars->pars[P_GTAB_R]=0x%lx, nextspars->pars[P_FRAME]=0x%lx\n",(int) ((thispars->pars[P_FRAME]+1) & PARS_FRAMES_MASK), nextspars->pars[P_GTAB_R], nextspars->pars[P_FRAME]));
  MDF16(printk(" nextframe=%d, nextspars->pars[P_GTAB_R]=0x%lx, nextspars->pars[P_FRAME]=0x%lx\n",(int) ((thispars->pars[P_FRAME]+1) & PARS_FRAMES_MASK), nextspars->pars[P_GTAB_R], nextspars->pars[P_FRAME]));
  if (frame8 >= 0) return -1; 
  int color, rslt;
  struct {
    unsigned short scale;
    unsigned short hash16;
  } gamma32;
  unsigned long * pgamma32= (unsigned long *) & gamma32;
  unsigned long *gtable;
  int need_pgm=0;
  for (color=0; color<4; color++) if (get_locked_hash32(color)!=thispars->pars[P_GTAB_R+color]) need_pgm++;
  if (need_pgm) {
    for (color=0; color<4; color++) {
      *pgamma32=thispars->pars[P_GTAB_R+color];
      rslt=set_gamma_table (gamma32.hash16, gamma32.scale, NULL,  GAMMA_MODE_HARDWARE | GAMMA_MODE_LOCK, color); 

      if ((gtable= get_gamma_fpga(color))) fpga_table_write_nice (CX313_FPGA_TABLES_GAMMA + (color * 256), 256, gtable);
      if (rslt <= 0) SETFRAMEPARS_SET(P_GTAB_R+color, get_locked_hash32(color)); 
    }
    MDF3(printk("need_pgm=%d, get_locked_hash32(*)=0x%lx 0x%lx 0x%lx 0x%lx\n",need_pgm,get_locked_hash32(0),get_locked_hash32(1),get_locked_hash32(2),get_locked_hash32(3)));
  }
  if (nupdate)  {
     setFramePars(thispars, nupdate, pars_to_update);  
     MDF3(printk("had to restore back %d gamma tables (color components) \n",nupdate));
     return -1;
  }
  return 0;
}

int pgm_sensorregs   (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  return 0;
}


int pgm_prescal       (struct sensor_t * sensor,  struct framepars_t * thispars, struct framepars_t * prevpars, int frame8) {
  MDF3(printk(" frame8=%d\n",frame8));
  if (frame8 >= PARS_FRAMES) return -1; 
  int fpga_addr=(frame8 <0) ? X313_SEQ_ASAP : (X313_SEQ_FRAME0+frame8);
  if (FRAMEPAR_MODIFIED(P_VIGNET_AX)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_AX(thispars->pars[P_VIGNET_AX]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_AX(thispars->pars[P_VIGNET_AX])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_AY)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_AY(thispars->pars[P_VIGNET_AY]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_AY(thispars->pars[P_VIGNET_AY])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_C)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_C(thispars->pars[P_VIGNET_C]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_C(thispars->pars[P_VIGNET_C])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_BX)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_BX(thispars->pars[P_VIGNET_BX]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_BX(thispars->pars[P_VIGNET_BX])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_BY)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_BY(thispars->pars[P_VIGNET_BY]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_BY(thispars->pars[P_VIGNET_BY])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_ZERIN)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_FATZERO_IN(thispars->pars[P_VIGNET_ZERIN]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_FATZERO_IN(thispars->pars[P_VIGNET_ZERIN])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_ZEROUT)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_FATZERO_OUT(thispars->pars[P_VIGNET_ZEROUT]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_FATZERO_OUT(thispars->pars[P_VIGNET_ZEROUT])));
  }
  if (FRAMEPAR_MODIFIED(P_VIGNET_SHL)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_POSTSCALE(thispars->pars[P_VIGNET_SHL]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_POSTSCALE(thispars->pars[P_VIGNET_SHL])));
  }
  if (FRAMEPAR_MODIFIED(P_DGAINR)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_SCALES(0, thispars->pars[P_DGAINR]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_SCALES(0,thispars->pars[P_DGAINR])));
  }
  if (FRAMEPAR_MODIFIED(P_DGAING)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_SCALES(1, thispars->pars[P_DGAING]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_SCALES(1,thispars->pars[P_DGAING])));
  }
  if (FRAMEPAR_MODIFIED(P_DGAINGB)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_SCALES(2, thispars->pars[P_DGAINGB]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_SCALES(2,thispars->pars[P_DGAINGB])));
  }
  if (FRAMEPAR_MODIFIED(P_DGAINB)) {
    X3X3_SEQ_SEND1(fpga_addr,  X313_WA_LENSCORR, X313_LENS_SCALES(3, thispars->pars[P_DGAINB]));
    MDF3(printk("  X3X3_SEQ_SEND1(0x%x,0x%x, 0x%x)\n", fpga_addr,  (int) X313_WA_LENSCORR, (int)X313_LENS_SCALES(3,thispars->pars[P_DGAINB])));
  }
  return 0;
}

---