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

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : cc353.c
*! DESCRIPTION: TBD
*! Copyright (C) 2002-2007 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: cc353.c,v $
*!  Revision 1.32  2008/07/23 02:27:12  elphel
*!  fixed hardware i2c bug - now 3MPix seem to work
*!
*!  Revision 1.31  2008/05/02 15:16:58  elphel
*!  changed to hardware i2c writes, added P_OVERSIZE parameter to be able to read sensor with the dark pixels
*!
*!  Revision 1.30  2008/05/01 01:28:57  elphel
*!  hardware i2c control - macros, variables
*!
*!  Revision 1.29  2008/04/25 21:30:12  elphel
*!  implemented frame delay for the parameters, made Exif exposure to match the frame it is applied to
*!
*!  Revision 1.28  2008/04/20 06:49:40  elphel
*!  cleanup, bug fixes
*!
*!  Revision 1.27  2008/04/16 20:33:23  elphel
*!  driver cleanup, removed some duplicate actions, working on better recovery after parameter modification
*!
*!  Revision 1.26  2008/04/11 22:57:02  elphel
*!  added "histogram" tasklet on/off control, removed extra local_irq_disable()
*!
*!  Revision 1.25  2008/04/07 09:09:31  elphel
*!  Changes to handle Exif
*!
*!  Revision 1.24  2008/03/20 22:29:30  elphel
*!  added trigger-related code and parameters
*!
*!  Revision 1.23  2008/02/12 21:53:19  elphel
*!  Modified I2c to support multiple buses, added raw access (no address registers) and per-slave protection bitmasks
*!
*!  Revision 1.22  2008/02/01 04:52:08  elphel
*!  Fixed focus visualization code in FPGA and related software
*!
*!  Revision 1.21  2008/01/27 06:25:30  elphel
*!  driver update for focus processing
*!
*!  Revision 1.20  2008/01/25 07:15:15  elphel
*!  7.1.7.8 - added fpga code FPGA code (and related software) to facilitate focusing
*!
*!  Revision 1.19  2008/01/12 06:53:23  elphel
*!  7.1.7.2 - added elphel_autoexposure_get() function to elphel php extension
*!
*!  Revision 1.18  2008/01/11 07:49:12  elphel
*!  added setting the autoexposure parameters for PHP
*!
*!  Revision 1.17  2008/01/11 01:28:23  elphel
*!  7.1.7.1 - working on autoexposure to make it use the same P_* parameters.
*!
*!  Revision 1.16  2008/01/10 02:45:02  elphel
*!  Fixed wrong frame time calculation
*!
*!  Revision 1.15  2008/01/07 08:56:44  elphel
*!  Temporary fix to "broken" images
*!
*!  Revision 1.14  2007/12/13 06:47:55  elphel
*!  Fixed my stupid cache/mmap bug I blamed Axis for
*!
*!  Revision 1.13  2007/12/13 02:47:15  elphel
*!  Fixed old driver bug (related to sensor reset), changed cache_flush for PHP extension
*!
*!  Revision 1.12  2007/12/09 05:58:54  elphel
*!  comments
*!
*!  Revision 1.11  2007/12/05 22:01:21  elphel
*!  added handling etrax fs mmap cach problem when communicating between PHP extension and the driver
*!
*!  Revision 1.10  2007/12/03 08:28:46  elphel
*!  Multiple changes, mostly cleanup
*!
*!  Revision 1.9  2007/11/30 06:46:12  elphel
*!  added mmap to parameters array, starting programSensor(nonstop) from overloaded lseek (,,SEEK_END)
*!
*!  Revision 1.8  2007/11/14 00:57:04  spectr_rain
*!  fix FPS on streamer interface
*!
*!  Revision 1.7  2007/11/04 05:49:31  elphel
*!  fixed mmap/caching bug - (that seems to be a known Axis one)
*!
*!  Revision 1.6  2007/11/01 18:59:37  elphel
*!  debugging mmap/caching problems
*!
*!  Revision 1.5  2007/10/27 00:55:32  elphel
*!  untested revision - need to go
*!
*!  Revision 1.4  2007/10/16 20:04:38  elphel
*!  debug for sensor phase, starting programSensor from write php
*!
*!  Revision 1.3  2007/10/11 06:41:35  elphel
*!  Added support for lseek -  ioctl alternatives to control compressor/image acquisition to circbuf
*!
*!  Revision 1.2  2007/10/10 23:33:32  elphel
*!  fixed bugs found by Spectr
*!
*!  Revision 1.1.1.1  2007/10/02 21:09:15  elphel
*!  This is a fresh tree based on elphel353-2.10
*!
*!  Revision 1.16  2007/10/02 19:39:55  elphel
*!  Bug fix, added notes for the future
*!
*!  Revision 1.15  2007/09/30 07:07:27  elphel
*!  only disabled debug output
*!
*!  Revision 1.14  2007/09/30 03:19:56  elphel
*!  Cleanup, fixed broken acquisition of individual JPEG images into circbuf (in mode 7)
*!
*!  Revision 1.13  2007/09/29 18:33:29  elphel
*!  Split cxdma.c - /dev/circbuf is now in a separate circbuf.c file. New device driver does not support ioctl, so some curernt applications are updated to use other drivers to control the camera
*!
*!  Revision 1.11  2007/09/19 17:47:30  elphel
*!  P_FPSLM is updated in non-stop mode (so it can be updated and read back from the camera in camvc)
*!
*!  Revision 1.10  2007/09/19 00:34:20  elphel
*!  support for frame rate limiting, disabled extra debug  messages
*!
*!  Revision 1.9  2007/09/18 06:09:22  elphel
*!  support for merged P_FLIP, support fro P_FPSLM (fps limit mode) that allow to limit FPS (upper limit) and maintain FPS (lower limit) preventing exposure time to exceed one divided by fps limit
*!
*!  Revision 1.8  2007/08/27 04:46:16  elphel
*!  Restoring JP4 format (option "j" in ccam.cgi "opt=" parameter). FPGA code for this mode is not fixed yet (but it does something different than in modes color & mono).
*!
*!  Revision 1.7  2007/08/17 10:23:17  spectr_rain
*!  switch to GPL3 license
*!
*!  Revision 1.6  2007/07/20 10:17:44  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.14  2007/07/13 20:54:07  elphel
*!  fixed operation of 10347 board to match changes in FPGA/drivers made fro EMI reduction of the 353 cameras
*!
*!  Revision 1.13  2007/07/10 06:08:14  elphel
*!  Adding possibility to read/write sensor parameters, increasing number from 64 to 1024.
*!  Now writing to first 4096 bytes of the /dev/sensorpars will write imageParams array, reading from the same first 4096 bytes will read imageParams array, next 4096 bytes - imageParamsW
*!
*!  Revision 1.12  2007/07/10 00:12:21  elphel
*!  Fixed bug that zeroed sensor.margins
*!
*!  Revision 1.11  2007/07/09 21:10:13  elphel
*!  Reducing EMI from the sensor front end cable by reducing the drive strengths on the lines. Improving phase adjustment (and phase error measurements) for the sensors. Dealing with the delayed (with respect to pixel data) line/frame valid signals in MT9P001 sensors
*!
*!  Revision 1.10  2007/06/28 02:27:05  elphel
*!  1) Added code to enable communication with sensor board FPGA over longer cable
*!  2) Rewrote the histogram module to support 96MHz. It now uses doubled pixel clock.
*!
*!  Revision 1.9  2007/06/18 07:57:24  elphel
*!  Fixed bug working with MT9P031 - added sensor reset/reinit after frequency change
*!
*!  Revision 1.8  2007/04/19 20:15:25  elphel
*!  added KAI-11000/KAI-11002 basic support
*!
*!  Revision 1.7  2007/04/18 21:13:36  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.6  2007/04/18 21:02:06  elphel
*!  working on KAI-11002 support
*!
*!  Revision 1.5  2007/04/09 17:32:23  spectr_rain
*!  enable gamms, scale and histograms
*!
*!  Revision 1.4  2007/04/05 21:00:28  spectr_rain
*!  remove trigger check in IRQ handler
*!
*!  Revision 1.3  2007/04/04 03:55:22  elphel
*!  Improved i2c, added i2c as character devices (to use from php)
*!
*!  Revision 1.2  2007/03/25 10:14:23  elphel
*!  Accommodating 10359 board
*!
*!  Revision 1.1.1.1  2007/02/23 10:11:48  elphel
*!  initial import into CVS
*!
*!  Revision 1.16  2006/11/28 18:33:26  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.15  2006/11/27 17:35:32  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.14  2006/11/24 22:59:49  spectr_rain
*!  fix output data counter from FPGA
*!
*!  Revision 1.13  2006/11/01 18:49:57  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.12  2006/09/19 16:22:14  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.11  2006/09/02 22:04:17  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.10  2006/09/02 00:19:49  spectr_rain
*!  lock sensor while readrawimage
*!
*!  Revision 1.9  2006/09/01 18:54:40  spectr_rain
*!  some fixes for /dev/ccam_img (image.raw)
*!
*!  Revision 1.8  2006/08/30 15:56:20  spectr_rain
*!  unlock manual exposition when autoexp disabled
*!
*!  Revision 1.7  2006/08/29 18:06:58  spectr_rain
*!  6.5.2
*!
*!  Revision 1.5  2006/07/17 12:22:42  spectr_rain
*!  enable autoexposition
*!
*!  Revision 1.4  2006/07/12 23:02:00  spectr_rain
*!  disable gistogramm tables apply
*!
*!  Revision 1.3  2006/07/12 07:06:43  elphel
*!  fixed a bug introduced in 333 code (was not in 313/323) that make driver be satisfied with no-sensor and do not try to reinit it during each file open.
*!
*!  Revision 1.2  2006/07/12 06:03:16  elphel
*!  bug fix
*!
*!  Revision 1.1.1.1  2006/07/11 19:15:02  spectr_rain
*!  unwork with less than 5MPx Micron sensor, initial branch
*!
*!  Revision 1.26  2006/02/22 18:03:56  spectr_rain
*!  restore normal autoexp work in continuous mode
*!
*!  Revision 1.25  2006/02/22 09:06:46  elphel
*!  Made ccam.cgi return last image from the buffer when streamer is running. Same as acquireing image, with "-" in the options, i.e. "admin-bin/ccam.cgi?opt=vhcxy-" (all parameters will be ignored)
*!
*!  Revision 1.24  2006/02/22 05:07:51  elphel
*!  seems it was an error - closing /dev/circbuf was zeroing minors[p] - it did not let access to circular buffer while streamer was running
*!
*!  Revision 1.23  2006/02/12 17:35:00  spectr_rain
*!  fix mutex deadlock
*!
*!  Revision 1.22  2006/02/08 01:53:56  spectr_rain
*!  fix broken mutex in check of down_interruptible
*!
*!  Revision 1.21  2006/02/03 20:40:40  spectr_rain
*!  use one gain for all colors
*!
*!  Revision 1.20  2006/01/22 09:18:40  elphel
*!  fixed problem with "gamma" gains - when {r,b}scale was <1.0, it reduced the other gains proportionally but still left this one, so effectively it was changing scale to the square of the value
*!
*!  Revision 1.19  2006/01/17 06:44:49  elphel
*!  1. changed interrupt tasklets call - no deadlocks since
*!  2. fixed bug so resetting sensor is possible (ccam.cgi?resetsensor=1)
*!
*!  Revision 1.18  2006/01/12 15:35:29  spectr_rain
*!  change color canal scale limits
*!
*!  Revision 1.17  2006/01/11 12:43:56  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.16  2006/01/11 12:19:54  spectr_rain
*!  add IO_CCAM_PINS_(READ|WRITE) ioctl
*!
*!  Revision 1.15  2006/01/05 05:35:19  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.14  2006/01/05 05:13:12  spectr_rain
*!  new sensitivity/scale iface
*!
*!  Revision 1.13  2006/01/05 00:01:21  elphel
*!  fixed hang-up - removed restarting a frame that was sometimes hanging a sensor until reset
*!
*!  Revision 1.12  2006/01/02 23:21:24  elphel
*!  modified with/for Kodak sensor
*!
*!  Revision 1.11  2005/12/15 05:18:13  elphel
*!  FPGA to accommodate USB controller, vector interrupts, 6 i/o pins contorl
*!
*!  Revision 1.10  2005/11/29 23:43:24  spectr_rain
*!  fix autoexpose with streamers
*!
*!  Revision 1.9  2005/11/29 09:13:00  spectr_rain
*!  add autoexposure
*!
*!  Revision 1.8  2005/11/23 05:11:47  spectr_rain
*!  add done_compress IRQ bottom half
*!
*!  Revision 1.7  2005/09/10 23:33:22  elphel
*!  Support of realtime clock and timestamps in the images
*!
*!  Revision 1.6  2005/09/06 03:40:37  elphel
*!  changed parameters, added support for the photo-finish mode
*!
*!  Revision 1.5  2005/08/27 05:16:27  elphel
*!  binning
*!
*!  Revision 1.4  2005/08/27 00:46:39  elphel
*!  bayer control with &byr=
*!
*!  Revision 1.3  2005/08/26 02:59:06  elphel
*!  working on histogram
*!
*!  Revision 1.2  2005/05/10 21:08:49  elphel
*!  *** empty log message ***
*!
*/
//TODO: remove sensor i2c communication from this file - move it to sensor driver
/****************** INCLUDE FILES SECTION ***********************************/

#define USE_HARDWARE_I2C y
#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/poll.h>
#include <linux/interrupt.h>
#include <linux/time.h>

#include <asm/system.h>
//#include <asm/svinto.h> obsolete

//#include <asm/arch/hwregs/reg_map.h>
//#include <asm/arch/hwregs/reg_rdwr.h>
#include <asm/arch/hwregs/intr_vect.h> // EXT_INTR_VECT
//#include <asm/arch/hwregs/intr_vect_defs.h>
#include <asm/arch/hwregs/intr_vect_defs.h>


#include <asm/io.h>

#include <asm/irq.h>

#include <asm/delay.h>
#include <asm/uaccess.h>

#include <asm/arch/cache.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 "x3x3.h"
#include "cc3x3.h"
#include "cxsdram.h"
#include "cci2c.h"
#include "cxdma.h"
#include "circbuf.h"

#include "fpgaconfi2c.h"  //to control clocks

#include "hist.h"
#include "exif353.h"

// make conditional later
#ifdef CONFIG_ETRAX_323
#include "sensorfpgajtag.h"
#endif
#ifdef CONFIG_ETRAX_ELPHEL_MCP
 #include "ccmcp.h"
#else
 #define MCPpresent() 0
 #define MCP_open(inode,filp) -1
 #define MCP_lseek(file,offset,orig) 0
 #define MCP_read(file,buf,count,off) 0


 #define MCP_write(file,buf,count,off) 0
#endif

#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
 #include "cczr32112.h"
#endif

#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
 #include "cczr32212.h"
#endif

#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
 #include "cckac1310.h"
//temporary with KAC will be CONFIG_ETRAX_ELPHEL_MI1300
#endif
// still supports image flipping needed for 1.3Mpix cameras
/*
#ifdef CONFIG_ETRAX_ELPHEL_MI1300
 #include "ccmi1300.h"
#endif
*/
// unified driver for 1.3-2.0-3.0Mpixel sensors (no flipping)
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
 #include "mt9x001.h"
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
 #include "ccibis51300.h"
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
 #include "kac5000.h"
#endif


#if ELPHEL_DEBUG
  #define MD1(x) printk("%s:%d:",__FILE__,__LINE__);x
  //#define MD1(x)
  #define MD12(x) printk("%s:%d:",__FILE__,__LINE__);x
  //#define MD12(x)
  #define MD13(x) printk("%s:%d:",__FILE__,__LINE__);x
  //#define MD13(x)
  #define MD20(x) printk("%s:%d:",__FILE__,__LINE__);x
#else
  #define MD1(x)
  #define MD12(x)
  #define MD13(x)
  #define MD20(x)
#endif



//#define MD11(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD11(x)

//#define MD10(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD10(x)
//#define MD9(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD9(x)

//MD8 - about i2c
//#define MD8(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD8(x)

//#define MD7(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD7(x)

//#define MD6(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD6(x)

//#define MD2(x) printk("%s:%d:",__FILE__,__LINE__);x
#define MD2(x)

//#define D(x) x
#define D(x)
#define D1(x)
#define D2(x)
#define D3(x)
#define D4(x)

#define D5(x) printk("%s:%d:",__FILE__,__LINE__);x


#define CMOSCAM_MAJOR 126  /* LOCAL/EXPERIMENTAL */
static const char cmoscam_name[] = "cmoscam353";

/* Camera revision dependent defines are here */
// Defines for Model 303 revA/M camera
#define MY_MODULE_DESCRIPTION "Elphel model 353  camera driver"
#define CMOSCAM_DRIVER_NAME "CMOS/MCP camera 353 driver\n"


#define X313_ACQUIRE_STOP      port_csp0_addr[X313_WA_TRIG]=0
#define X313_ACQUIRE_ONCE      port_csp0_addr[X313_WA_TRIG]=(imageParamsR[P_TRIG] & 1)?6:4
#define X313_ACQUIRE_INTERNAL  port_csp0_addr[X313_WA_TRIG]=4
#define X313_ACQUIRE_EXTERNAL  port_csp0_addr[X313_WA_TRIG]=6
#define X313_ACQUIRE_ON        port_csp0_addr[X313_WA_TRIG]=5

//  #define   X313_WA_IRQ_RST   0x1c // reset selected interrupt bits
//  #define   X313_WA_IRQ_DIS   0x1d // disable selected interrupt bits (mask)
//  #define   X313_WA_IRQ_ENA   0x1e // enable selected interrupt bits
//  #define   X313_WA_IRQ_WVECT 0x1f // write vector number (in bits [0:7], [11:8] - interrupt number (0..15)
// intm_shadow not used, disable and reset as was before (only 8 interrupts - does not touch USB
#ifdef CONFIG_ETRAX_ELPHEL353
    #define EN_INTERRUPT(x)  port_csp0_addr[X313_WA_IRQ_ENA]= (1<< x )
    #define DIS_INTERRUPT(x) {port_csp0_addr[X313_WA_IRQ_DIS]= (1<< x ); port_csp0_addr[X313_WA_IRQ_RST]= (1<< x );}
    #define DIS_INTERRUPTS   {port_csp0_addr[X313_WA_IRQ_DIS]= 0xff; port_csp0_addr[X313_WA_IRQ_RST]= 0xff;}
#else
  #ifdef CONFIG_ETRAX_333
    #define EN_INTERRUPT(x)  port_csp0_addr[X313_WA_IRQ_ENA]= (1<< x )
    #define DIS_INTERRUPT(x) {port_csp0_addr[X313_WA_IRQ_DIS]= (1<< x ); port_csp0_addr[X313_WA_IRQ_RST]= (1<< x );}
    #define DIS_INTERRUPTS   {port_csp0_addr[X313_WA_IRQ_DIS]= 0xff; port_csp0_addr[X313_WA_IRQ_RST]= 0xff;}
  #else
    #define EN_INTERRUPT(x)  port_csp0_addr[X313_WA_IRQM]= (intm_shadow |=  (1<< x ))
    #define DIS_INTERRUPT(x) port_csp0_addr[X313_WA_IRQM]= (intm_shadow &= ~(1<< x ))
    #define DIS_INTERRUPTS   port_csp0_addr[X313_WA_IRQM]= (intm_shadow = 0)
  #endif
#endif

// t - test (0,1), s - subtract mode (0-3), m - multiply mode (0-3), d - depth (0 - 8, 1 - 16), l - left shift (8 bit only)

/*#define PROGRAM_FPN(t,s,m,d,l)      port_csp0_addr[X313_WA_SENSFPN]=    \
                                        (((t) & 1) << 7) | \
                                        (((s) & 3) << 5) | \
                                        (((m) & 3) << 3) | \
                                        (((d) & 1) << 2) | \
                                        (((l) & 3) << 0)  */
// t - test (0,1), s - subtract mode (0-7), m - multiply mode (0-7), d - depth (0 - 8, 1 - 16), l - left shift (8 bit only)
#define PROGRAM_FPN(t,s,m,d,l)      port_csp0_addr[X313_WA_SENSFPN]=    \
                                        (((t) & 1) << 10) | \
                                        (((s) & 7) << 7) | \
                                        (((m) & 7) << 4) | \
                                        (((d) & 1) << 3) | \
                                        (((l) & 7) << 0)
// saving glogbal parameters combine all (but width) in one
// w:  - 0- 8bit,1 - 16 bits
// p: bits 3:0 - shift 
//         6:4 - mpy mode
//         10:8 - sub mode
//         12 - test mode
/*#define PROGRAM_FPNW(p,w)      port_csp0_addr[X313_WA_SENSFPN]=    \
                                        (((p) & 0x1000) >> 2) | \
                                        (((p) &  0x700) >> 1) | \
                                        (((p) &   0x70) >> 0) | \
                                        (((w) &      1) << 3) | \
                                        (((p) &      7) << 0)*/




// program DMA block size
//define PROGRAM_BLKSZ(x)  port_csp0_addr[CCAM_WA_WBLKSZ]= x
// program FPGA  mclk - needs to change external clock
//#define PROGRAM_CLK_DIV(x)  CCAM_SETFIELD(CLKDIV, x )
// enable clock to sensor
#define PROGRAM_CLK_EN(x)   X313_SETFIELD(CLKEN,  x )
// program depth - combine with other parameters
// #define PROGRAM_DEPTH(x)     CCAM_SETFIELD(DEPTH,(( x )==4)? 2 :((( x )==8)? 1 : 0))
// program left shift
// #define PROGRAM_SHIFT(x)     CCAM_SETFIELD(SHFT,(( x )==3)? 3 :((( x )==2)? 0 : ((( x )==1)? 1 : 2)))
// program color compressor mode
// #define PROGRAM_COLOR(x)     CCAM_SETFIELD(COLOR, x)
// program aux clock (0/1/20MHz)
// #define PROGRAM_AUXCM(x)     CCAM_SETFIELD(AUXCM, x)


// do not use aux connector pins (used to program KAI11000 FPGA)
#define CCAM_DONOTUSEAUX (ccam_cr_shadow & X313_MASK(KAI11000))

//IS_KAI11000
#define CCAM_ARO_ON \
        ccamCROr( X313_BITS(ARO,1) )
#define CCAM_ARO_OFF \
        ccamCRAnd(~X313_BITS(ARO,1) )

// turn clock to sensor on/off (default - on)
#define CCAM_DCLK_OFF \
        ccamCROr( X313_BITS(DCLKMODE,1) )
#define CCAM_DCLK_ON \
        ccamCRAnd(~X313_BITS(DCLKMODE,1) )

// ARST is opposite in 303!
#define CCAM_ARST_OFF \
        ccamCROr( X313_BITS(ARST,1) )
#define CCAM_ARST_ON \
        ccamCRAnd(~X313_BITS(ARST,1) )

#define CCAM_MRST_OFF \
        ccamCROr( X313_BITS(MRST,1) )
#define CCAM_MRST_ON \
        ccamCRAnd(~X313_BITS(MRST,1) )
  
#define CCAM_NEGRST \
        ccamCROr( X313_BITS(NEGRST,1) )
#define CCAM_POSRST \
        ccamCRAnd(~X313_BITS(NEGRST,1) )

// enable power converter control. *** Only if it is not MT9P001 !!! ***
#define CCAM_CNVEN_OFF \
   ccamCRAnd(~X313_BITS(CNVEN,1) )

#define CCAM_TRIG_INT \
   ccamCRAnd(~X313_BITS(TRIGSRC,1) )
#define CCAM_TRIG_EXT \
   ccamCROr( X313_BITS(TRIGSRC,1) )

#define CCAM_TIMESTAMP_NORMAL \
   ccamCRAnd(~X313_BITS(EARLYTRIG,1) )
#define CCAM_TIMESTAMP_EARLY \
   ccamCROr( X313_BITS(EARLYTRIG,1) )



// For sensor where HACT (and VACT, BPF) switches later than PXD
// it is possible to compensate HACT by registering it later by N/4Tpclk (where 0<=N<=3)
// definitely needed for MT5P001 @ 96MHz (3/4)
#define CCAM_SET_HACT_PHASE(x) ccamCRAndOr(~X313_MASK(HACT_PHASE), X313_BITS(HACT_PHASE, (x)))


#if 0 // restore that back after playing with 10359 board
#ifdef CONFIG_ETRAX_ELPHEL_FORCE_MT9P001
  #define CCAM_CNVEN_ON \
   printk ("\r\n*** Turning voltage is disabled in kernel config - CONFIG_ETRAX_ELPHEL_FORCE_MT9P001 ***\r\n")
#else
  #define CCAM_CNVEN_ON \
   printk ("\r\n*** Maybe fatal for MT9P001 !!! Set CONFIG_ETRAX_ELPHEL_FORCE_MT9P001 if troubleshooting MT9P001 ***\r\n");ccamCROr( X313_BITS(CNVEN,1) )
#endif
#else
  #define CCAM_CNVEN_ON \
   printk ("\r\n*** Maybe fatal for MT9P001 !!! Set CONFIG_ETRAX_ELPHEL_FORCE_MT9P001 if troubleshooting MT9P001 ***\r\n");ccamCROr( X313_BITS(CNVEN,1) )
#endif
// output "EXPOS" is used to communicate with FPGA on MCP board, else - as external output
// will go to FPGA - later
/*
#define CCAM_EXP_EN \
        if (!MCPpresent()) ccamCRAnd(~(X313_BITS(EXP,1) | X313_BITS(EXPPOL,1) ) )
#define CCAM_EXP_DIS \
        if (!MCPpresent()) ccamCROr (  X313_BITS(EXP,1) | X313_BITS(EXPPOL,1) )
*/

#define X313_MAXMINOR 15
//extern unsigned long ccam_dma_buf[CCAM_DMA_SIZE + PAGE_SIZE] __attribute__ ((aligned (PAGE_SIZE)));




//extern unsigned long ccam_dma_buf1[CCAM_DMA_SIZE + PAGE_SIZE];
//unsigned long * ccam_dma_buf= ccam_dma_buf1;

/*
 * Initial parameters, common for all for all sensors
 */
//static struct sensor_t sensor; // current sensor (will be copied to by sensor driver)
struct sensor_t sensor; // current sensor (will be copied to by sensor driver)
unsigned short gamma_tables_soft[1028];
int gamma_tables_changed=0; // to know that closing tables needs writing FPGA

static DECLARE_MUTEX(sensor_lock);


static unsigned long default_common[]= \
   {
   P_WOI_WIDTH,       1280,
   P_WOI_HEIGHT,      1024,
   P_WOI_LEFT,        0,
   P_WOI_TOP,         0,
   P_SENSOR,    0,
   P_TRIG,              2, // enable stopping clip by external input
   P_EXPOS,             1,
//   P_DMA_SZ,  0x0f,   // default DMA blok size = 16 words
//   P_DMA_LOOP,        CCAM_DMA_SIZE,  // will be updated
   P_PAGE_ACQ,  0,  // Number of image page buffer to acquire to (0.1?)
   P_PAGE_READ, 0,  // Number of image page buffer to read from to (0.1?)


   P_BGFRAME,   0,  // not a background mode
   P_OVERLAP,   0,      // (will be overwritten) Rolling Shutter DMA length (number of words to be acquired over frame size)
   P_AUXCM,             0,              // 0 on auxclk pin
   P_BIN_HOR,   0,              // no binning h
   P_BIN_VERT,  0,              // no binning h
   P_COLOR,             0,              // monochrome mode
//   P_VIDEO,           0,              // still mode
//   P_TEST,            0,              // normal mode
   P_MCLK,              4,              // divide by 4 -- FPGA, divide by 80MHz by P_MCLK
//   P_MCLK_DIS,  0,            // enable MCLK to sensor
   P_DCM_HOR,   0,              // 0 - no decimation, 1 - 1/2, 2 - 1/4, 3 - 1/8, etc.
   P_DCM_VERT,  0,              // 0 - no decimation, 1 - 1/2, 2 - 1/4, 3 - 1/8, etc.

   P_BITS,         8,           // 8-bit mode
   P_SHIFTL,    0,              // no pre-scaling
   P_FPNS,       0,      // no FPN correction
   P_FPNM,       0,      // no FPN correction
//   P_FPN,       0,      // no FPN correction
   P_VEXPOS,    0,

   P_GAINR,             0,
   P_GAING,             0,
   P_GAINB,             0,
   P_GAINGB,    0,
   P_FATZERO,   0,
   P_VIRTTRIG,  0,
   P_QUALITY,   50,
   P_COLOR_SATURATION_BLUE, 100,
   P_COLOR_SATURATION_RED,  100,
   P_GSCALE,                256, // whas not defined before, 256 (1.0 - use the same greens)
   
   P_GAMMA, 100,
   P_PIXEL_LOW, 0,
   P_PIXEL_HIGH, 255,
   P_FRAMESYNC_DLY, 0,
   P_PF_HEIGHT, 0,
   P_FPSLM, 0,
   P_TASKLET_CTL, 0,
   P_SKIP_FRAMES, 1,   
   P_I2C_QPERIOD, 100,
   P_I2C_BYTES,2,
   P_OVERSIZE,0,
   P_I2C_BYTES,2,
   P_IRQ_SMART,3
   };

#define SCALE_MIN       0x040
#define SCALE_MAX       0x400
extern unsigned long gain_balance(unsigned long *scale, unsigned long gain);
struct gains_t gains = {
        .red = 0x100,
        .green = 0x100,
        .blue = 0x100,
};

struct frame_params_t frame_params ={
/*00-03 unsigned int */   .exposure=0,       
/*04-05 unsigned short */ .width=0,          
/*06-07 unsigned short */ .height=0,         
/*08-11 unsigned long  */ .colorsat=  DEFAULT_COLOR_SATURATION_BLUE | (DEFAULT_COLOR_SATURATION_RED << 16), 
/*12    unsigned char  */ .color=0,          
/*13    unsigned char  */ .quality=50,       
/*14    unsigned char  */ .gamma=100,        
/*15    unsigned char  */ .black=0,          
/*16-17 unsigned short */ .rscale=0,         
/*18-19 unsigned short */ .bscale=0,         

/*20    unsigned char  */ .gain_r=0,         
/*21    unsigned char  */ .gain_g=0,         
/*22    unsigned char  */ .gain_b=0,         
/*23    unsigned char  */ .gain_gb=0,        
/*24-25 unsigned short */ .meta_index =0,     

/*26-27 unsigned short */ .signffff=0xffff,   

/*28-31 unsigned long  */ {.timestamp_sec=0},  
/*32-35 unsigned long  */ .timestamp_usec=0  
};
  unsigned long  * frame_params_ul= (unsigned long *) &frame_params; // fighting caching of circular buffer
//  unsigned short * exif_index=  (unsigned short * ) &frame_params.bindec_hor;
  unsigned short * exif_index=  (unsigned short * ) &frame_params.meta_index;
  static struct meta_offsets_t { // works like a cache to time save on looking for tags in the directory (forced to recalcualte if does not match)
    int Image_DateTime;          // will have offset of the Exif_Image_DateTime data in meta page (Exif_Photo_SubSecTime should go immediately after in meta page)
    int Photo_DateTimeOriginal;
    int Photo_ExposureTime;
    int Image_FrameNumber;
  } meta_offsets;

  char * exif_meta_time_string;
void dumpFrameParams(struct frame_params_t * fp, const char * title) {
//  double d1,d2,d3;
//  char   s[1024];
  printk ("%s\n",title);
  printk (".exposure=          %d * 100usec\n",(int)fp->exposure);
  printk (".width=             %d\n", (int)fp->width);
  printk (".height=            %d\n",(int)fp->height);
  printk (".colorsat=        0x%x (%d / %d)\n",(int)fp->colorsat, (int)((100.0*(fp->colorsat>>16))/DEFAULT_COLOR_SATURATION_RED),   (int) ((100.0*(fp->colorsat & 0xffff))/DEFAULT_COLOR_SATURATION_BLUE));
  printk (".color=           0x%x (color=%d, flipX=%d, flipY=%d)\n",(int) fp->color,  (int) fp->color & 0x0f,  (int) (fp->color >> 6) & 1, (int) (fp->color >> 7) & 1);
  printk (".quality=           %d\n",(int) fp->quality);
  printk (".gamma=             %d\n",(int) fp->gamma);
  printk (".black=             %d\n",(int) fp->black);
  printk (".rscale=          0x%x (%d)\n",(int) fp->rscale,  (int)((100.0*fp->rscale)/256));
  printk (".bscale=          0x%x (%d)\n",(int) fp->bscale,  (int)((100.0*fp->bscale)/256));
  printk (".gain_r=          0x%x (%d)\n",(int) fp->gain_r,  (int)((100.0*fp->gain_r)/16));
  printk (".gain_g=          0x%x (%d)\n",(int) fp->gain_g,  (int)((100.0*fp->gain_g)/16));
  printk (".gain_b=          0x%x (%d)\n",(int) fp->gain_b,  (int)((100.0*fp->gain_b)/16));
  printk (".gain_gb=         0x%x (%d)\n",(int) fp->gain_gb, (int)((100.0*fp->gain_gb)/16));
//  printk (".bindec_hor=      0x%x (bin: %d dec: %d)\n",(int) fp->bindec_hor, (int) (fp->bindec_hor >>4)+1, (int) (fp->bindec_hor & 0x0f)+1);
//  printk (".bindec_vert=     0x%x (bin: %d dec: %d)\n",(int) fp->bindec_vert, (int) (fp->bindec_vert >>4)+1,     (int) (fp->bindec_vert & 0x0f)+1);
  printk (".meta_index=      0x%x\n",(int) fp->meta_index);
  printk (".signffff=        0x%x\n",(int) fp->signffff);
  printk (".timestamp_sec=   0x%x\n",(int) fp->timestamp_sec);
  printk (".timestamp_usec=  0x%x\n",(int) fp->timestamp_usec);
}
static int minors[X313_MAXMINOR+1];     // each minor can be opened only once

static unsigned char sensor_i2c_addr;   // 0x60 for ZR32112, ZR32212; 0x66 for KAC1310

//static unsigned char sensor_i2c_regs[0x200]; // was 0x17 -- only first 32 accessible through ioctl
static unsigned short sensor_i2c_regs16[0x100];
unsigned char * sensor_i2c_regs;

// migration to read/write instead of IOCTL. First 64 will still be accessible with ioctl, all through read/write.
// first 4096 bytes when written will go to imageParamsW, when read - from imageParamsR. Reading from bytes 4096..8191 will
// return imageParamsW
//#define P_NUMBER         1024   //number of registers (was 64)
static unsigned long imageParamsR[P_NUMBER * 4] __attribute__ ((aligned (PAGE_SIZE)));   // Sensor Parameters (user read)
unsigned long *imageParamsW=&imageParamsR[P_NUMBER]; // sensor parameters (user write) go immediately after read parameters
unsigned long *imageParamsR_PREV=&imageParamsR[2*P_NUMBER]; // (some) sensor parameters delayed by 1 frame
unsigned long *imageParamsR_PREV_PREV=&imageParamsR[3*P_NUMBER]; // (some) sensor parameters delayed by 2 frames
// variables that should be prepared for JPEG control in programSensor()


struct autoexp_t * autoexp_state= NULL;
struct autoexp_t * autoexp_set=  NULL;
struct aexp_window_t * aexp_window = NULL;
struct aexp_window_t * aexp_window_set = NULL;


static int jpeg_sdram_ctl0;

volatile unsigned long ccam_cr_shadow=0;
/*
 * Functions used in only in this file
 */

static int getCamSeqState(void);
static int getCamSeqCount(void);
static void setCamSeqState(int v);
static void setCamSeqCount(int v);
static  void initCamIRQs(void);

static int camSeqStart(void);

//static irqreturn_t camSeq_interrupt(int irq, void *dev_id, struct pt_regs * regs);
static irqreturn_t camSeq_interrupt(int irq, void *dev_id);
static int x313_JPEG_cmd_wrapper(int arg); 
static int ccam_DMA_ioctl(struct inode *inode, struct file *file,unsigned int cmd, unsigned long arg);

static int cmoscam_open(struct inode *inode, struct file *filp);

static int cmoscam_release(struct inode *inode, struct file *filp);
static int cmoscam_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
static loff_t cmoscam_lseek(struct file * file, loff_t offset, int orig);
static ssize_t cmoscam_read(struct file * file, char * buf, size_t count, loff_t *off);
static ssize_t cmoscam_write(struct file * file, const char * buf, size_t count, loff_t *off);
static int cmoscam_mmap (struct file *file, struct vm_area_struct *vma);
static unsigned int cmoscam_poll (struct file *file, poll_table *wait);

static int __init cmoscam_init(void);
static int init_sensor(void);
static int programSensor(int nonstop);
static int init_FPGA(void); //will check FPGA version, init SDRAM (if needed) and sensor
//static void initSDRAM(void); // - use fpga_initSDRAM(void)
static void camSeq_dump (void);

void adjust_fps_2_compressor(void);


//r/w to fpga tables (not all readable) - move to separate file?
void x313_tables_gammainitlinear(void);
loff_t  x313_tables_lseek(struct file * file, loff_t offset, int orig) ;
ssize_t x313_tables_write(struct file * file, const char * buf, size_t count, loff_t *off) ;
ssize_t x313_tables_read(struct file * file, char * buf, size_t count, loff_t *off) ;
loff_t  x313_histogram_lseek(struct file * file, loff_t offset, int orig) ;
ssize_t x313_histogram_read(struct file * file, char * buf, size_t count, loff_t *off) ;

int write_gamma_fpga (unsigned short gamma_table[1028]);
loff_t  x313_gamma_lseek(struct file * file, loff_t offset, int orig);
ssize_t x313_gamma_read(struct file * file, char * buf, size_t count, loff_t *off) ;
ssize_t x313_gamma_write(struct file * file, const char * buf, size_t count, loff_t *off) ;

loff_t x313_senspars_lseek(struct file * file, loff_t offset, int orig);
ssize_t x313_senspars_read(struct file * file, char * buf, size_t count, loff_t *off);
ssize_t x313_senspars_write(struct file * file, const char * buf, size_t count, loff_t *off);
int     x313_senspars_mmap (struct file *file, struct vm_area_struct *vma);

void x313_program_focus(int totalwidth);


static struct file_operations cmoscam_fops = {
        owner:    THIS_MODULE,
        llseek:   cmoscam_lseek,
        read:     cmoscam_read,
        write:    cmoscam_write,
        ioctl:    cmoscam_ioctl,
        open:     cmoscam_open,
        mmap:     cmoscam_mmap,
        poll:     cmoscam_poll,

        release:  cmoscam_release
};

/* ++++++++++++++++++++++++++++ IRQ/camseq related stuff +++++++++++++++++++++++++++++++++++ */
// parameters, copied from Verilog file "emultasks.v"
// define interrupt numbers
#define nint_vact       0 // start of VACT pulse
#define nint_xint               1 // external enterrupt
#define nint_xferovr    2 // DMA xfer over
#define nint_done       3 // DMA xfer over, persistent till reset through...

#define nint_eot        4
#define nint_overrun    5     // persistent till compressor reset
#define nint_done_input 6     // persistent till compressor reset/restarted
#define nint_done_compress 7  // persistent till compressor reset/restarted
#define nint_smart      8  // Single cycle, does not need restart, configurable to wait for VACT, always at VACT if no compression is underway


#define MAXEXPOSURE     60000   //60 sec, in 1ms increments
//static        volatile int camSeqState;
/*
#define CAMSEQ_OFF       0 // off, not programmed (Video mode off on Zoran sensors)
#define CAMSEQ_READY     1 // sensor programmed may acquire at will (programSensor sets number of frames to skip (if any)
#define CAMSEQ_SKIP      2 // skipping specified number of frames, interrupt service routine counts and will start acquisition
#define CAMSEQ_WAIT_F    3 // set by "start exposure" or interrupt service routine. WAIT_F/WAIT_T/acquire/done differs by hardware register
#define CAMSEQ_WAIT_T    4 // set by "start exposure" or interrupt service routine. Wait/acquire/done differs by hardware register
#define CAMSEQ_ACQUIRE   5 // acquisition in progress (camSeqState is still CAMSEQ_WAIT)
#define CAMSEQ_DONE      6 // acquisition over  (camSeqState is still CAMSEQ_WAIT)
#define CAMSEQ_JPEG      7 // waiting for JPEG done interrupt, acquiring/compressing some frames

#define CAMSEQ_RUN       8 // compressor is constantly running (or skipping "bad" frames)
#define CAMSEQ_STOP      9 // compressor is constantly running but will stop after next "compressor ready"

Status CAMSEQ_OFF may be changed to CAMSEQ_READY only by programSensor, it will also stop sensor (if needed)
  and set camSeqCount (if needed) to skip certain number of frames before actual acquisition
  camSeqStart (called mostly through ioctl) will return error if state was not "CAMSEQ_READY" or "CAMSEQ_DONE".
  If called from correct states will either start ISR-based waiting for specified number of frames  or just acquisition.
  In the first case ISR will start acquisition itself
  State "CAMSEQ_WAIT" is set at the same time as starting acquisition (by either camSeqStart() or ISR),
  States CAMSEQ_ACQUIRE, CAMSEQ_DONE are returned after testing the hardware register in FPGA if camSeqState==CAMSEQ_WAIT
  camSeqStop will terminate any acquisition in progress and set state to CAMSEQ_READY (if it was not CAMSEQ_OFF)

*/

//static void x313_f_invalidate (void); // to be called when page number is changed. Write should not be in progress

#ifndef CONFIG_ETRAX_ELPHEL353
  #ifdef CONFIG_ETRAX_333
  #else
    static volatile unsigned long intm_shadow=0;
  #endif
#endif

static volatile int camSeqCount;
static volatile int camSeqState;
static volatile int JPEG_wp;
static volatile int JPEG_rp;
static volatile int JPEG_len;   // current length in buffer;


static unsigned long DMA_buf_start;

static volatile int JPEG_nfr;   // number of frames left to acquire
static volatile int JPEG_lfr;   // total frames length to acquire

static volatile int dbg_20;   // contents of register 20 at the compression start
static volatile int dbg_28;   // same for 0x28


/* x313_wait_queue -- so a reader can sleep while waiting for something
*       to do.
*/
wait_queue_head_t x313_wait_queue;
static inline void startAcquire(void) {
//   setCamSeqState(CAMSEQ_WAIT_F);
   camSeqState=CAMSEQ_WAIT_F;
   camSeqCount=0;
   imageParamsR[P_CAMSEQSTATE]=CAMSEQ_WAIT_F;
   imageParamsR[P_CAMSEQCOUNT]=0;
   if (imageParamsR[P_BGFRAME]) X313_ACQUIRE_INTERNAL ;
   else                         X313_ACQUIRE_ONCE ;
   EN_INTERRUPT(nint_xferovr);

}

// X313_ACQUIRE_ON
// void x313_dma_start(void);
// int  x313_dma_stop(void);


// for video(?) compressed images acquisition

// sensor is assumed running in continuous mode, ETRAX DMA on
// will see if more frames are needed (both in count and memory)
// and (re)start frame compression (live).

//     i=((((*R_DMA_CH5_BUF) - virt_to_phys (ccam_dma_buf)) & 0x7fffffff) + (( *R_DMA_CH5_STATUS ) & 0x7f))>>2;
// OK, I've got it. Actual data length is the sum of BUF and STATUS
//     if (i>=CCAM_DMA_SIZE) i-=CCAM_DMA_SIZE;
//  #define X313__RA__IRQS      0x11    // read interrupt register
// There should be couple extra lines after the frame, so compressor will have time to finish before
// frame sync IRQ

/*
extern void hist_irq_done(void);
extern void hist_irq_vact(void);

void tasklet_done_compress_f(unsigned long arg) {
        hist_irq_done();
}

DECLARE_TASKLET(tasklet_done_compress, tasklet_done_compress_f, 0);

void tasklet_vact_f(unsigned long arg) {
        hist_irq_vact();
}

DECLARE_TASKLET(tasklet_vact, tasklet_vact_f, 0);
*/

void tasklet_irq_f(unsigned long arg) {
        hist_irq(arg);
}

DECLARE_TASKLET(tasklet_vact, tasklet_irq_f, IRQ_SRC_VACT);
DECLARE_TASKLET(tasklet_done_compress, tasklet_irq_f, IRQ_SRC_DONE_COMPRESS);
//extern unsigned long *ccam_dma;
extern unsigned long ccam_dma_length;

static int fpga_counter_prev=0;
static int JPEG_wp_prev=0;

//#define P_COMPRESSOR_CMD 107 // read only - compressor command, last written to FPGA
//  #define COMPRESSOR_CMD_RUN    0x080
//  #define COMPRESSOR_CMD_SINGLE 0x800  

inline void compressorSingle(void) {
     port_csp0_addr[X313_WA_COMP_CMD] = \
                imageParamsR[P_COMPRESSOR_CMD]= \
                (x313_get_JPEG_ctrl() & (~COMPRESSOR_CMD_RUN)) | COMPRESSOR_CMD_SINGLE; 
     X313_CHN_EN(2);  
}
inline void compressorRun(void) {
     port_csp0_addr[X313_WA_COMP_CMD] = \
                imageParamsR[P_COMPRESSOR_CMD]= \
                x313_get_JPEG_ctrl() | COMPRESSOR_CMD_RUN; 
     X313_CHN_EN(2);  
}
inline void compressorStop(void) {
     port_csp0_addr[X313_WA_COMP_CMD] = \
             imageParamsR[P_COMPRESSOR_CMD]= 0; 
     X313_CHN_DIS(2);  
     fpga_counter_prev=0; 
}
inline void updateJPEG_wp(void) {
     int xferred; 
//     int fpga_cntr=port_csp0_addr[X313__RA__XFERCNTR]; // reducing external accesses - be "green" (lower power)
     int fpga_cntr=X313_XFERCNTR; // reducing external accesses - be "green" (lower power)

     xferred=fpga_cntr-fpga_counter_prev; 
     fpga_counter_prev=fpga_cntr;
     if (xferred <0) xferred+= (1 <<24) ; //rolled over
     JPEG_wp_prev=JPEG_wp;
     JPEG_wp+= (xferred << 3); 
     if (JPEG_wp > CCAM_DMA_SIZE) JPEG_wp-=CCAM_DMA_SIZE;
     imageParamsR[P_JPEG_WP] = JPEG_wp; 
     imageParamsR[P_CIRCBUFWP]= JPEG_wp<<2; 
     imageParamsR[P_FREECIRCBUF] = ((imageParamsR[P_CIRCBUFRP] < imageParamsR[P_CIRCBUFWP])? imageParamsR[P_CIRCBUFSIZE]:0)+ 
                                     imageParamsR[P_CIRCBUFRP] - imageParamsR[P_CIRCBUFWP];
     imageParamsR[P_FOCUS_VALUE]= X313_HIGHFREQ ; 
}
void resetPointers(void) {
      JPEG_wp=0;
      imageParamsR[P_JPEG_WP]=JPEG_wp;
      imageParamsR[P_CIRCBUFWP]= JPEG_wp<<2;
      imageParamsR[P_FREECIRCBUF] = imageParamsR[P_CIRCBUFRP];
//      imageParamsR[P_FRAME]=0;
      JPEG_rp=0;
      imageParamsR[P_FREECIRCBUF] = 0;
      JPEG_len=0;   // current length in buffer;
  }


inline void advance_imageParamsR(void) { // called to delay exposure to appear in Exif (maybe other parames to be added later), encode exposure to Exif
// done after current Exif page is copied to the buffer, so one more frame delay for exposure
   putlong_meta_irq(imageParamsR_PREV[P_EXPOS], &meta_offsets.Photo_ExposureTime,  Exif_Photo_ExposureTime);
   putlong_meta_irq(imageParamsR[P_FRAME], &meta_offsets.Image_FrameNumber,  Exif_Image_FrameNumber);
   frame_params.exposure=imageParamsR_PREV_PREV[P_EXPOS]; 
   imageParamsR_PREV_PREV[P_EXPOS]=imageParamsR_PREV[P_EXPOS] ; // not yet needed
   imageParamsR_PREV[P_EXPOS]=     imageParamsR[P_EXPOS] ;
   int i2c_frame_number= X3X3_I2C_FRAME ;
   imageParamsR[P_FRAME]= (imageParamsR[P_FRAME] & 0xfffffff8) + i2c_frame_number +(((imageParamsR[P_FRAME] & 7) > i2c_frame_number)?8:0);
}


inline void add_frame_params(void) {
   int alen = JPEG_wp-9; if (alen<0) alen+=CCAM_DMA_SIZE;
   int jpeg_len=ccam_dma_buf_ptr[alen] & 0xffffff;
   int aframe_params=(alen & 0xfffffff8)- 
                     (((jpeg_len + CCAM_MMAP_META + 3) & 0xffffffe0)>>2) // multiple of 32-byte chunks to subtract
                     -8; // just size of thestorage area to be filled before the frame
   if(aframe_params < 0) aframe_params += CCAM_DMA_SIZE;

// new Exif handling

   exif_meta_time_string=encode_time(ccam_dma_buf_ptr[alen-2], ccam_dma_buf_ptr[alen-1]); // calculates datetime([20] and subsec[7], returns pointer to char[27]
   write_meta_irq(exif_meta_time_string, &meta_offsets.Photo_DateTimeOriginal,  Exif_Photo_DateTimeOriginal, 27); // may be split in datetime/subsec - now it will not notice missing subseq field in template
   write_meta_irq(exif_meta_time_string, &meta_offsets.Image_DateTime,  Exif_Image_DateTime, 20); // may use 27 if room is provided
   *exif_index= store_meta();
   memcpy ((void *) &ccam_dma_buf_ptr[aframe_params], &frame_params, 28) ;// !copy just 28 bytes of the current parameters to the circbuf
   ccam_dma_buf_ptr[aframe_params+7]=jpeg_len;
   advance_imageParamsR();

   wake_up_interruptible(&circbuf_wait_queue);


}


extern int slock;
extern void ch0_lock(void);
extern wait_queue_head_t vack_wait_queue;

#define SIMPLE_IRQ y

static irqreturn_t camSeq_interrupt(int irq, void *dev_id) {
        unsigned long irq_state;

        irq_state = X313_IRQSTATE; 

// with only vact - no lockup, trying to make done compress look the same (only in run mode when no vacts are allowed)
#define CONFIG_ETRAX_ELPHEL_AUTOEXP y
#ifdef CONFIG_ETRAX_ELPHEL_AUTOEXP
        if((irq_state & 0x01) && slock == 2) {
                ch0_lock();
                slock = 1;
//              wake_up_interruptible(&vack_wait_queue);
//              printk("sensor_VACK!!!\r\n");
        }
//      if((irq_state & 0x00000001) || ((camSeqState == CAMSEQ_RUN) && (irq_state & 0x00000080))) {
//        if ( irq_state & ((camSeqState == CAMSEQ_RUN)? 0x00000080:0x00000001) ) { // does not seem to work - state 7, IRQs are coming - no autoexposure
// but we do not need this - only one IRQ is enabled at a time
        if ((imageParamsR[P_TASKLET_CTL] & 1) == 0) tasklet_schedule(&tasklet_vact);
//      }
#warning using autoexposure
#else
#warning not using autoexposure
#endif
        // simulate "inta"
        DIS_INTERRUPTS; // disable and clear all interrupts
//      #define CAMSEQ_RUN       8 // compressor is constantly running
//      #define CAMSEQ_STOP      9 // compressor is constantly running but will stop after next "compressor ready"
//      #define CAMSEQ_SINGLE   10 // compressor is constantly running to all the buffer

        // in       
#ifndef SIMPLE_IRQ
#warning using wake_up_interruptible
//      wake_up_interruptible(&x313_wait_queue);
#else
#warning no wake_up_interruptible
#endif
   if((camSeqState == CAMSEQ_RUN) || (camSeqState == CAMSEQ_SINGLE)) { 
      // find where DMA stopped
       if(camSeqCount > 0) { 
         advance_imageParamsR();
         imageParamsR[P_CAMSEQCOUNT]=(--camSeqCount);
         EN_INTERRUPT(nint_vact);
       } else {
         if((camSeqCount) == 0) { 
           advance_imageParamsR();
           X313_POSTINIT_SDCHAN(2,(jpeg_sdram_ctl0 | 0x2000));   //read, depend, mode=1 (tiles)
           compressorRun();
           imageParamsR[P_CAMSEQCOUNT]= (--camSeqCount);
           EN_INTERRUPT(nint_done_compress);
         } else {  
            updateJPEG_wp(); 
            add_frame_params();
            if((camSeqState == CAMSEQ_SINGLE) && (JPEG_wp < JPEG_wp_prev)) {
               camSeqState = CAMSEQ_STOP; 
               imageParamsR[P_CAMSEQSTATE]=CAMSEQ_STOP;
            }
            compressorRun();
//            imageParamsR[P_FRAME]++;
            EN_INTERRUPT(nint_done_compress); 
         }
      }
   } else { 
      if(camSeqState == CAMSEQ_STOP) {
         updateJPEG_wp();
         add_frame_params();
         camSeqState = CAMSEQ_JPEG;
         imageParamsR[P_CAMSEQSTATE]=CAMSEQ_JPEG;
         JPEG_nfr = 0; // so it will not acquire any more frames
         compressorSingle();
//         imageParamsR[P_FRAME]++;
         EN_INTERRUPT(nint_done_compress);
      } else { 
         if(camSeqState == CAMSEQ_JPEG) { 
            if(X313_SR(DONE_CMPRS)) { // it is status, not IRQ register . SO it works even after DIS_INTERRUPTS (reset by writing to command register)
               updateJPEG_wp();
               add_frame_params();
               if(JPEG_nfr > 0) 
                  JPEG_nfr--;
                compressorStop(); 
               // will continue at frame sync interrupt to prevent false start (trying to compress the current frame)
               // See if it was not rereading from memory:
               if (X313_CHN0_BOUND) {  // was a bug - always started interrupts, even after rereading
//                  imageParamsR[P_FRAME]++;
                  EN_INTERRUPT(nint_vact); // no IRQ if it was rereading
               }
            } else {

               advance_imageParamsR();
               JPEG_len = JPEG_wp - JPEG_rp;
               if(JPEG_len < 0)
                  JPEG_len += CCAM_DMA_SIZE;
               if(((camSeqCount--) <= 0) && (JPEG_nfr > 0) && (JPEG_len< JPEG_lfr)) {
                  X313_POSTINIT_SDCHAN(2,(jpeg_sdram_ctl0 | 0x2000));   //read, depend, mode=1 (tiles)
                  compressorSingle();
                  EN_INTERRUPT(nint_done_compress);
               } else { // just skip next frame
                  compressorStop();  
                  EN_INTERRUPT(nint_vact);
               }
            } // X313_SR(DONE_CMPRS)  - else
         } else {
            advance_imageParamsR();
            if(camSeqState == CAMSEQ_WAIT_F) {
               camSeqState = CAMSEQ_DONE;
              imageParamsR[P_CAMSEQSTATE]=CAMSEQ_DONE;
            } else { 
               if((camSeqCount--) <= 0) {
                  startAcquire();
               } else {
                  EN_INTERRUPT(nint_vact);      // re-enable end of frame interrupt
               }
            }
         }
      }
   }
   return IRQ_HANDLED;
}

static int getCamSeqCount(void) {return camSeqCount;}
static void setCamSeqState(int v) {camSeqState=v;
                                   imageParamsR[P_CAMSEQSTATE]=v;
                                   imageParamsR[P_CAMSEQCOUNT]=0;
MD (printk ("camSeqState=0x%x\n",v));}


static void setCamSeqCount(int v) {camSeqCount=v;
                                   imageParamsR[P_CAMSEQCOUNT]=v;
}


static  void initCamIRQs(void){ // most moved outside - before FPGA loaded (only once!)
    reg_intr_vect_rw_mask intr_mask;
    DIS_INTERRUPTS;
    setCamSeqState(CAMSEQ_OFF);
    camSeqStop();
    resetPointers();
      JPEG_nfr=0;
      JPEG_lfr=0;

//      *R_IRQ_MASK0_SET = 0x10;        //1 << irq_int_vector_nr
    intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
    intr_mask.ext = 1;
    REG_WR(intr_vect, regi_irq, rw_mask, intr_mask); 

        printk ("Camera interrupts enabled\n");
//      *R_IRQ_MASK0_SET = IO_STATE(R_IRQ_MASK0_SET, irq_int_vector_nr, set);
}

static int getCamSeqState(void) {
    int res=-1;
    unsigned long flags;
    if (camSeqState==CAMSEQ_WAIT_F) {
      local_irq_save(flags);
      if (X313_SR(SENST1)) res=X313_SR(SENST0)?CAMSEQ_ACQUIRE:CAMSEQ_WAIT_T;
      else if (X313_SR(SENST0)) res=CAMSEQ_WAIT_F;
      else res= ((camSeqState=CAMSEQ_READY));
      local_irq_restore(flags);

      return res;
    }
    return      camSeqState;
}


static int camSeqStart(void) { 
  int i;
  if (((i=getCamSeqState()) != CAMSEQ_READY) && (i!=CAMSEQ_DONE)) {
   printk("camSeqStart error - CamSeqState was %d\n",i);
   return -1;    // error
  }
MD1(printk("camSeqStart:getCamSeqCount()=%x\n",getCamSeqCount())); 
  if (getCamSeqCount()) {

    setCamSeqState(CAMSEQ_SKIP);
    EN_INTERRUPT(nint_vact);
  } else {startAcquire();} 
  return 0; // OK
}

static void camSeq_dump (void) {
  printk ("    camSeqCount=  %x\n",camSeqCount);
  printk ("    camSeqState=  %x\n",camSeqState);
  printk ("    JPEG_wp=      %x\n",JPEG_wp);
  printk ("    JPEG_rp=      %x\n",JPEG_rp);
  printk ("    JPEG_len=     %x\n",JPEG_len);
  printk ("    DMA_buf_start=%lx\n",DMA_buf_start);
  printk ("    JPEG_nfr=     %x, (%d)\n",JPEG_nfr,JPEG_nfr);
  printk ("    JPEG_lfr=     %x\n",JPEG_lfr);
  printk ("    0x20 was=     %x\n",dbg_20);
  printk ("    0x28 was=     %x\n",dbg_28);
  printk("\n");
}



/*
 * Functions used in other files (implementation)
 */




/*
len <0, nfr>0 - acquire nfr frames, no length restrictions
len =0, nfr>0 - acquire nfr frames, unchanged length restriction
len >0, nfr>0 - acquire nfr frames, set new length restriction
len >0, nfr <0 - acquire unlimited number of frames, only total length restriction
len >0, nfr =0 - do not change number of frames to acquire, update total length restriction
len =0, nfr =0 - reread from memory (if was off).
*/
int  camSeqGetJPEG_wp(void) {return JPEG_wp;}
int  camSeqGetJPEG_rp(void) {return JPEG_rp;}
void camSeqSetJPEG_rp(int p) {
                              JPEG_rp=p;
                              imageParamsR[P_CIRCBUFRP] = p<< 2;
                              imageParamsR[P_FREECIRCBUF] =
                                    ((imageParamsR[P_CIRCBUFRP] < imageParamsR[P_CIRCBUFWP])?
                                     imageParamsR[P_CIRCBUFSIZE]:0)+ 
                                     imageParamsR[P_CIRCBUFRP] - imageParamsR[P_CIRCBUFWP];
                               }


int camSeqStartClip(int nfr, int len) { // will start/continue acquisition of a clip to memory (-1 - unlimited)
    unsigned long flags;
    int res=-1;
    MD1(printk("camSeqStartClip nfr=%d, len=%d, getCamSeqState()=%d \n", nfr, len, getCamSeqState()));
    MD7(printk("camSeqStartClip nfr=%d, len=%d, getCamSeqState()=%d \n", nfr, len, getCamSeqState()));

    if (((res=getCamSeqState()) != CAMSEQ_READY) && (res!=CAMSEQ_DONE) && (res!=CAMSEQ_JPEG) && (res!=CAMSEQ_RUN)) {
      printk("camSeqStartClip error - CamSeqState was %d\n",res);
      return -1;    // error
    }
   MD7(printk("camSeqStartClip nfr=%d, len=%d, getCamSeqState()=%d \n", nfr, len, res));
    if ((res==CAMSEQ_RUN)) {  // only "stop constant compression" is allowed
      if ((nfr<0) && (len ==0)){ // will work with both nfr == -1 (stop/acquire) and nfr =-2 (stop only)
        setCamSeqState(CAMSEQ_STOP);
        return 0;
      } else {
        printk("camSeqStartClip error - CamSeqState was %d\n",res);
        return -1;    // error
      }  
    }
    if ((nfr<0) && (len ==0)){ 
//        printk("camSeqStartClip error - tried to stop but CamSeqState was %d\n",res);
//        return -1;    // error
      if (nfr<-1) return 0; // just exit (do nothing if was not running) - don't restart
      JPEG_wp=0; 
      imageParamsR[P_JPEG_WP]=JPEG_wp;
      imageParamsR[P_CIRCBUFWP]= JPEG_wp<<2;
      imageParamsR[P_FREECIRCBUF] = imageParamsR[P_CIRCBUFRP];

//      imageParamsR[P_FRAME]=0;
      JPEG_rp=-1; 
      imageParamsR[P_FREECIRCBUF] = 0xffffffff;

      JPEG_len=0;   // current length in buffer;
      x313_dma_reset_chain();
      x313_dma_start();
      setCamSeqState(CAMSEQ_SINGLE);
//      port_csp0_addr[X313_WA_SD_MODE]= (port_csp0_addr[X313_WA_SD_MODE] & 0x2f); //disable SDRAM channel 2
      X313_CHN_DIS(2); //disable SDRAM channel 2
      setCamSeqCount(imageParamsR[P_SKIP_FRAMES]); // skip couple frames ****************** Not for CCD
      X313_ACQUIRE_ON;  // start constant-on acquisition mode
      EN_INTERRUPT(nint_vact);
      return 0;
    }
    if ((nfr==0) && (len == -1)) { 
      if (res==CAMSEQ_JPEG) { 
        MD1(printk("Restarting RUN\n"));
        setCamSeqState(CAMSEQ_RUN);
        setCamSeqCount(0); // next IRQ will start
        return 0;
      } else {
        MD1(printk("Starting RUN\n"));
        resetPointers();
        x313_dma_reset_chain(); 
        x313_dma_start();
        setCamSeqState(CAMSEQ_RUN);


        if (IS_KAI11000) {
MD7(printk("camSeqStartClip - using KAI-11002"));
           setCamSeqCount(imageParamsR[P_SKIP_FRAMES]); // Not for CCD
           X313_ACQUIRE_ON;
//           writeSensorReg16(0x14, 0, 1); // start CCD here
           X313_POSTINIT_SDCHAN(2,(jpeg_sdram_ctl0 | 0x2000));   //read, depend, mode=1 (tiles)
           compressorRun();
           camSeqCount--;
           EN_INTERRUPT(nint_done_compress);
        } else {
           X313_CHN_DIS(2); //disable SDRAM channel 2
           setCamSeqCount(imageParamsR[P_SKIP_FRAMES]); // (do not) skip couple frames wait for the first Vsync, then program compressor (1-st will still be wasted)
           X313_ACQUIRE_ON;  // start constant-on acquisition mode
           EN_INTERRUPT(nint_vact);
        }
        return 0;
      }
    }
MD7(printk("camSeqStartClip(0x%x, 0x%x), state=%d\n",nfr,len,res));
    if (res==CAMSEQ_JPEG) { 
      MD1(printk("Restarting SINGLE\n"));
      local_irq_save(flags);
      if (nfr<0) JPEG_nfr=0x7fffffff;
      else JPEG_nfr+=nfr;
      if (len<0) JPEG_lfr=0x7fffffff;
      else if (len>0) JPEG_lfr=len; // len ==0 -> no change

      local_irq_restore(flags);
      return 0;
    }  else { // need to start DMA
      MD1(printk("Starting SINGLE\n"));
      resetPointers();
      x313_dma_reset_chain();
      x313_dma_start();
      setCamSeqState(CAMSEQ_JPEG);
//      port_csp0_addr[X313_WA_SD_MODE]= (port_csp0_addr[X313_WA_SD_MODE] & 0x2f); //disable SDRAM channel 2
      X313_CHN_DIS(2); //disable SDRAM channel 2

      if ((len!=0) || (nfr !=0)) {
         if (nfr<0) JPEG_nfr=0x7fffffff;
         else JPEG_nfr+=nfr;
         if (len<0) JPEG_lfr=0x7fffffff;
         else if (len>0) JPEG_lfr=len; // len ==0 -> no change
         if (IS_KAI11000) {
MD7(printk("camSeqStartClip - using KAI-11002"));
           setCamSeqCount(imageParamsR[P_SKIP_FRAMES]); // Not for CCD
//           X313_ACQUIRE_ONCE?
           X313_ACQUIRE_ON;
           writeSensorReg16(0x14, 0, 1); // start CCD here
           X313_POSTINIT_SDCHAN(2,(jpeg_sdram_ctl0 | 0x2000));   //read, depend, mode=1 (tiles)
           compressorRun();
//           compressorSingle(); //! or just single?
           camSeqCount--;
           EN_INTERRUPT(nint_done_compress);
         } else {
// How many frames to skip after parameter change?
//         setCamSeqCount(2); // skip couple frames ****************** Not for CCD
         setCamSeqCount(imageParamsR[P_SKIP_FRAMES]); // skip couple frames ****************** Not for CCD
         X313_ACQUIRE_ON;  // start constant-on acquisition mode
         EN_INTERRUPT(nint_vact);
        }
      } else { 
// do similar to what is done inside IRQ service, but unconditionally once
         JPEG_nfr=1;
         JPEG_lfr=0x7fffffff;

         JPEG_len= JPEG_wp-JPEG_rp;
         if (JPEG_len<0) JPEG_len+=CCAM_DMA_SIZE;
            X313_POSTINIT_SDCHAN(2,jpeg_sdram_ctl0);   //do not wait (depend=0)
// start compressor (Should be started after SDRAM channel programmed)
         compressorSingle();
         EN_INTERRUPT(nint_done_compress);
      }
    }
    return 0;
}

//static void camSeqStop(void) {  // Add shutting down DMA/compressor?

#define OLD_CAMSEQSTOP 0 





void camSeqStop(void) {  // Add shutting down DMA/compressor?
//  unsigned long flags;
  MD1(printk("camSeqStop:getCamSeqState()=0x%x, imageParamsR[P_COMPRESSOR_CMD]=0x%x\n",getCamSeqState(), (int) imageParamsR[P_COMPRESSOR_CMD])); 
  MD12(printk ("camSeqStop: state=%d rp=0x%x, wp=0x%x\r\n", getCamSeqState(), JPEG_rp, JPEG_wp ));
  MD11(printk ("camSeqStop: state=%d rp=0x%x, wp=0x%x\r\n", getCamSeqState(), JPEG_rp, JPEG_wp ));
  DIS_INTERRUPTS;
  X313_ACQUIRE_STOP ;
//  local_irq_save(flags);
  if (imageParamsR[P_COMPRESSOR_CMD]) { // yes, it was runnning
    compressorStop(); // will immediately stop DMA operations
  }
//  local_irq_restore(flags);

//
#if OLD_CAMSEQSTOP
  if (getCamSeqState()>=CAMSEQ_JPEG) { // stop acquisition
    x313_dma_stop(); // will stop DMA and prepare data for reading out (?)
    setCamSeqState(CAMSEQ_READY);
  } else { 

      JPEG_wp=0;
      imageParamsR[P_JPEG_WP]=JPEG_wp;
      imageParamsR[P_CIRCBUFWP]= JPEG_wp<<2;
      imageParamsR[P_FREECIRCBUF] = imageParamsR[P_CIRCBUFRP];
//      imageParamsR[P_FRAME]=0;
      JPEG_rp=0;
      imageParamsR[P_FREECIRCBUF] = 0;
      JPEG_len=0;   // current length in buffer;
      JPEG_nfr=0;
      JPEG_lfr=0;
      x313_dma_reset_chain();
  }
#endif
  setCamSeqCount(0);

  if (getCamSeqState()!=CAMSEQ_OFF) setCamSeqState(CAMSEQ_READY);
  MD11(printk ("camSeqStop-exit: state=%d rp=0x%x, wp=0x%x\r\n", getCamSeqState(), JPEG_rp, JPEG_wp ));
}


int           get_sensor_i2c_regs16(int n) {return (((int) (sensor_i2c_regs[n<<1]))<<8)+sensor_i2c_regs[(n<<1)+1] ;}
unsigned char get_sensor_i2c_regs  (int n) {return sensor_i2c_regs[n] ;}
unsigned long get_imageParamsR     (int n) {return imageParamsR[n];}
unsigned long get_imageParamsW     (int n) {return imageParamsW[n];}
unsigned char get_sensor_i2c_addr  (void) {return sensor_i2c_addr ;}
void          set_sensor_i2c_regs  (int n, unsigned char d) {sensor_i2c_regs[n]=d;}
void          set_imageParamsR     (int n, unsigned long d) {imageParamsR[n]=d;}
void          set_imageParamsW     (int n, unsigned long d) {imageParamsW[n]=d;}
void          set_sensor_i2c_addr  (       unsigned char d) {sensor_i2c_addr=d;}



void ccamCRAnd(unsigned long d) {
        unsigned long flags;
   local_irq_save(flags);
        port_csp0_addr[X313_WA_WCTL]= (ccam_cr_shadow &= d);
        local_irq_restore(flags);
}

void ccamCROr(unsigned long d) {
        unsigned long flags;
   local_irq_save(flags);
        port_csp0_addr[X313_WA_WCTL]= (ccam_cr_shadow |= d);
        local_irq_restore(flags);
}

void ccamCRXor(unsigned long d) {
        unsigned long flags;
   local_irq_save(flags);
        port_csp0_addr[X313_WA_WCTL]= (ccam_cr_shadow ^= d);
        local_irq_restore(flags);
}


void ccamCRAndOr(unsigned long d_and, unsigned long d_or) {
        unsigned long flags;
   local_irq_save(flags);
        ccam_cr_shadow &= d_and;
        port_csp0_addr[X313_WA_WCTL]= (ccam_cr_shadow |= d_or);
        local_irq_restore(flags);
}

unsigned long ccamGetCR(void) {return ccam_cr_shadow;}

void writeSensorDefaults(unsigned long * data, int count) {
 int i;
MD7 (printk ("writing sensor defaults to imageParamsW[] (needs update to copy to imageParamsR[]), count=%d (decimal)\r\n",count));
 for (i=0;i<count;i++) {
   imageParamsW[data[2*i]]=data[2*i+1];
   MD7 (printk ("%ld(0x%lx): %ld(0x%lx)\r\n",data[2*i],data[2*i],data[2*i+1],data[2*i+1]));

 }
 imageParamsR[P_PARS_CHANGED]=1;
}


// readSensorReg and writeSensorReg hacked to accomodate KAC5000 "hidden" registers - the same address can point to multiple registers,
// such as color gains. Now ra will be unsigned int, if > 255 the high word will point to shadow array index (up to 511),
// else - array index is the same as ra
int readSensorReg(unsigned int ra, int mode) { //  mode=0 - shadow, 1 - actual register
  int i;
  unsigned long flags;
  int i1=0;
  unsigned char rab=ra & 0xff;
  int rindx= (ra>>16) & 0x1ff; if (!rindx) rindx=rab;
  if(mode) {
MD7 (printk ("ra= 0x%x, rab=0x%x, shadow was =0x%x - ",ra, (int) rab, (int)sensor_i2c_regs[rindx]));
    local_irq_save(flags);
    X3X3_I2C_STOP_WAIT ; // stop hardware i2c , wait !busy (guaranteed by hardware to finish)
    i= i2c_writeData(0, sensor_i2c_addr & 0xfe, &rab, 1, 0); // no stop
    if (!i) i1= i2c_readData(0, sensor_i2c_addr | 0x01, &sensor_i2c_regs[rindx],  1, 0); //restart, not strart
    X3X3_I2C_RUN ; // let it continue (should be initialized)
    local_irq_restore(flags);
    if (i1) return -i1-1000; //error
    if (i)  return -i;       //error
  }
MD7 (printk (" new x%x\r\n",(int)sensor_i2c_regs[rindx]));

  return (int)sensor_i2c_regs[rindx];
}

int writeSensorReg(unsigned int ra, unsigned char rd, int uncond) { // returns -1 (error) , 1 - set, 0 - did not have to change
   int i, res;
   unsigned long flags;
   unsigned char rab=ra & 0xff;
   int rindx= (ra>>16) & 0x1ff; if (!rindx) rindx=rab;
   unsigned char d[2];

   if (!uncond && (sensor_i2c_regs[rindx] == rd)) {
          MD8(printk("writeSensorReg(0x%x,0x%x) did not do anything\n",(int) ra,(int) rd)); 
          return 0;

        }  
   d[0]=rab;
   d[1]=rd;
   local_irq_save(flags);
   X3X3_I2C_STOP_WAIT ; // stop hardware i2c , wait !busy (guaranteed by hardware to finish)
   i=i2c_writeData(0, sensor_i2c_addr, &d[0], 2, 1 ); //send stop
   X3X3_I2C_RUN ; // let it continue (should be initialized)
   local_irq_restore(flags);
   if (i) {
      i=d[0]; res=d[1];
      printk ("\tError writing I2C register %2x with data %2x\r\n",i,res);
      return -1;
   }
        MD8(printk("writeSensorReg(0x%x,0x%x) wrote to sensor (shadow was 0x%x)\r\n",(int) ra,(int) rd, (int) sensor_i2c_regs[rindx])); 
   sensor_i2c_regs[rindx] = rd;
        return 1;
}

// 16-bit access for Micron sensor (MT9X001) 16-bit registers
// For shadows use a pair of unsigned char elements (MSB first)
int readSensorReg16(unsigned char ra, int mode) { //  mode=0 - shadow, 1 - actual register
  int i,a;
  int i1=0;
  a=ra;
  unsigned long flags;
  if(mode) {
MD8 (printk ("ra= 0x%x, shadow was =0x%x - ",(int) ra, get_sensor_i2c_regs16(ra)));
    local_irq_save(flags);
    X3X3_I2C_STOP_WAIT ; // stop hardware i2c , wait !busy (guaranteed by hardware to finish)
    i=          i2c_writeData(0, sensor_i2c_addr & 0xfe, &ra, 1, 0); //no stop
    if (!i) i1= i2c_readData(0, sensor_i2c_addr | 0x01, &sensor_i2c_regs[a<<1],  2, 0); //restart, not strart
    X3X3_I2C_RUN ; // let it continue (should be initialized)
    local_irq_restore(flags);
    if (i1) return -i1-1000; //error
    if (i)  return -i;       //error
  }
MD8 (printk (" new 0x%x\r\n",get_sensor_i2c_regs16(ra)));
  return get_sensor_i2c_regs16(ra);
}

int writeSensorReg16(unsigned char ra, int rd, int uncond) { // returns -1 (error) , 1 - set, 0 - did not have to change
  int res, a;
  unsigned char d[3];
#ifndef USE_HARDWARE_I2C
  unsigned long flags;
#endif
  a=ra;
  d[0]=ra;
  d[1]=(rd>>8) & 0xff;
  d[2]= rd     & 0xff;
  if (!uncond && (sensor_i2c_regs[(a<<1)] == d[1]) && (sensor_i2c_regs[(a<<1)+1] == d[2]))  return 0;
#ifdef USE_HARDWARE_I2C
//  X313_I2C_ASAP
//  #define X3X3_I2C_SEND2(a,s,r,d) {port_csp0_addr[a] = (s<<24) | ((r & 0xff) << 16) | ((d & 0xff) << 8) | ((d >>8) &  0xff)}
  X3X3_I2C_SEND2(X313_I2C_ASAP, sensor_i2c_addr, a, rd);
  res=0;
#else
  local_irq_save(flags); 
  X3X3_I2C_STOP_WAIT ; // stop hardware i2c , wait !busy (guaranteed by hardware to finish)
  res=i2c_writeData(0, sensor_i2c_addr, &d[0], 3, 1); //send stop
  X3X3_I2C_RUN ; // let it continue (should be initialized)
  local_irq_restore(flags);
#endif
  if (res) {
    printk ("\tError (%x) writing 16-bit I2C register %2x with data %4x, dev_addr=%2x\r\n",res,a,((int) d[1]<<8)+ (int) d[2],sensor_i2c_addr);
    return -1;
  }
  MD8(printk("writeSensorReg(0x%x,0x%x) wrote to sensor (shadow was 0x%x)\r\n",(int) ra,(int) rd,get_sensor_i2c_regs16(a)));
  sensor_i2c_regs[(a<<1)  ] = d[1];
  sensor_i2c_regs[(a<<1)+1] = d[2];
  return 1;
}
// 12-bit access for FillFactory sensor (IBIS5) 12-bit registers
// For shadows use a pair of unsigned char elements (MSB first)

int writeSensorRegFF(unsigned char ra, int rd, int uncond) { // returns -1 (error) , 1 - set, 0 - did not have to change
  int res, a;
  unsigned char d[3];
  unsigned long flags;

  a=ra;
  d[0]=((ra & 0x0f) << 4) | ((rd >> 8) & 0x0f);
  d[1]= rd     & 0xff;
//  printk("writeSensorRegFF(0x%x,0x%x)\n",(int) ra,(int) rd);
  if (!uncond && (sensor_i2c_regs[(a<<1)] == (d[0] & 0xf)) && (sensor_i2c_regs[(a<<1)+1] == d[1])) {
          MD(printk("writeSensorRegFF(0x%x,0x%x) did not do anything\r\n",(int) ra,(int) rd));
// printk("writeSensorRegFF(0x%x,0x%x) did not do anything\n",(int) ra,(int) rd);

// write to FPGA number of lines in a frame - already done in main driver 
//          if (a==P_IBIS5_NROF_LINES) {

//            port_csp0_addr[X313_WA_NLINES]= rd;
//          }

          return 0;
  }
//  printk ("++++++++ccam_cr_shadow= %x\n", (int) ccam_cr_shadow);

  local_irq_save(flags); 
  X3X3_I2C_STOP_WAIT ; // stop hardware i2c , wait !busy (guaranteed by hardware to finish)

  if ((res=i2c_writeData(0, sensor_i2c_addr, &d[0], 2, 1))) { //send stop
    printk ("\tError (%x) writing 16-bit I2C register %2x with data %4x\r\n",res,a,((int) d[1]<<8)+ (int) d[2]);
    return -1;
  }
  X3X3_I2C_RUN ; // let it continue (should be initialized)
  local_irq_restore(flags);

  MD(printk("writeSensorReg(0x%x,0x%x) wrote to sensor (shadow was 0x%x)\r\n",(int) ra,(int) rd, ((int)sensor_i2c_regs[a<<1])<<8 +((int)sensor_i2c_regs[(a<<1)+1])));
  sensor_i2c_regs[(a<<1)  ] = (d[0] & 0x0f);
  sensor_i2c_regs[(a<<1)+1] = d[1];
  return 1;
}



static int __init 
cmoscam_init(void) {
   int res;
   ccam_cr_shadow=0;
   init_ccam_dma_buf_ptr();
   init_autoexp_struct();
   sensor_i2c_regs = (char*) sensor_i2c_regs16;

   res = register_chrdev(CMOSCAM_MAJOR, cmoscam_name, &cmoscam_fops);
   if(res < 0) {
     printk(KERN_ERR "ccam: couldn't get a major number.\n");
     return res;
   }
   if(request_irq(EXT_INTR_VECT,
                  camSeq_interrupt,
                  SA_INTERRUPT, // SA_SHIRQ | SA_INTERRUPT if it is a shared one.
                  "Elphel FPGA interrupts",
                  NULL)) {
               printk(KERN_ERR "Can't allocate Elphel FPGA interrupts");
               return -EBUSY;
    }
    printk("CMOS/MCP camera interrupts initialized\n");
    init_waitqueue_head(&x313_wait_queue);
    DMA_buf_start=x313_dma_init();
    printk(CMOSCAM_DRIVER_NAME);
    return 0;
}


static int init_FPGA(void) { //will check FPGA version, init SDRAM (if needed) and sensor
  int i;
  int f1,f2;
   // Should be initial
  if ((i=port_csp0_addr[X313__RA__MODEL]) < X313_MINMODREV) {
   printk ("too old fpga rev - found %x, software wants >= %x\n",i,X313_MINMODREV);
   return -1;   // too old FPGA
  } 
  if (i > X313_MAXMODREV) {
     printk ("too new fpga rev - found %x, software wants <= %x\n",i,X313_MAXMODREV);
     return -1;    // too new FPGA
  }
//  D5(printk("(27)=%x, ccam_cr_shadow=%x\r\n",(int)port_csp0_addr[X313_WA_SD_MODE], (int)ccam_cr_shadow));
//  if ((port_csp0_addr[X313_WA_SD_MODE] & 3)!=3) fpga_initSDRAM();
  if (!X313_IS_SDRAM_ON)  fpga_initSDRAM();
// Was sensor initialized? (What if SDRAM was initialized by some application?)
//  D5(printk("port_csp0_addr[X313_WA_SDCH0_CTL1]=%x, port_csp0_addr[X313_WA_SDCH0_CTL2]=%x\r\n",(int)port_csp0_addr[X313_WA_SDCH0_CTL1],(int)port_csp0_addr[X313_WA_SDCH0_CTL2]));
//  if ((port_csp0_addr[X313_WA_SDCH0_CTL1]& 0xffff) !=0) return 0; // channel 0 was programmed (will set dummy bit 15) - model 333
//  if ((port_csp0_addr[X313_WA_SDCH0_CTL2]& 0xffff) !=0) return 0; // channel 0 was programmed (will set dummy bit 15) - model 313
  if (X313_CHN0_USED!=0) return 0;
  D5(printk ("FPGA/Sensor need initialization. Wait 1 sec for troubleshooting\n");    udelay (1000000));

//  imageParamsR[P_CLK_SENSOR]=20000000; setClockFreq(1, imageParamsR[P_CLK_SENSOR]);
//  imageParamsR[P_CLK_FPGA]=120000000;  setClockFreq(0, imageParamsR[P_CLK_FPGA]);
//#define       X313__DCLKMODE__WIDTH            1

  f1=imageParamsR[P_CLK_SENSOR]=20000000; setClockFreq(1, imageParamsR[P_CLK_SENSOR]); X3X3_RSTSENSDCM;

//  f2=imageParamsR[P_CLK_FPGA]=120000000;  setClockFreq(0, imageParamsR[P_CLK_FPGA]);
  f2=imageParamsR[P_CLK_FPGA]=getClockFreq(0); // will not change clocks here - it needs restarting FPGA DCM in Spartan 3E
  D5(printk("clock1=%d,clck0=%d\r\n",f1,f2));
  
// needs phase adjustment too ! *****************************************************************8         
  
  udelay (50000);// 0.05 sec to stabilize clocks
  fpga_initSDRAM(); // force reinitializing SDRAM after clock change
  D5(printk ("------init_FPGA\n"));
  init_sensor();
  D5(printk ("init_sensor() finished\n"));
  udelay (1000000); // TODO: remnove this or move to condition (above)

// Init MCP here
#ifdef CONFIG_ETRAX_ELPHEL_MCP
        if (MCP_initmodule()== 0) printk ("MCP module initialized\r\n");
        else                      printk ("no MCP module detected\r\n");
#endif

  printk("FPGA rev %x\n", (unsigned int) port_csp0_addr[X313__RA__MODEL]);
  x313_tables_gammainitlinear();
  printk("Programmed linear intensity table (gamma=1.0)\n");

// printk ("Will init IRQs after 1 sec delay...\n");    udelay (1000000);



  initCamIRQs();
//printk ("initCamIRQs() Done, waiting 1 sec...\n");    udelay (1000000);


  return 1;

}

struct sensor_t kai11002={
// sensor constants
   .imageWidth  = 4008,    //nominal image width for final images
   .imageHeight = 2672,    //nominal image height for final images
   .clearWidth  = 4032,    //maximal clear image width
   .clearHeight = 2688,    //maximal clear image height;
   .clearTop    = 16,       //top margin to the first clear pixel
   .clearLeft   = 20,      //left margin to the first clear pixel
   .arrayWidth  = 4072,    //total image array width (including black and boundary)
   .arrayHeight = 2720,    //total image array height (including black and boundary)
   .minWidth    = 4,       // minimal WOI width
   .minHeight   = 3,       // minimal WOI height
   .minHorBlank = 999,     // minimal horizontal blanking, in pixels in no-decimation, no-binning mode.
   .minLineDur  = 999,     // minimal total line duration, in pixels in no-decimation, no-binning mode.
   .maxHorBlank = 9999,    // maximal horizontal blanking/Virtual frame width (depends on sensor type)
   .minVertBlank= 99,      // minimal vertical blanking
   .maxVertBlank= 9999,    // maximal vertical blanking/Virtual frame height (depends on sensor type)
   .maxShutter  = 0x3fff,  // Maximal shutter duration (in lines)
   .flips       = 3,       // bit mask bit 0 - flipX, 1 - flipY
   .dcmHor      = 0x1,    // 1,2,4,8
   .dcmVert     = 0x1,    // 1,2,4,8
   .binHor      = 0x1,    // 1
   .binVert     = 0x1,    // 1
   .maxGain256  = 4032,    // (15.75) maximal analog gain times 0x100
   .maxClockFreq= 48000000, // Maximal clock frequency
   .nomClockFreq= 48000000, //nominal clock frequency
   .sensorType  = SENSOR_KAI11000,     // sensor type (for Elphel cameras)
   .i2c_addr    = 0x10,
   .i2c_period  = 2500,     // SCL period in ns, (standard i2c - 2500)
   .i2c_bytes   = 2,        // number of bytes/ register
   .margins     = 0,        // actually - property of FPGA code, not the sensor. Will be set in common sensor code
// dynamic variables
   .pixelWidth  = 0,       // number of the pixels output in a line (including margins, decimation)
   .pixelHeight = 0        // number of the lines output in a frame (including margins, decimation)
};

int init_sensor(void) {
 int i;
// currently relies on the init script (/etc/init.d/fpga) to set 14-bit mode bit in control register. It will be used to branch to 10347/10342 here.
// edit initscript for 10359 board that will be detected as if 10347 - later we'll add JTAG reading of the FPGA pins to distinguish between 10347 and 10359
   MD10(dumpFrameParams(&frame_params,"\nframe parameters before init_sensor:"));
   program_i2c();
   X3X3_I2C_RESET_WAIT ;

  if (IS_KAI11000) {
    printk("------------------ using KAI-11000 ---------------------- \n");
    // use KAI-11000
    memcpy(&sensor, &kai11002, sizeof(kai11002));
    imageParamsR[P_SENSOR_WIDTH]=sensor.imageWidth;
    imageParamsR[P_SENSOR_HEIGHT]=sensor.imageHeight;
    imageParamsW[P_WOI_WIDTH]=sensor.imageWidth; //needed?
    imageParamsW[P_WOI_HEIGHT]=sensor.imageHeight;//needed?
    imageParamsR[P_SENSOR]= sensor.sensorType;
    imageParamsW[P_CLK_SENSOR]=sensor.nomClockFreq;
    imageParamsR[P_VIDEO]=0;
    imageParamsW[P_VIDEO]=0;
    imageParamsW[P_SKIP_FRAMES]=imageParamsR[P_SKIP_FRAMES]=0;
    sensor.margins     =X313_MARGINS; 
    writeSensorDefaults(&default_common[0],sizeof(default_common)/sizeof(default_common[0])/2); // set common defaults
    MD7(printk ("sensorType=%ld,sensor.imageWidth=%ld,sensor.imageHeight=%ld\r\n", sensor.sensorType,sensor.imageWidth,sensor.imageHeight));
    set_sensor_i2c_addr(0x20); //10347 primary page i2c address
    imageParamsW[P_IRQ_SMART] &= 2; // disaable waiting for VACT after compressor_done
    program_smart_irq();
    X3X3_RSTSENSDCM;    // start generating pclk2x
    printk ("pclk2x DCM is reset\r\n");
    i=programSensor(0); 
    udelay (1000); // needs time for DCM?
    X3X3_I2C_RUN ;
    return i;
  }

// moving here detection of MT9P001 - before programming DC-DC power that will need those pins as outputs (input for 12-bit sensors).
// a problem (bus conflict) can happen if the sensor is not recognized and FPGA outputs are anabled.
 printk("removing MRST from the sensor, setting DMA burst size, setting MCLK to 20MHz\r\n");

      ccamCRAndOr(0,0x80000000);  // just clear control register
      PROGRAM_CLK_EN(1);
      udelay (100); // apply clock before removing MRST

//printk ("Done, CCAM_MRST_OFF after 1 sec delay...\n");    udelay (1000000);

      CCAM_NEGRST;  //set negative MRST polarity
      CCAM_MRST_OFF;
      CCAM_ARST_OFF;
       writeSensorDefaults(&default_common[0],sizeof(default_common)/sizeof(default_common[0])/2); // set common defaults
      program_smart_irq();
// printk ("Trying sensors - again after 1 sec delay...\n");    udelay (1000000);
    imageParamsR[P_SENSOR]=0;
    for (i=0;i<256;i++) sensor_i2c_regs[i]=0; // shadow registers

#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
 printk("trying MT9X001\r\n");
 if (imageParamsR[P_SENSOR]==0) init_mt9x001();  // try Micron 5.0 Mpixel
#endif

//for now - disable all but 5MPix
#define ENABLE_OLD_SENSORS 1
#ifdef ENABLE_OLD_SENSORS
 if (imageParamsR[P_SENSOR]==0) { // no - it is not MT9P001)
   CCAM_CNVEN_ON;
// enable output for power converter signals

// printk("removing MRST from the sensor, setting DMA burst size, setting MCLK to 20MHz\n");
// This should be done first!!!
// printk ("Will Turn DC power for the sensor after 1 sec delay...\n");  udelay (1000000);

// turning on DC-DC converter may cause system to reboot because of a power spike, so start slow
        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
        ccamCRAndOr(0,0x80000800);      // just clear control register and re-enble outputs for converter
      CCAM_CNVEN_ON; //just in case, better mnemonic
                PROGRAM_CLK_EN(1);
                udelay (100); // apply clock before removing MRST

    CCAM_POSRST;  //set positive MRST polarity (default)
      udelay (100); // apply clock before removing MRST
                CCAM_MRST_OFF;
 }

// writeSensorDefaults(&default_common[0],sizeof(default_common)/sizeof(default_common[0])/2); // set common defaults

// printk ("Trying sensors - again after 1 sec delay...\n");    udelay (1000000);
// imageParamsR[P_SENSOR]=0;
// for (i=0;i<256;i++) sensor_i2c_regs[i]=0; // shadow registers

#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
 if (imageParamsR[P_SENSOR]==0) init_KAC1310();  // try KAC-1310
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
 if (imageParamsR[P_SENSOR]==0) init_IBIS51300();  // try IBIS5-1300
#endif
/* invert MRST for other sensors */
if (imageParamsR[P_SENSOR]==0) {
    CCAM_NEGRST;  //set negative MRST polarity
printk ("Inverted MRST, ccam_cr_shadow= %x\n", (int) ccam_cr_shadow);
                udelay (100);
    }    
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
 printk("trying MT9X001\n");
 if (imageParamsR[P_SENSOR]==0) init_mt9x001();  // try Micron 1.3/2.0/3.0 Mpixel
#endif

#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
 if (imageParamsR[P_SENSOR]==0) init_KAC5000();  // try KAC-5000
#endif

#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
 if (imageParamsR[P_SENSOR]==0) init_ZR32112(); // try ZR32112
#endif

#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
 if (imageParamsR[P_SENSOR]==0) init_ZR32212(); // try ZR32212
#endif

#endif // *************** temporary disabling other sensors ********************

 if (imageParamsR[P_SENSOR]==0) {
   sensor.sensorType=SENSOR_NONE;
   imageParamsR[P_SENSOR]=SENSOR_NONE; // to prevent from initializing again
   printk("No image sensor found\r\n");
//   return -1;
 }
 imageParamsR[P_SENSOR_WIDTH]=sensor.imageWidth;
 imageParamsR[P_SENSOR_HEIGHT]=sensor.imageHeight;
 imageParamsW[P_WOI_WIDTH]=sensor.imageWidth; //needed?
 imageParamsW[P_WOI_HEIGHT]=sensor.imageHeight;//needed?
 imageParamsR[P_SENSOR]= sensor.sensorType;
 imageParamsW[P_CLK_SENSOR]=sensor.nomClockFreq;
 imageParamsR[P_VIDEO]=1;
 imageParamsW[P_VIDEO]=1;
 sensor.margins     =X313_MARGINS; 

  imageParamsW[P_I2C_QPERIOD]= (sensor.i2c_period * (imageParamsR[P_CLK_FPGA]/1000))/4000000;
  imageParamsW[P_I2C_BYTES]=sensor.i2c_bytes;
  program_i2c();
  X3X3_I2C_RESET_WAIT ;
  X3X3_I2C_RUN ;
  imageParamsR[P_FRAME]=0 ; // when sensor is reset;

MD7(printk ("sensorType=%ld,sensor.imageWidth=%ld,sensor.imageHeight=%ld,sensor.margins=%ld\r\n", sensor.sensorType,sensor.imageWidth,sensor.imageHeight,sensor.margins));

 return programSensor(0); 
}


//#define CX313_FPGA_TABLES_FOCUSPARS 0xbc0 //block of focus-related parameters: left[11:0],right[11:0],top[11:0],bottom[11:0],full_width[11:0],filter_sel[3:0]
//#define P_FOCUS_SHOW     93 // show focus information instead of/combined with the image:
//                            // 0 - regular image, 1 - block focus instead of Y DC (AC=0), 2 - image Y DC combined all frame, 3 combined in WOI
//#define P_FOCUS_SHOW1    94 // Additional parameter that modifies visualization mode. Currently just a single bit (how much to add)
//#define P_FOCUS_VALUE    95 // (readonly) - sum of all blocks focus values inside focus WOI
//#define P_FOCUS_LEFT     96 // focus WOI left margin, inclusive (3 LSB will be zeroed as it should be multiple of 8x8 block width) 
//#define P_FOCUS_WIDTH    97 // focus WOI width (3 LSB will be zeroed as it should be multiple of 8x8 block width) 
//#define P_FOCUS_TOP      98 // focus WOI top margin, inclusive (3 LSB will be zeroed as it should be multiple of 8x8 block height) 
//#define P_FOCUS_HEIGHT   99 // focus WOI height (3 LSB will be zeroed as it should be multiple of 8x8 block height) 
//#define P_FOCUS_TOTWIDTH 100 // (readonly) - total width of the image frame in pixels
//#define P_FOCUS_FILTER  101 // select 8x8 filter used for the focus calculation (same order as quantization coefficients), 0..14
void x313_program_focus(int totalwidth) {
  unsigned long flags;
  totalwidth&= 0xfff0;
  int left, right, top, bottom, filter_no,show1;
  show1=imageParamsW[P_FOCUS_SHOW1];
  left=imageParamsW[P_FOCUS_LEFT] & 0xff8;
  right=(left+imageParamsW[P_FOCUS_WIDTH] -8);
  if (right<0) {
    right=0;
    left=8;
  }
  else if (right >  0xfff) right = 0xfff;
  right &=0xff8;

  top=imageParamsW[P_FOCUS_TOP] & 0xff8;
  bottom=(top+imageParamsW[P_FOCUS_HEIGHT] -8);
  if (bottom<0) {
   bottom=0;
   top=8;
  }
  else if (bottom >  0xfff) bottom = 0xfff;
  bottom &=0xff8;

  filter_no=imageParamsW[P_FOCUS_FILTER];
  if   (filter_no > 14) filter_no=14;

  if ((totalwidth!=imageParamsR[P_FOCUS_TOTWIDTH]) ||
      (left   != imageParamsR[P_FOCUS_LEFT]) ||
      (right  != (left+imageParamsR[P_FOCUS_WIDTH] -8)) ||
      (top    != imageParamsR[P_FOCUS_TOP]) ||
      (bottom != (top+imageParamsR[P_FOCUS_HEIGHT] -8)) ||
      (filter_no != imageParamsR[P_FOCUS_FILTER]) ||
      (show1  != imageParamsR[P_FOCUS_SHOW1])) {
      imageParamsR[P_FOCUS_SHOW1]=   show1;
      imageParamsR[P_FOCUS_TOTWIDTH]=totalwidth;
      imageParamsR[P_FOCUS_LEFT]=    left;
      imageParamsR[P_FOCUS_WIDTH]=   right-left+8;
      imageParamsR[P_FOCUS_TOP]=     top;
      imageParamsR[P_FOCUS_HEIGHT]=  bottom-top+8;
      imageParamsR[P_FOCUS_FILTER]=  filter_no;
      local_irq_save(flags);
      //local_irq_disable();
      port_csp0_addr[X313_WA_COMP_TA]=CX313_FPGA_TABLES_FOCUSPARS; 
      port_csp0_addr[X313_WA_COMP_TD]=left;     
      port_csp0_addr[X313_WA_COMP_TD]=right;
      port_csp0_addr[X313_WA_COMP_TD]=top;
      port_csp0_addr[X313_WA_COMP_TD]=bottom;
      port_csp0_addr[X313_WA_COMP_TD]=totalwidth-1;
      port_csp0_addr[X313_WA_COMP_TD]=filter_no;
      port_csp0_addr[X313_WA_COMP_TD]=show1;
      port_csp0_addr[X313_WA_COMP_TA]=CX313_FPGA_TABLES_FOCUSPARS; 
      local_irq_restore(flags);
  } 
//HACK?: Set focus display mode (TODO: remove fixed bit locations)
  imageParamsR[P_FOCUS_SHOW]=imageParamsW[P_FOCUS_SHOW] & 3;
  x313_JPEG_ctrl((x313_get_JPEG_ctrl() & 0x9fff) | (imageParamsR[P_FOCUS_SHOW] << 13));
}


/* 
 * ************************* programSensor ************************
 */
static int program_KAI11000(void) {
 printk("here programmimbg KAI11000\n");
 return 1; // always success
}
#define PROGRAM_SENSOR_DIS_IRQ 0
static int programSensor(int nonstop){   // program appropriate sensor
        struct hist_sensor_t *hist_s = NULL;
//      unsigned long scale;
    float fscale_r;
    float fscale_g;
    float fscale_b;
    float fscale_g1;
    int   hact_shift;    // 0..3 - HACT phase shift
    unsigned long scale_r;
    unsigned long scale_g;
    unsigned long scale_b;
    unsigned long scale_g1;
    int ntilex,ntiley,padlen,n,sa,i;
// there is a mess here, let's add some more
    int ntilex_compressor,ntiley_compressor; // what is actually written to chn 2 memory

    int dh,dv,bh,bv,l,h,t,timestamp_len,pfh,pf_stripes;
    int goodEOL=0;
        int sensRslt=0;   // sensor specific result
#if PROGRAM_SENSOR_DIS_IRQ
        unsigned long flags;
#endif
    short * shortP;
    int  scales_changed;
 MD1(printk("programSensor:, imageParamsR[P_PARS_CHANGED]=%x, nonstop=%d\n", (int) imageParamsR[P_PARS_CHANGED], nonstop));
        MD11(printk ("programSensor rp=0x%x, wp=0x%x\r\n", JPEG_rp, JPEG_wp ));

// Changing frequency of the sensor confuses MT9P031 - it can get 0/1 pixel horizonatl shift, so sensor requires reset+reinitialization
// after frequency change
   imageParamsR[P_TASKLET_CTL]=imageParamsW[P_TASKLET_CTL];

  if (imageParamsW[P_CLK_SENSOR]) {
     if (setClockFreq(1, imageParamsW[P_CLK_SENSOR])>=0) imageParamsR[P_CLK_SENSOR]=imageParamsW[P_CLK_SENSOR];
     imageParamsW[P_CLK_SENSOR]=0;
     X3X3_RSTSENSDCM;
//#define CCAM_SET_HACT_PHASE(x) ccamCRAndOr(~X313_MASK(HACT_PHASE), X313_BITS(HACT_PHASE, (x)))

// set HACT PHASE here

     hact_shift= 0.004 * (sensor.hact_delay/(1000000000.0/imageParamsR[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) ;
// turn sensor phase here
// TODO need to add finding the correct phase - may be found once for sensor+fpga_image+frequency and saved
// to measure correctly phase you need to give enough time for each measurement (sensor should output some image data, preferrably test pattern
// so bit2 for 12-bit 5MPix (bit 0 for older 10-bit) will have all the combinations of 0 after 1, 1 after 0
// procedure will be:
// 1: set/change phase (may watch DCM state)
// 2: X3X3_SENSDCM_NOP to reset error counters (error is a mismatch between data at strobe and two aux. ones - 1/4Tclk early and 1/4Tclk late)
// 3: wait for some data to pass through (at least one sensor line)
// read X313_SENSOR_PHASE
// if it is <2 (MSB=0) the phase is correct and no changes are needed (with 96MHz and slow outputs that will not be the case at any phase)
// if there is an error, look at the LSB that shows direction to change. Start with 90 degrees until there will be "right" transition,
// i.e. while X3X3_SENSDCM_INC90 the LSB will change from 1 to 0 (don't remember to exit if MSB=0)
// Then reverse direction and go with X3X3_SENSDCM_DEC until the LSB will be 1 again (or MSB=0). That will be the right phase

//#define P_SENSOR_PHASE  513 // packed, low 16 bit - signed fine phase, bits [18:17] - 90-degrees shift
   MD12(printk("imageParamsR[%d]=0x%x imageParamsW[%d]=0x%x\r\n", (int) P_SENSOR_PHASE, (int) imageParamsR[P_SENSOR_PHASE], (int) P_SENSOR_PHASE, (int) imageParamsW[P_SENSOR_PHASE]) );
   if (imageParamsW[P_SENSOR_PHASE] !=0 ) { // if needed 0, may set some unused bit
     imageParamsR[P_SENSOR_PHASE]=imageParamsW[P_SENSOR_PHASE];
     imageParamsW[P_SENSOR_PHASE]=0;
   }

   if (imageParamsR[P_SENSOR_PHASE] !=0 ) { // unpack and use instead of the table data
     MD12(printk("imageParamsR[%d]=0x%x\r\n", (int) P_SENSOR_PHASE, (int) imageParamsR[P_SENSOR_PHASE]));
     shortP= (short * ) &imageParamsR[P_SENSOR_PHASE];
     sensor.sensorPhase=  shortP[0];
     sensor.sensorPhase90=shortP[1] & 3; //to mark as used
     MD12(printk ("sensor.sensorPhase=0x%x, sensor.sensorPhase90=0x%x\r\n",(int) sensor.sensorPhase, (int) sensor.sensorPhase90));
   }
// possibly adjust phase here

   for (i=sensor.sensorPhase90;i>0;i--) {
      X3X3_SENSDCM_INC90 ;  // (0..3) 90-degree shift (fpcf -w 8 80)
   }
   if      (sensor.sensorPhase > 0) for (i=sensor.sensorPhase; i > 0; i--) {X3X3_SENSDCM_INC ; udelay(1); }
   else if (sensor.sensorPhase < 0) for (i=sensor.sensorPhase; i < 0; i++) {X3X3_SENSDCM_DEC ; udelay(1); }
// write back possibly modified phase
   shortP= (short * ) &imageParamsR[P_SENSOR_PHASE];
   shortP[0] = sensor.sensorPhase;
   shortP[1] = sensor.sensorPhase90 | 4;
    MD12(printk("imageParamsR[%d]=0x%x\r\n", (int) P_SENSOR_PHASE, (int) imageParamsW[P_SENSOR_PHASE]));

     switch (imageParamsR[P_SENSOR] & SENSOR_MASK) {

//#ifdef CONFIG_ETRAX_ELPHEL_KAI11000
      case SENSOR_KAI11000: { break;}
//#endif


#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
      case SENSOR_ZR32112:  { break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
      case SENSOR_ZR32212:  { break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
      case SENSOR_KAC1310:  { break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
      case SENSOR_KAC5000:  { break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
      case SENSOR_MT9X001:  // { break;}//0x30..0x33
      case SENSOR_MT9Y001: //0x34..0x37
          {
// reset/reinitialize MT9P001 sensor;
        CCAM_MRST_ON;
        udelay (100); // apply clock before removing MRST
        CCAM_MRST_OFF;
        printk ("Resetting sensor after sensor clock change\n");
        init_mt9x001();
        sensor.margins     =X313_MARGINS; 
// it seems that something else is still not restored after sensor reset.
// maybe just save/restore registers of the sensor?

        nonstop=0; // can not make nonstop if senosor is reset
      break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
      case SENSOR_IBIS51300:  { break;}
#endif
     } //switch
  }


  if ((imageParamsR[P_SENSOR] & SENSOR_MASK)==SENSOR_NONE) {
    printk("can not program unknown/unexistent sensor\r\n");
//    port_csp0_addr[X313_WA_SDCH0_CTL1]=0x8000; // sensor will be considered initialized - model 333
//    port_csp0_addr[X313_WA_SDCH0_CTL2]=0x8000; // sensor will be considered initialized - model 313 ?
    X313_CHN0_SET_USED;
    return 0; // do nothing if no sensor is present
  }

//   if ((imageParamsR[P_SENSOR] & SENSOR_MASK)==SENSOR_KAI11000) {
//    printk("can not program KAI11000 sensor (yet)\n");
//    return 0; // do nothing if no sensor is present
//  }
  if(down_interruptible(&sensor_lock) != 0) return -1;


// remove disabling irqs if desired
   MD8(printk("nonstop=%d\r\n", nonstop));

   if (!nonstop) {
     imageParamsR[P_OVERSIZE]=imageParamsW[P_OVERSIZE]?1:0;
#if PROGRAM_SENSOR_DIS_IRQ
     local_irq_save(flags);
#endif
     MD11(printk ("program sensor, !nonstop -> ...  "));

     camSeqStop();   // to reset data transefer to SDRAM from sensor - it could disturb pointers if let on
MD6(printk ("programSensor  imageParamsR[P_PARS_CHANGED]=0x%x\r\n",imageParamsR[P_PARS_CHANGED]));
     imageParamsR[P_PARS_CHANGED]=1;

   }
   if (imageParamsR[P_PARS_CHANGED]) { // Maybe (to make it work faster) do not call program sensor if only some parameters are changed?
    imageParamsR[P_EXPOS]= (imageParamsW[P_EXPOS]>0)?imageParamsW[P_EXPOS]:1;
    
    if ((imageParamsW[P_COLOR_SATURATION_BLUE] != imageParamsR[P_COLOR_SATURATION_BLUE]) ||
        (imageParamsW[P_COLOR_SATURATION_RED] != imageParamsR[P_COLOR_SATURATION_RED])) {
        if (imageParamsW[P_COLOR_SATURATION_BLUE]<0) imageParamsW[P_COLOR_SATURATION_BLUE]=0;
        if (imageParamsW[P_COLOR_SATURATION_RED]<0)  imageParamsW[P_COLOR_SATURATION_RED]=0;
        if ((imageParamsW[P_COLOR_SATURATION_BLUE]*DEFAULT_COLOR_SATURATION_BLUE) > 102300)
          imageParamsW[P_COLOR_SATURATION_BLUE]=102300/DEFAULT_COLOR_SATURATION_BLUE;
        if ((imageParamsW[P_COLOR_SATURATION_RED]*DEFAULT_COLOR_SATURATION_RED) > 102300)
          imageParamsW[P_COLOR_SATURATION_RED]=102300/DEFAULT_COLOR_SATURATION_RED;
        imageParamsR[P_COLOR_SATURATION_BLUE]=imageParamsW[P_COLOR_SATURATION_BLUE];
        imageParamsR[P_COLOR_SATURATION_RED]=imageParamsW[P_COLOR_SATURATION_RED];
//        port_csp0_addr[X313_WA_COLOR_SAT] = ((DEFAULT_COLOR_SATURATION_BLUE*imageParamsR[P_COLOR_SATURATION_BLUE])/100) |
//                                           (((DEFAULT_COLOR_SATURATION_RED *imageParamsR[P_COLOR_SATURATION_RED])/100)<<16);
//TODO:add to Exif
       frame_params.colorsat = ((DEFAULT_COLOR_SATURATION_BLUE*imageParamsR[P_COLOR_SATURATION_BLUE])/100) |
                               (((DEFAULT_COLOR_SATURATION_RED *imageParamsR[P_COLOR_SATURATION_RED])/100)<<16);
       port_csp0_addr[X313_WA_COLOR_SAT]=frame_params.colorsat;
    }

//set fame sync delay
      
      port_csp0_addr[X313_WA_FRAMESYNC_DLY]= imageParamsR[P_FRAMESYNC_DLY]=  imageParamsW[P_FRAMESYNC_DLY];
//P_FRAMESYNC_DLY     
//X313_WA_FRAMESYNC_DLY    
    
// TODO: stop sensor if running before writing parameters ?? probably not needed
    if (!nonstop) {
      imageParamsR[P_DMA_VALID]=0;
// process common parameters (not sensor specific)
      imageParamsR[P_PAGE_ACQ]=imageParamsW[P_PAGE_ACQ]; // number of page for image acquisition
      imageParamsR[P_BGFRAME]= imageParamsW[P_BGFRAME]; // number of page for image acquisition
      imageParamsR[P_OVERLAP]=imageParamsW[P_OVERLAP];

//      imageParamsR[P_TRIG]=  imageParamsW[P_TRIG];
// don't touch bit 2 - async trigger mode
      imageParamsR[P_TRIG]=  (imageParamsR[P_TRIG] & 4) | (imageParamsW[P_TRIG] & ~4);
      imageParamsR[P_VIRTTRIG]=  imageParamsW[P_VIRTTRIG];
      imageParamsR[P_BITS]=  (imageParamsW[P_BITS] < 5)? 4 : (imageParamsW[P_BITS] < 9)? 8: 10; // TODO: add DMA size support 
      
//      imageParamsR[P_FPN]=   imageParamsW[P_FPN];
      imageParamsR[P_SHIFTL]=imageParamsW[P_SHIFTL]& 0x7;
      imageParamsR[P_FPNS]=   imageParamsW[P_FPNS] & 0x7;
      imageParamsR[P_FPNM]=   imageParamsW[P_FPNM] & 0x7;
      imageParamsR[P_AUXCM]=(imageParamsW[P_AUXCM] < 2)? imageParamsW[P_AUXCM] : 2;
      imageParamsR[P_MCLK]=  (imageParamsW[P_MCLK]<129)?((imageParamsW[P_MCLK]>1)?imageParamsW[P_MCLK]:((imageParamsW[P_MCLK]>0)?2:0)):129;
//      if ((imageParamsW[P_FPSLM] & ~3) == 0) imageParamsR[P_FPSLM]=  imageParamsW[P_FPSLM] & 0x3; // -1 - don't change
//MD9 (printk ("\r\n============ imageParamsW[P_FPSLM]=0x%08x=== imageParamsR[P_FPSLM]=0x%08x\r\n",imageParamsW[P_FPSLM],imageParamsR[P_FPSLM]));

      PROGRAM_CLK_EN(1);
    }
// make it work always? Even in non-stop mode?
    if ((imageParamsW[P_FPSLM] & ~3) == 0) imageParamsR[P_FPSLM]=  imageParamsW[P_FPSLM] & 0x3; // -1 - don't change
MD9 (printk ("\r\n============ imageParamsW[P_FPSLM]=0x%08x=== imageParamsR[P_FPSLM]=0x%08x\r\n",imageParamsW[P_FPSLM],imageParamsR[P_FPSLM]));
// set period to 0 - should be updated by sensors specific routines
    imageParamsR[P_PERIOD]=0;  // should be calculated even when not stopping
// process  sensor specific parameters
    sensRslt=-1;

/*
 * autoexposure: begin
 * exposure time correction
 */
        /* can't sleep process - all ok ! */
//      hist_image_exp(get_imageParamsR(P_EXPOS));
        hist_image_exp(get_imageParamsR(P_VEXPOS));
        hist_s = hist_sensor_lock();
        if(hist_s != NULL) {
                set_imageParamsW(P_VEXPOS, hist_s->exposure);
//              set_imageParamsW(P_EXPOS, hist_s->exposure);
                hist_sensor_unlock();
        }
/*
 * autoexposure: end
 */
//printk("\n\nimageParamsW[P_RSCALE] == 0x%04X; imageParamsR[P_RSCALE] == 0x%04X\n", imageParamsW[P_RSCALE], imageParamsR[P_RSCALE]);
//printk("imageParamsW[P_BSCALE] == 0x%04X; imageParamsR[P_BSCALE] == 0x%04X\n", imageParamsW[P_BSCALE], imageParamsR[P_BSCALE]);


//   set_gamma(imageParamsR[P_GAMMA], imageParamsR[P_PIXEL_LOW], scale_r, scale_g, scale_b, scale_g1);
 if ((imageParamsW[P_GAMMA]     != imageParamsR[P_GAMMA]) ||
     (imageParamsW[P_PIXEL_LOW] != imageParamsR[P_PIXEL_LOW] ) ||
     (imageParamsW[P_PIXEL_HIGH]!= imageParamsR[P_PIXEL_HIGH] ) ||
     (imageParamsW[P_RSCALE]    != imageParamsR[P_RSCALE] ) ||
     (imageParamsW[P_GSCALE]    != imageParamsR[P_GSCALE] ) ||
     (imageParamsW[P_BSCALE]    != imageParamsR[P_BSCALE] ))  {

    imageParamsR[P_GAMMA]=imageParamsW[P_GAMMA]; // copy values
    imageParamsR[P_PIXEL_LOW]=imageParamsW[P_PIXEL_LOW]; // copy values
    imageParamsR[P_PIXEL_HIGH]=imageParamsW[P_PIXEL_HIGH]; // copy values

    scales_changed=0;
    scale_g1 = imageParamsW[P_GSCALE]; 
    if(scale_g1 > SCALE_MAX)
       scale_g1 = SCALE_MAX;
    if(scale_g1 < SCALE_MIN)
       scale_g1 = SCALE_MIN;
    if (imageParamsR[P_GSCALE] != scale_g1 ) { imageParamsR[P_GSCALE]=scale_g1; scales_changed=1; }
    fscale_g1 = scale_g1;
    fscale_g1 /= 0x100;
    scale_r = imageParamsW[P_RSCALE];
    if(scale_r > SCALE_MAX)
       scale_r = SCALE_MAX;
    if(scale_r < SCALE_MIN)
       scale_r = SCALE_MIN;
    if (imageParamsR[P_RSCALE] != scale_r ) { imageParamsR[P_RSCALE]=scale_r; scales_changed=1; }
    fscale_r = scale_r;
    fscale_r /= 0x100;
    scale_b = imageParamsW[P_BSCALE];
    if(scale_b > SCALE_MAX)
       scale_b = SCALE_MAX;
    if(scale_b < SCALE_MIN)
       scale_b = SCALE_MIN;
    if (imageParamsR[P_BSCALE] != scale_b ) { imageParamsR[P_BSCALE]=scale_b; scales_changed=1; }
    if (scales_changed){
MD13(printk("imageParamsW[P_GAMMA]=      0x%x, imageParamsR[P_GAMMA]=      0x%x\n" \
            "imageParamsW[P_PIXEL_LOW]=  0x%x, imageParamsR[P_PIXEL_LOW]=  0x%x\n" \
            "imageParamsW[P_PIXEL_HIGH]= 0x%x, imageParamsR[P_PIXEL_HIGH]= 0x%x\n" \
            "imageParamsW[P_RSCALE]=     0x%x, imageParamsR[P_RSCALE]=     0x%x\n" \
            "imageParamsW[P_GSCALE]=     0x%x, imageParamsR[P_GSCALE]=     0x%x\n" \
            "imageParamsW[P_BSCALE]=     0x%x, imageParamsR[P_BSCALE]=     0x%x\n", \
             (int) imageParamsW[P_GAMMA],      (int) imageParamsR[P_GAMMA], \
             (int) imageParamsW[P_PIXEL_LOW],  (int) imageParamsR[P_PIXEL_LOW], \
             (int) imageParamsW[P_PIXEL_HIGH], (int) imageParamsR[P_PIXEL_HIGH], \
             (int) imageParamsW[P_RSCALE],     (int) imageParamsR[P_RSCALE], \
             (int) imageParamsW[P_GSCALE],     (int) imageParamsR[P_GSCALE], \
             (int) imageParamsW[P_BSCALE],     (int) imageParamsR[P_BSCALE]));

      fscale_b = scale_b;
      fscale_b /= 0x100;
      fscale_g = 1.0;
//    set_imageParamsR(P_GAINB, imageParamsW[P_GAINB]);
    /* normalize scale */
      if((fscale_r < fscale_g) || (fscale_b < fscale_g) || (fscale_g1 < fscale_g)) {
       if((fscale_r < fscale_b) && (fscale_r < fscale_g1)) {
          fscale_g1 /= fscale_r;
          fscale_g  /= fscale_r;
          fscale_b  /= fscale_r;
          fscale_r = 1.0; //AF:-)
       } else {
          if(fscale_b < fscale_g1) {
            fscale_r  /= fscale_b;
            fscale_g  /= fscale_b;
            fscale_g1 /= fscale_b;
            fscale_b = 1.0;  //AF:-)
          } else {
            fscale_r /= fscale_g1;
            fscale_g /= fscale_g1;
            fscale_b /= fscale_g1;
            fscale_g1 = 1.0;
          }
       }
      }
      scale_r  = fscale_r  * 0x100;
      scale_g  = fscale_g  * 0x100;
      scale_b  = fscale_b  * 0x100;
      scale_g1 = fscale_g1 * 0x100;
      gains.used = 1;

// TODO: move above gain calculations outside   
   
   
        /* apply gamma */
          set_gamma(imageParamsR[P_GAMMA], imageParamsR[P_PIXEL_LOW], scale_r, scale_g, scale_b, scale_g1);
  } 
} 

//TODO:add to Exif
    frame_params.gamma=imageParamsR[P_GAMMA];
    frame_params.black=imageParamsR[P_PIXEL_LOW]; // no support for P_PIXEL_HIGH in the data stored in circbuf
//TODO:add to Exif
    frame_params.rscale=imageParamsR[P_RSCALE];
    frame_params.bscale=imageParamsR[P_BSCALE];



   imageParamsR[P_COLOR]=imageParamsW[P_COLOR];

// common part of decimation/binning calculation
   if (!nonstop) {
 // copy enabled bits from imageParamsW[P_FLIP] to imageParamsR[P_FLIP]
     if (sensor.flips & 1) imageParamsR[P_FLIP]=((imageParamsR[P_FLIP] ^ imageParamsW[P_FLIP]) & (sensor.flips & 3)) ^ imageParamsR[P_FLIP];
     dh = imageParamsW[P_DCM_HOR];
     dv = imageParamsW[P_DCM_VERT];
     if (dh<1) dh=1; else if (dh>32) dh=32;
     if (dv<1) dv=1; else if (dv>32) dv=32;
    MD8(printk("dv=%d, dh=%d\r\n", dv,dh));

     while ((dh>1) && !(sensor.dcmHor  & (1 << (dh-1)))) dh--;
     while ((dv>1) && !(sensor.dcmVert & (1 << (dv-1)))) dv--;
     bh = imageParamsW[P_BIN_HOR]; if (bh<1) bh=1; else if (bh>dh) bh=dh;
     bv = imageParamsW[P_BIN_VERT];if (bv<1) bv=1; else if (bv>dv) bv=dv;
     while ((bh>1) && !(sensor.dcmHor  & (1 << (bh-1)))) bh--;
     while ((bv>1) && !(sensor.dcmVert & (1 << (bv-1)))) bv--;
     imageParamsR[P_DCM_HOR] = dh;
     imageParamsR[P_DCM_VERT]= dv;
     imageParamsR[P_BIN_HOR] = bh;
     imageParamsR[P_BIN_VERT]= bv;
//TODO:add to Exif

//     frame_params.bindec_hor= ((bh-1)<<4) | ((dh-1) & 0xf);     // (binning/decimation horizontal, 1..16 for each)
//     frame_params.bindec_vert=((bv-1)<<4) | ((dv-1) & 0xf);     // (binning/decimation vertical  , 1..16 for each)

    MD8(printk("dv=%d, dh=%d\r\n", dv,dh));
// sensor-specific binning adjustment (not all combinations are valid)   
     switch (imageParamsR[P_SENSOR] & SENSOR_MASK) {
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
      case SENSOR_MT9X001: //0x30..0x33
      case SENSOR_MT9Y001: //0x34..0x37
      adjustBinning_mt9x001();
      break;
#endif
     } //switch, sensor-specific decim/bin
// adjust WOI width (will be less in timestamp mode 2)
     timestamp_len = (((imageParamsW[P_PF_HEIGHT] >> 16) & 3)==2)? X313_TIMESTAMPLEN*dh : 0;
// adjust width/height first, then adjust left top
     l=imageParamsW[P_WOI_WIDTH];
     if (!imageParamsR[P_OVERSIZE]) {
       if ((l-timestamp_len) > sensor.imageWidth) l = sensor.imageWidth+timestamp_len;
     } 
     l=l/dh/X313_TILEHOR;
     l*=X313_TILEHOR;
// suppose minimal width refers to decimated output      
     while (l < sensor.minWidth) l+=X313_TILEHOR;
     imageParamsR[P_ACTUAL_WIDTH]=l;
     sensor.pixelWidth=l+sensor.margins-timestamp_len;
     MD8(printk("sensor.pixelWidth=0x%x, sensor.margins=0x%x\r\n", sensor.pixelWidth,sensor.margins));
     l*=dh;
//     l-=timestamp_len; // normally - 0, else X313_TIMESTAMPLEN*dh
     imageParamsR[P_WOI_WIDTH]=l; // decreased for time stamp if any
// adjust WOI height (will be less in timestamp mode 2)
//     pfh = (imageParamsW[P_PF_HEIGHT] & 0xffff) * dv; // corrected to decimation
     pfh = (imageParamsW[P_PF_HEIGHT] & 0xffff);
     h=imageParamsW[P_WOI_HEIGHT];
     if(pfh > 0) {
       if (pfh < sensor.minHeight)  pfh =  sensor.minHeight;
       if (imageParamsR[P_COLOR] && (pfh & 1)) pfh++;
       if (h > X313_MAXHEIGHT*dv) h=X313_MAXHEIGHT*dv;
       pf_stripes = h / (pfh * dv);
       if(pf_stripes < 1) pf_stripes = 1;
       sensor.pixelHeight=pfh;
//pfh - output lines, not programmed (they are  *dv)       
     } else {
       if (!imageParamsR[P_OVERSIZE]) {
         if (h > sensor.imageHeight) h=sensor.imageHeight;
       }
       h=h/dv/X313_TILEVERT;
       h*=X313_TILEVERT;
// suppose minimal height refers to decimated output      
       while (h < sensor.minHeight) h+=X313_TILEVERT;
       sensor.pixelHeight=h+sensor.margins;
       h*=dv;        
       pf_stripes = 0;
       pfh = 0;
     }
     imageParamsR[P_PF_HEIGHT]=(imageParamsW[P_PF_HEIGHT] & 0xffff0000) | pfh;
     imageParamsR[P_WOI_HEIGHT]=h;
     imageParamsR[P_ACTUAL_HEIGHT]=h/dv;
     MD8(printk("pfh=0x%x, pf_stripes=0x%x, h=%d(0x%x)\r\n", pfh, pf_stripes,h,h));
   } else {//(!nondtop)
      dh = imageParamsR[P_DCM_HOR];
      dv = imageParamsR[P_DCM_VERT];
      pfh= imageParamsR[P_PF_HEIGHT] & 0xffff;
      timestamp_len = (((imageParamsR[P_PF_HEIGHT] >> 16) & 3)==2)? X313_TIMESTAMPLEN*dh : 0;
   }
//#define P_FLIP          30 // bit 0 - horizontal, bit 1 - vertical
//TODO:add to Exif
   frame_params.color=(imageParamsR[P_COLOR] & 0x0f) | (imageParamsR[P_FLIP] << 6) ;

   MD8(printk("sensor.pixelWidth=0x%lx, sensor.pixelHeight=0x%lx\r\n", sensor.pixelWidth,sensor.pixelHeight));

//   unsigned long  pixelWidth;     // number of the pixels output in a line (including margins, decimation)
//   unsigned long  pixelHeight;    // number of the lines output in a frame (including margins, decimation)


// adjusted always (for any nonstop)   
// left margin     
        l = imageParamsW[P_WOI_LEFT];
   if (!imageParamsR[P_OVERSIZE]) {
           if(imageParamsR[P_COLOR])
                   l &= 0xfffe;
           if((l < 0) || (l & 0x8000))
                   l = 0;
           if ((l + imageParamsR[P_WOI_WIDTH] + sensor.margins) > sensor.clearWidth) { 
                   l = sensor.clearWidth - imageParamsR[P_WOI_WIDTH] - sensor.margins;
                   if(imageParamsR[P_COLOR])
                           l &= 0xfffe;
           }
           if(l & 0x8000) l = 0;
   }
        imageParamsR[P_WOI_LEFT] = l; // maybe adjusted later by sensor-specific function
// top margin
        t = imageParamsW[P_WOI_TOP];
   if (!imageParamsR[P_OVERSIZE]) {
        if(imageParamsR[P_COLOR])
                t &= 0xfffe;
           if((t < 0) || (t & 0x8000))
                   t = 0;
           if(pfh > 0) {
                   if((t + pfh * dv) > sensor.clearHeight)
                        t = sensor.clearHeight - pfh * dv;
           } else {
                   if((t + imageParamsR[P_WOI_HEIGHT] + sensor.margins) > sensor.clearHeight)
                           t = sensor.clearHeight - imageParamsR[P_WOI_HEIGHT] - sensor.margins;
           }
      if (imageParamsR[P_COLOR]) t &= 0xfffe;
   }
   imageParamsR[P_WOI_TOP]=t; // maybe adjusted later by sensor-specific function

if  (imageParamsW[P_CLK_SENSOR]  > sensor.maxClockFreq) imageParamsW[P_CLK_SENSOR] = sensor.maxClockFreq;
imageParamsR[P_FPGA_XTRA]=imageParamsW[P_FPGA_XTRA];
   
      
   switch (imageParamsR[P_SENSOR] & SENSOR_MASK) {

//#ifdef CONFIG_ETRAX_ELPHEL_KAI11000
      case SENSOR_KAI11000: { CCAM_ARST_OFF; sensRslt=program_KAI11000();break;}
//#endif


#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
      case SENSOR_ZR32112: { CCAM_ARST_OFF; sensRslt=program_ZR32112();break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
      case SENSOR_ZR32212: {CCAM_ARST_OFF; sensRslt=program_ZR32212();break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
      case SENSOR_KAC1310: {sensRslt=program_KAC1310(nonstop);break;} // add nonstop here too
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
      case SENSOR_KAC5000: {sensRslt=program_KAC5000(nonstop);break;} // add nonstop here too
#endif
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
      case SENSOR_MT9X001: //0x30..0x33
      case SENSOR_MT9Y001: //0x34..0x37
//      if ((imageParamsR[P_SENSOR] & 7)!=0) {sensRslt=program_mt9x001(nonstop);break;}
      if ((imageParamsR[P_SENSOR] & 7)!=0) {
//         printk("programming mt9p001\r\n");
//sensRslt - number of frames to skip after changing parameters         
         sensRslt=program_woi_mt9x001(nonstop);
         if (sensRslt>=0) {i=program_gains_mt9x001();    if ((i<0) || (i>sensRslt)) sensRslt=i;} // now - always <= 0 ?
// moved outside individual sensors
//         if (sensRslt>=0) {i=program_exposure_mt9x001(); if ((i<0) || (i>sensRslt)) sensRslt=i;} // now - always <= 0 ?
      break;}
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
      case SENSOR_IBIS51300: {sensRslt=program_IBIS51300();break;}  // add nonstop here too
#endif
   } //switch

#if 0
        if(sensRslt>= 0) {
                i = program_sensor_exposition_just();
                if((i < 0) || (i > sensRslt))
                        sensRslt = i;
        } // now - always <= 0 ?
#endif
// Sensor might modify sensor.pixelWidth, sensor.pixelHeight
//TODO: adjust P_WOI_WIDTH, P_ACTUAL_WIDTH (and height) accordingly



// restore line length to the full length (above was sensor pixels)   
//   imageParamsR[P_WOI_WIDTH]+=timestamp_len; // normally - 0, else X313_TIMESTAMPLEN*dh
/* refresh histogramm (autoexposure) window */
   hist_image_size(get_imageParamsR(P_ACTUAL_WIDTH), get_imageParamsR(P_ACTUAL_HEIGHT));
// Bayer phase will be set in individual driver, but if it was explicitly specified - overwrite it   
   if (imageParamsW[P_BAYER]<=3) imageParamsR[P_BAYER]=imageParamsW[P_BAYER];

   if (!nonstop) {
     if (imageParamsR[P_TRIG] & 0x4) {CCAM_TRIG_EXT ; program_early_timestamp(); }
     else                            CCAM_TRIG_INT ;
// process clocks here - normally just one during initializing
     if (imageParamsW[P_CLK_FPGA]) {

#if 0 // disable changing FPGA clock here - needs readjusting the phase
       if (setClockFreq(0, imageParamsW[P_CLK_FPGA])>=0) {
         imageParamsR[P_CLK_FPGA]=imageParamsW[P_CLK_FPGA];
// needs phase adjustment too ! *****************************************************************8         
         initSDRAM();
       }  
#endif
       imageParamsW[P_CLK_FPGA]=0; 
     }
// Changing frequency of the sensor confuses MT9P031 - it can get 0/1 pixel horizonatl shift, so sensor requires reset+reinitialization
// after frequency change
#if 0
     if (imageParamsW[P_CLK_SENSOR]) {
       if (setClockFreq(1, imageParamsW[P_CLK_SENSOR])>=0) imageParamsR[P_CLK_SENSOR]=imageParamsW[P_CLK_SENSOR];
       imageParamsW[P_CLK_SENSOR]=0;
       X3X3_RSTSENSDCM;
     }
#endif
//set bayer phase
     ccamCRAndOr(~X313_MASK(BAYER_PHASE), X313_BITS(BAYER_PHASE,imageParamsR[P_BAYER]));
// prepare compressor color mode 0 - mono, 1 - color, 2 - jp4/google
     if ((imageParamsW[P_COLOR] & 3)==2) { // jp4/google mode
       x313_JPEG_ctrl(x313_get_JPEG_ctrl() | JPEG_CTRL_MONOCHROME | JPEG_CTRL_NOMOSAIC);
       imageParamsR[P_COLOR] = 2;
     } else if ((imageParamsW[P_COLOR] & 3)==1) {
       x313_JPEG_ctrl(x313_get_JPEG_ctrl() & ~JPEG_CTRL_MONOCHROME & ~JPEG_CTRL_NOMOSAIC);
       imageParamsR[P_COLOR] = 1;
     } else {
       x313_JPEG_ctrl((x313_get_JPEG_ctrl()  & ~JPEG_CTRL_NOMOSAIC) | JPEG_CTRL_MONOCHROME);
       imageParamsR[P_COLOR] = 0;
     }
// Set number of frames to skip according to sensor requirements
     if (sensRslt>=0) { // no error
// adjust exposure to variable MCLK - obsolete? or still in 313?
       if ((imageParamsR[P_MCLK]!=4) && (imageParamsR[P_MCLK]!=0)) imageParamsR[P_EXPOS]= (imageParamsR[P_EXPOS]<<2)/imageParamsR[P_MCLK];
       if (imageParamsR[P_EXPOS]<1) imageParamsR[P_EXPOS]=1;
// program FPGA  mclk
       PROGRAM_CLK_EN( (imageParamsR[P_MCLK]>0)?1:0);
// Set timestamp mode 
MD8(printk ("set timestamp mode to %lx\r\n", ((imageParamsR[P_PF_HEIGHT] >>16) & 3)));
       port_csp0_addr[X313_WA_TIMESTAMP] = (imageParamsR[P_PF_HEIGHT] >>16) & 3;
       
// make approximation of the period (in clocks) if it was not set by sensor (should)
       if (imageParamsR[P_PERIOD]==0) imageParamsR[P_PERIOD]=(imageParamsR[P_ACTUAL_WIDTH]+20)*(imageParamsR[P_ACTUAL_HEIGHT]+1);
// ***** Put here new parameters programming ******
       port_csp0_addr[X313_WA_VIRTTRIG]= imageParamsR[P_VIRTTRIG];
       if (imageParamsW[P_COLOR] & 0x300) imageParamsR[P_COLOR] |= 0x200; // sensor does not have test mode
       if (imageParamsR[P_BGFRAME]) PROGRAM_FPN(0,0,0,0,0);
//       else  PROGRAM_FPNW(imageParamsR[P_FPN],(imageParamsR[P_BITS]!=8));
       else  PROGRAM_FPN(((imageParamsR[P_COLOR]& 0x200)>0), \
                         (imageParamsR[P_FPNS]),  \
                         (imageParamsR[P_FPNM]),     \
                         (imageParamsR[P_BITS]!=8), \
                          imageParamsR[P_SHIFTL]);
//programm channel1 (FPN). Will not enable if not needed (imageParamsR[P_FPN]==0)
       ntilex=((imageParamsR[P_ACTUAL_WIDTH]+sensor.margins+7)>>3);
       if ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0) {
          ntiley=imageParamsR[P_ACTUAL_HEIGHT]; // number of lines it the whole frame
// no FPN yet for pf mode       
       } else {
          ntiley=imageParamsR[P_ACTUAL_HEIGHT]+sensor.margins;
//   printk("ntilex=%x, ntiley= %x\r\n", ntilex,ntiley);
          if(!imageParamsR[P_BGFRAME] && ((imageParamsR[P_FPNS]!=0) || (imageParamsR[P_FPNM]!=0))) {
           X313_INIT_SDCHAN(1,0,0,0, X313_MAP_FPN, (ntilex-1), (ntiley-1)); // multiple lines - already {}
//       enable channel1 for reading SDRAM
           X313_CHN_EN(1);
// wait ready later...
         }
       }
//       goodEOL=0; // last 8/16 blocks of pixels in each scanline are bad (only 2 are actually written)
// if 8-bit mode we'll need to update ntilex. fpga tries to write 2 bytes more (but not crossing the page boundaries
       if ((imageParamsR[P_BITS]==8) && (!imageParamsR[P_BGFRAME])) {
           ntilex=((imageParamsR[P_ACTUAL_WIDTH]+sensor.margins+15)>>4);
//           if ((imageParamsR[P_PF_HEIGHT] & 0xf0000)>0) ntilex=((imageParamsR[P_ACTUAL_WIDTH]+X313_MARGINS+15+28)>>4);
//           else                                         ntilex=((imageParamsR[P_ACTUAL_WIDTH]+X313_MARGINS+15)>>4);

           goodEOL=((imageParamsR[P_ACTUAL_WIDTH] & 0x0f) == 0) && ((imageParamsR[P_ACTUAL_WIDTH] & 0x1f0) != 0);
           if (goodEOL) ntilex--;
       }    
       if (imageParamsR[P_OVERLAP]>=(imageParamsR[P_ACTUAL_HEIGHT]+2)) imageParamsR[P_OVERLAP]=imageParamsR[P_ACTUAL_HEIGHT]+1;
       if (imageParamsR[P_OVERLAP]>0) ntiley=(ntiley<<1);
// ntiley will be twice bigger for synch. mode)
       padlen=((ntilex+31)>>5) << 8;
       sa=X313_MAP_FRAME + ((padlen * (imageParamsR[P_ACTUAL_HEIGHT]+sensor.margins) * imageParamsR[P_PAGE_ACQ]) << ((get_imageParamsR(P_TRIG) & 1)?1:0));
MD8(printk ("-->> sa frame = 0x%08X, ntilex=0x%04X, ntiley=0x%04X\r\n", sa, ntilex, ntiley));
//printk("!!! -->> sa frame = 0x%08X\r\n", sa);
//   printk("ntilex=%x, ntiley= %x, padlen=%x, sa=%x\r\n", ntilex,ntiley,padlen,sa);
       X313_INIT_SDCHAN(0,0,1,1, \
             sa, \
             (ntilex-1),(ntiley-1)); // dependency - source
       X313_CHN_EN(0);
//programm number of lines to read
       if ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0) {
         i = (imageParamsR[P_ACTUAL_HEIGHT] & 0xfff) | ((imageParamsR[P_ACTUAL_HEIGHT]/(imageParamsR[P_PF_HEIGHT] & 0xffff))<<16) ;
       } else {
         i= (imageParamsR[P_ACTUAL_HEIGHT]+sensor.margins+imageParamsR[P_OVERLAP]);
       }
       port_csp0_addr[X313_WA_NLINES] = i;
MD8(printk ("port_csp0_addr[X313_WA_NLINES] =%d(0x%x)\r\n", i,i));
//prepare data for JPEG compressor (and program partially)
//static int jpeg_sdram_ctl0;
// old code commented out
// X313_INIT_SDCHAN(num,mode,wnr,dep,sa,ntilex,ntiley)

//    int ntilex_compressor,ntiley_compressor; // what is actually written to chn 2 memory
#if 0
       jpeg_sdram_ctl0=X313_PREINIT_SDCHAN(2,1,
             ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0)?1:0, // photo-finish mode
             0,  // no dependency here
             sa,
             ntilex - (goodEOL?1:2), 
             ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0)?(ntiley-0x10):(ntiley-sensor.margins-0x10) );
#endif
       ntilex_compressor=ntilex - (goodEOL?1:2);
       ntiley_compressor=((imageParamsR[P_PF_HEIGHT] & 0xffff)>0)?(ntiley-0x10):(ntiley-sensor.margins-0x10);
       jpeg_sdram_ctl0=X313_PREINIT_SDCHAN(2,1,
             ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0)?1:0, // photo-finish mode
             0,  // no dependency here
             sa,
             ntilex_compressor, 
             ntiley_compressor );
//TODO:add to Exif
       frame_params.width=(ntilex_compressor+1)<<4; //actual width how compressor sees it, in pixels
       frame_params.height=(ntiley_compressor &0xfff0)+0x10; //actual height how compressor sees it, in pixels

//       x313_program_focus(frame_params.width) ;//!NOTE: (new function)

MD8(printk ("programSensor ntilex=0x%x, ntiley=0x%x jpeg_sdram_ctl0=0x%x\r\n", ntilex, ntiley,jpeg_sdram_ctl0));
MD8(printk ("programSensor 2ctl1=0x%lx, 2ctl2=0x%lx\r\n", port_csp0_addr[X313_WA_SDCH2_CTL1], port_csp0_addr[X313_WA_SDCH2_CTL2]));
// set number of MCUs to acquire
       if (imageParamsR[P_OVERLAP]>0) ntiley=(ntiley>>1);
       if ((imageParamsR[P_PF_HEIGHT] & 0xffff)>0) {
         n= ((ntilex - (goodEOL?0:1)) & 0x3ff) * ((ntiley)>>4) -1;
       } else {
         n= ((ntilex - (goodEOL?0:1)) & 0x3ff) * ((ntiley-sensor.margins)>>4) -1;
       }
       port_csp0_addr[X313_WA_MCUNUM]= n;
       imageParamsR[P_TILES]=n+1;


MD8(printk ("port_csp0_addr[X313_WA_MCUNUM] =%d (0x%x)\r\n", n,n));
// printk("ntilex=0x%x, ntiley= 0x%x, MCUs=0x%x\r\n", ntilex,ntiley,n);
// printk("actual width=0x%x, actual height= 0x%x\r\n", imageParamsR[P_ACTUAL_WIDTH],imageParamsR[P_ACTUAL_HEIGHT]);
// wait FPN ready (if used)
    if ((imageParamsR[P_FPNS]!=0) ||(imageParamsR[P_FPNM]!=0)) {
//       if (imageParamsR[P_FPN]!=0)) { // +++++ Why?
         n=1000;
         while (((n--)>0) && !X313_SR(CH1RDY)); udelay (1);
       }
     } else { // error occured while programming sensor
       setCamSeqState(CAMSEQ_OFF);
    printk("Error programming sensor\n");
     } // if sensResult/else
    } // if (!nonstop) 


   if(sensRslt>= 0) {
      i = program_sensor_exposition_just();
      if((i < 0) || (i > sensRslt))
         sensRslt = i;
   } // now - always <= 0 ?




    x313_program_focus(frame_params.width) ;
//     start acquisition (granting internal/external) - not here
   } // changes/no changes

   imageParamsR[P_UPDATE]=1;  // in sync
   imageParamsW[P_UPDATE]=0;  // not needed
   imageParamsR[P_PARS_CHANGED]=0;

   if (!nonstop) {
     setCamSeqCount(((sensRslt>=0) && ((imageParamsW[P_PF_HEIGHT] & 0xffff)==0))?sensRslt:0);
     setCamSeqState((sensRslt>=0)?CAMSEQ_READY:CAMSEQ_OFF);
#if PROGRAM_SENSOR_DIS_IRQ
     local_irq_restore(flags); // remove completely?
#endif
   }  
   MD2(printk("programSensor:, sensRslt=%x,getCamSeqState()=%x\n", (int) sensRslt, (int) getCamSeqState()));
   up(&sensor_lock);
   MD10(dumpFrameParams(&frame_params,"\nframe parameters after ProgramSensor:"));
   MD11(printk ("rp=0x%x, wp=0x%x\r\n", JPEG_rp, JPEG_wp ));
   imageParamsR[P_PGMSENSRSLT]=sensRslt;
   imageParamsR[P_SKIP_FRAMES]=imageParamsW[P_SKIP_FRAMES];
   return sensRslt;
}
// autoexp unlock timing
void exposition_unlock(void) {
        set_imageParamsW(P_EXPOS, get_imageParamsR(P_EXPOS));
        set_imageParamsW(P_VEXPOS, 0);
}
// autoexoposure program sensor timing
int program_sensor_exposition(void) {
        int sensRslt = -1;
//printk ("*************************");
        struct hist_sensor_t *hist_s = NULL;
        unsigned long exp = 0x00;
        if(down_trylock(&sensor_lock) != 0)
                return -1;
        /* process can't sleep - all ok !!! */
        hist_s = hist_sensor_lock();
        if(hist_s != NULL) {
                set_imageParamsW(P_VEXPOS, hist_s->exposure);
                exp = hist_s->exposure;
                hist_sensor_unlock();
        } else {
                up(&sensor_lock);
                return -1;
        }

        sensRslt = program_sensor_exposition_just();

   up(&sensor_lock);
//printk("\n\nnew exp == %d\n\n", exp);
   return sensRslt;
}
// adjust fps limit to compressor capabilities.
// use P_FCLK (fpga clock, HZ)
//     P_COLOR (1 - color, 2,0 - mono) - later, currently not implemented in FPGA
//     P_TILES - number of tiles to process
//     P_FPGA_XTRA - extra cycles (fpga clocks) in frame





 void adjust_fps_2_compressor(void) {
//    int cycles= imageParamsR[P_TILES]*(((imageParamsR[P_COLOR] &3)==1)?762:512)+imageParamsR[P_FPGA_XTRA];
        int cycles = imageParamsR[P_TILES] * 768 + imageParamsR[P_FPGA_XTRA]; // 768 == FPGA clock time for the tile (YCbCr 4:2:0) 16x16 * 1.5
        int fp100s = imageParamsR[P_CLK_FPGA] / ((cycles/100) + 1);
// preserve limit mode, set limit if compressor is slower or upper limit mode is not set
// If only "maintain" (lower limit) flag is set exposure will be limited tothe frame time determined from slowest of the sensor and compressor
        if(((imageParamsR[P_FPSLM] & 1) == 0) || (imageParamsW[P_FP100S] > fp100s))
                imageParamsW[P_FP100S] = fp100s ;
    MD9(printk("\r\n+++++++++ fp100s=0x%08x imageParamsR[P_FPSLM]=0x%01X, imageParamsW[P_FPSLM]=0x%01X, imageParamsR[P_FP100S] = 0x%08X, imageParamsW[P_FP100S] = 0x%08X\r\n",fp100s, imageParamsR[P_FPSLM], imageParamsW[P_FPSLM], imageParamsR[P_FP100S],  imageParamsW[P_FP100S]));

 }
int program_sensor_exposition_just(void) {
        int res = -1;
        adjust_fps_2_compressor();
        switch(imageParamsR[P_SENSOR] & SENSOR_MASK) {
//#ifdef CONFIG_ETRAX_ELPHEL_KAI11000
        case SENSOR_KAI11000:
        res=1; 
        break; // senosor exposition
//#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32112
        case SENSOR_ZR32112: break;
#endif
#ifdef CONFIG_ETRAX_ELPHEL_ZR32212
        case SENSOR_ZR32212: break;
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
        case SENSOR_KAC1310: break; // FIXME
#endif
#ifdef CONFIG_ETRAX_ELPHEL_KAC1310
        case SENSOR_KAC5000: break; // FIXME
#endif
#ifdef CONFIG_ETRAX_ELPHEL_MT9X001
        case SENSOR_MT9X001: //0x30..0x33
        case SENSOR_MT9Y001: //0x34..0x37
                res = program_exposure_mt9x001();
                break;
#endif
#ifdef CONFIG_ETRAX_ELPHEL_IBIS51300
        case SENSOR_KAC5000: break; // FIXME
#endif
        } //switch
//TODO:add to Exif
//int putlong_meta(unsigned long data, int * indx,  unsigned long ltag); //write data to meta (4 bytes, big endian), from outside IRQ (atomic). Returns index of the written data, -1 if not written
//   write_meta_irq(exif_meta_time_string, &meta_offsets.Image_DateTime,  Exif_Image_DateTime, 20); // may use 27 if room is provided
//        frame_params.exposure=imageParamsR[P_EXPOS];
//        putlong_meta(imageParamsR[P_EXPOS], &meta_offsets.Photo_ExposureTime,  Exif_Photo_ExposureTime);
        return res;
}


/* ======================================== Top level file operations =================================================================== */

static int cmoscam_open(struct inode *inode, struct file *filp) {
        int p,res;


        p = MINOR(inode->i_rdev);
//  printk("cmoscam_open: minor=%x\r\n",p);
   MD(printk("cmoscam_open: minor=%x\r\n",p));
     D1(printk("cmoscam_open: minor=%x\r\n",p) );
     D1(printk("filp=%lx\r\n",(unsigned long)filp) );
//     if (init_FPGA()<0) return -EACCES;

        switch ( p ) {
        case  CMOSCAM_MINOR_HISTOGRAM :
         {
              if (minors[p]) {
               printk("***** Attemped to open twice CMOSCAM_MINOR_HISTOGRAM *****\n");
               return -EACCES;
           }
           break;
         }
        case  CMOSCAM_MINOR_RWTABLES :
         {
              if (minors[p]) {
               printk("***** Attemped to open twice CMOSCAM_MINOR_RWTABLES *****\n");
               return -EACCES;
           }
           break;
         }
        case  CMOSCAM_MINOR_GAMMA :
         {
              if (minors[p]) {
               printk("***** Attemped to open twice CMOSCAM_MINOR_GAMMA *****\n");
               return -EACCES;
           }
           gamma_tables_changed=0;
           break;
         }
#ifdef CONFIG_ETRAX_323         
        case  CMOSCAM_MINOR_SENSORJTAGFPGA :
         {
// for KAI11000 development - disable sensor init (that "open" should be before any attemts to find/init sensor)
           port_csp0_addr[X313_WA_SDCH0_CTL2]=0x8000; // sensor will be considered initialized
           ccamCROr( X313_BITS(KAI11000,1)); //just shadow, no real fpga reg yet
           if (minors[p])  {
              printk("***** Attemped to open CMOSCAM_MINOR_SENSORJTAGFPGA w/o closing\n");
           }
           if ((res =sfjtag_open())) return res;
           break;
         }  
#endif          
                case  CMOSCAM_MINOR_FRAME: {
                        if(init_FPGA() < 0)
                                return -EACCES;
                        if(minors[p]) {
                                printk("***** Attemped to open CMOSCAM_MINOR_FRAME w/o closing\n");
//                              return -EACCES; // maybe different number - channel in use
                        }
                        if((res = x313_frame_open(inode, filp)))
                                return res;
                        break;      
                }

        case  CMOSCAM_MINOR_LOCK :
         {
           if (minors[p]) {
               printk("***** Attemped to access locked camera *****\n");
               return -EACCES;  // maybe different number - channel in use
           }
           break;      
         }

        case  CMOSCAM_MINOR_UNLOCK :
         {
           minors[CMOSCAM_MINOR_LOCK]=0;
           break;      
         }


        case  CMOSCAM_MINOR_FPN :
         {
           if (minors[p]) {
               printk("***** Attemped to open CMOSCAM_MINOR_FPN w/o closing\n");
//               return -EACCES;        // maybe different number - channel in use

           }
           if ((res =x313_fpn_open(inode, filp))) return res;
          break;      
         }
        case CMOSCAM_MINOR_I2C :
          {
           if (minors[p])  return -EACCES;      // maybe different number - channel in use
           break;
          }
        case CMOSCAM_MINOR_DMA :
          {
// bypass  cmoscam_open_dma() to avoid calculating chain when compressor is still running in "run" mode
            if (((res=getCamSeqState())==CAMSEQ_RUN) || (res == CAMSEQ_STOP)) inode->i_size=0;
            else if ((res =cmoscam_open_dma(inode, filp))) return res;
            break;      
          }
        case CMOSCAM_MINOR_MCP :
          {
            if (init_FPGA()<0) return -EACCES;
            if (CCAM_DONOTUSEAUX) return -EACCES;
            if ((minors[p]) && ((ccam_cr_shadow & X313_MASK(XRST)) != 0))  return -EACCES;
            if ((res =MCP_open(inode, filp))) return res;
            break;      
          }
        case CMOSCAM_MINOR_CIRCBUF :
          {
 //           if ((res =x313_circbuf_open(inode, filp))) return res;
            break;
          }
        case CMOSCAM_MINOR_JPEAGHEAD :
          {
//            if ((res =x313_jpeghead_open(inode, filp))) return res;
            break;
          }
        case CMOSCAM_MINOR_SENSPARS : // for now - no checks, always possible to open
          {
            break;
          }

        default: return -EINVAL;
        }

        minors[p]=p;

        filp->private_data = &minors[p];



        return 0;
}
static int cmoscam_release(struct inode *inode, struct file *filp) {
 int p = MINOR(inode->i_rdev);
 int i=0;
   MD(printk("cmoscam_release: minor=%x\r\n",p));
        switch ( p ) {
#ifdef CONFIG_ETRAX_323
        case  CMOSCAM_MINOR_SENSORJTAGFPGA :
          {
            i=sfjtag_close();
            printk("sfjtag_close returned %x\r\n",i);
            if (i>0) i=0;
            minors[p]=0;
            break;
          }  
#endif
        case  CMOSCAM_MINOR_GAMMA :
          if (gamma_tables_changed) write_gamma_fpga (gamma_tables_soft);
          gamma_tables_changed=0;
          minors[p]=0;
          break;
        case  CMOSCAM_MINOR_FPN :
          x313_fpn_release();
        case  CMOSCAM_MINOR_HISTOGRAM :
        case  CMOSCAM_MINOR_RWTABLES :
        case CMOSCAM_MINOR_I2C :
        case CMOSCAM_MINOR_MCP :
        case CMOSCAM_MINOR_LOCK :
        case CMOSCAM_MINOR_UNLOCK :
//        case CMOSCAM_MINOR_CIRCBUF :      
         {
           minors[p]=0;
           break;
         }
        case CMOSCAM_MINOR_FRAME: {
                        x313_frame_release();
                        minors[p]=0;
                        break;
                }
        case CMOSCAM_MINOR_SENSPARS :
        case CMOSCAM_MINOR_DMA :
        case CMOSCAM_MINOR_CIRCBUF : 
        case CMOSCAM_MINOR_JPEAGHEAD :
         {
           break;
         }
        default: return -EINVAL;
        }

   D(printk("cmoscam_release:  done\r\n"));
   return i;
}



static int cmoscam_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { // switch by minor
        int rv;
//   MD(printk("cmoscam_ioctl cmd= %x, arg= %x\n\r",cmd,arg));
//   MD(printk("cmoscam_ioctl:  ((int *)filp->private_data)[0]= %x\n\r",((int *)filp->private_data)[0]));
//   MD(printk("cmoscam_ioctl:   (int)  filp->private_data= %x\n\r",(int)filp->private_data));

          switch (((int *)filp->private_data)[0]) {

          case CMOSCAM_MINOR_I2C : return i2c_ioctl (inode, filp, cmd, arg);
          case CMOSCAM_MINOR_DMA :  
            if (init_FPGA()<0) return -EACCES; // test if programmed, on first call will init
          case  CMOSCAM_MINOR_SENSPARS :
          case  CMOSCAM_MINOR_MCP :     // do the same (just to check status)
          case  CMOSCAM_MINOR_FPN :     // do the same
          case  CMOSCAM_MINOR_FRAME :   // do the same
          case  CMOSCAM_MINOR_CIRCBUF :  // do the same
          case  CMOSCAM_MINOR_JPEAGHEAD : { // do the same
                 rv= ccam_DMA_ioctl(inode, filp, cmd, arg);
                 return rv;     
                }
          default:return -EINVAL;
          }
}

static loff_t cmoscam_lseek(struct file * file, loff_t offset, int orig) {
     int i;
     switch (((int *)file->private_data)[0]) {
       case CMOSCAM_MINOR_GAMMA     : return  x313_gamma_lseek  (file, offset, orig);
       case CMOSCAM_MINOR_HISTOGRAM : return  x313_histogram_lseek  (file, offset, orig);
       case CMOSCAM_MINOR_RWTABLES :  return  x313_tables_lseek  (file, offset, orig);
       case CMOSCAM_MINOR_MCP :       return  MCP_lseek          (file, offset, orig);
       case CMOSCAM_MINOR_FPN :       return  x313_fpn_lseek     (file, offset, orig);
       case CMOSCAM_MINOR_FRAME :     return  x313_frame_lseek   (file, offset, orig);
       case CMOSCAM_MINOR_DMA :{
          if ( (((i=getCamSeqState()))== CAMSEQ_RUN   ) ||
               (i                     == CAMSEQ_STOP  ) ||
               (i                     == CAMSEQ_SINGLE)) return 0; // for waiting ready
          return  x313_dma_lseek     (file, offset, orig);
       }   
//       case CMOSCAM_MINOR_CIRCBUF :    return  x313_circbuf_lseek (file, offset, orig);
//       case CMOSCAM_MINOR_JPEAGHEAD :  return  x313_jpeghead_lseek (file, offset, orig);
       case CMOSCAM_MINOR_SENSPARS :   return  x313_senspars_lseek (file, offset, orig);
       default:                      return -EINVAL;
     }
}

static ssize_t cmoscam_read(struct file * file, char * buf, size_t count, loff_t *off) {
// printk("cmoscam_read: ((int *)file->private_data)[0]= %x\r\n",((int *)file->private_data)[0]);
    switch (((int *)file->private_data)[0]) {
       case CMOSCAM_MINOR_GAMMA     :    return  x313_gamma_read     (file, buf, count, off);
       case CMOSCAM_MINOR_HISTOGRAM:     return  x313_histogram_read (file, buf, count, off);
       case CMOSCAM_MINOR_RWTABLES :     return  x313_tables_read    (file, buf, count, off);
       case CMOSCAM_MINOR_MCP :          return  MCP_read            (file, buf, count, off);
       case CMOSCAM_MINOR_FPN :          return  x313_fpn_read       (file, buf, count, off);
       case CMOSCAM_MINOR_FRAME :        return  x313_frame_read     (file, buf, count, off);
       case CMOSCAM_MINOR_DMA :          return  x313_dma_read       (file, buf, count, off);
//       case CMOSCAM_MINOR_CIRCBUF :      return  x313_circbuf_read   (file, buf, count, off);
//       case CMOSCAM_MINOR_JPEAGHEAD :    return  x313_jpeghead_read  (file, buf, count, off);
       case CMOSCAM_MINOR_SENSPARS :     return  x313_senspars_read  (file, buf, count, off);
       default:                          return -EINVAL;
    }
}
static ssize_t cmoscam_write(struct file * file, const char * buf, size_t count, loff_t *off) {
// printk("cmoscam_write: ((int *)file->private_data)[0]= %x\r\n",((int *)file->private_data)[0]);
    switch (((int *)file->private_data)[0]) {
       case CMOSCAM_MINOR_GAMMA:          return  x313_gamma_write   (file, buf, count, off);
       case CMOSCAM_MINOR_RWTABLES:       return  x313_tables_write  (file, buf, count, off);
#ifdef CONFIG_ETRAX_323
       case CMOSCAM_MINOR_SENSORJTAGFPGA: return  sfjtag_write       (file, buf, count, off);
#endif
       case CMOSCAM_MINOR_MCP :           return  MCP_write          (file, buf, count, off);
       case CMOSCAM_MINOR_FPN :           return  x313_fpn_write     (file, buf, count, off);
       case CMOSCAM_MINOR_DMA :           return  x313_dma_write     (file, buf, count, off);
//       case CMOSCAM_MINOR_CIRCBUF :       return  x313_circbuf_write (file, buf, count, off);
       case CMOSCAM_MINOR_JPEAGHEAD :     return  x313_dma_write     (file, buf, count, off); // same as other - write header
       case CMOSCAM_MINOR_SENSPARS :      return  x313_senspars_write(file, buf, count, off);
       default:                           return -EINVAL;
    }

}


static int cmoscam_mmap (struct file *file, struct vm_area_struct *vma) {
    switch (((int *)file->private_data)[0]) {
       case  CMOSCAM_MINOR_SENSPARS :   return  x313_senspars_mmap   (file, vma);
       default:                         return -EINVAL;
    }
}
static unsigned int cmoscam_poll (struct file *file, poll_table *wait) {
    switch (((int *)file->private_data)[0]) {
       case  CMOSCAM_MINOR_DMA :
            
            break;
       case  CMOSCAM_MINOR_CIRCBUF :
            if(imageParamsR[P_CIRCBUFWP]==file->f_pos) poll_wait(file, &x313_wait_queue, wait);
            if(imageParamsR[P_CIRCBUFWP]==file->f_pos) return 0;
    }
    return POLLIN | POLLRDNORM;
}

//#define P_TRIG_CONDITION 102 // trigger condition, 0 - internal, else dibits ((use<<1) | level) for each GPIO[11:0] pin
//#define P_TRIG_DELAY     103 // trigger delay, 32 bits in pixel clocks
//#define P_TRIG_OUT       104 // trigger output to GPIO, dibits ((use << 1) | level_when_active). Bit 24 - test mode, when GPIO[11:10] are controlled by other internal signals
//#define P_TRIG_PERIOD    105 // output sync period (32 bits, in pixel clocks). 0- stop. 1..256 - single, >=256 repetitive with specified period.
//  #define X313_WA_CAMSYNCTRIG 0x78 // trigger condition, 0 - internal, else dibits ((use<<1) | level) for each GPIO[11:0] pin
//  #define X313_WA_CAMSYNCDLY  0x79 // trigger delay, 32 bits in pixel clocks
//  #define X313_WA_CAMSYNCOUT  0x7a // trigger output to GPIO, dibits ((use << 1) | level_when_active). Bit 24 - test mode, when GPIO[11:10] are controlled by other internal signals
//  #define X313_WA_CAMSYNCPER  0x7b // output sync period (32 bits, in pixel clocks). 0- stop. 1..256 - single, >=256 repetitive with specified period.

void  program_trigger(void) {
   port_csp0_addr[X313_WA_CAMSYNCTRIG]=(imageParamsR[P_TRIG_CONDITION]=imageParamsW[P_TRIG_CONDITION]);
   port_csp0_addr[X313_WA_CAMSYNCDLY] =(imageParamsR[P_TRIG_DELAY]=    imageParamsW[P_TRIG_DELAY]);
   port_csp0_addr[X313_WA_CAMSYNCOUT] =(imageParamsR[P_TRIG_OUT]=      imageParamsW[P_TRIG_OUT]);
   port_csp0_addr[X313_WA_CAMSYNCPER] =(imageParamsR[P_TRIG_PERIOD]=   imageParamsW[P_TRIG_PERIOD]);
}


void  program_i2c(void) {
   if ((imageParamsW[P_I2C_QPERIOD]<256) && (imageParamsW[P_I2C_QPERIOD]> 2)) imageParamsR[P_I2C_QPERIOD]=imageParamsW[P_I2C_QPERIOD];
   if ((imageParamsW[P_I2C_BYTES]<3) && (imageParamsW[P_I2C_BYTES]>=0))       imageParamsR[P_I2C_BYTES]=imageParamsW[P_I2C_BYTES];
   port_csp0_addr[X313_I2C_CMD]=X3X3_SET_I2C_BYTES(imageParamsR[P_I2C_BYTES]+1) | X3X3_SET_I2C_DLY(imageParamsR[P_I2C_QPERIOD]) ;
  MD20(printk ("program_i2c (0x%x)\n",X3X3_SET_I2C_BYTES(imageParamsR[P_I2C_BYTES]+1) | X3X3_SET_I2C_DLY(imageParamsR[P_I2C_QPERIOD])));
}

void  program_smart_irq(void) {
   imageParamsR[P_IRQ_SMART]=imageParamsW[P_IRQ_SMART];
   port_csp0_addr[X313_WA_SMART_IRQ]=(2 | ((imageParamsR[P_IRQ_SMART] & 1)?1:0)) | \
                                     (8 | ((imageParamsR[P_IRQ_SMART] & 2)?4:0));
}

void  program_early_timestamp(void) {
   imageParamsR[P_EARLY_TIMESTAMP]=imageParamsW[P_EARLY_TIMESTAMP]?1:0;
   if (imageParamsR[P_EARLY_TIMESTAMP]) CCAM_TIMESTAMP_EARLY ;
   else                                 CCAM_TIMESTAMP_NORMAL ;
}


int flush_par_cache(void) {
//P_MAX_PAR
  int sum, i;
  sum=0;
  for (i=0;i<=P_MAX_PAR; i+=8) sum+=ccam_dma_buf_ptr[i]+ccam_dma_buf_ptr[i+P_NUMBER]+ccam_dma_buf_ptr[i+(PAGE_SIZE>>2)]+ccam_dma_buf_ptr[i+P_NUMBER+(PAGE_SIZE>>2)];
  return sum;
}
loff_t x313_senspars_lseek(struct file * file, loff_t offset, int orig) {
  int l=(P_NUMBER<<3); //4 * P_NUMBER * 2 bytes

  switch (orig)
  {
   case SEEK_SET:
     file->f_pos = offset;
     break;
   case SEEK_CUR:
     file->f_pos += offset;
     break;
   case SEEK_END:
     if (offset <= 0) {
        file->f_pos = l + offset;
     } else switch (offset) { 
//imageParamsR[P_SENSOR]=0;
//cris_flush_cache()
       case LSEEK_RESET_SENSOR:
         X313_CHN0_SET_UNUSED;
         imageParamsR[P_SENSOR]=0;
         return 0; // not fall through to init sensor
       case LSEEK_INIT_SENSOR:
         if  (imageParamsR[P_SENSOR]) return 0; 
         init_FPGA();
         return 0;
       case LSEEK_CAMSEQSTATE:
         return (file->f_pos=camSeqState); 
       case LSEEK_GET_FPGA_TIME:
         X313_GET_FPGA_TIME( imageParamsR[P_SECONDS] , imageParamsR[P_MICROSECONDS] );
         return 0;
       case LSEEK_SET_FPGA_TIME:
         X313_SET_FPGA_TIME( imageParamsW[P_SECONDS] , imageParamsW[P_MICROSECONDS] );
         return 0;
       case  LSEEK_FLUSH_CACHE:            
         flush_par_cache();
         return 0;
       case  LSEEK_AUTOEXP_SET:
         set_autoexposure_parameters(); 
         return 0;
       case  LSEEK_AUTOEXP_GET:
         get_autoexposure_parameters(); 
         return 0;
       case  LSEEK_TRIGGER_PGM:
         program_trigger();
         return 0;
       case  LSEEK_I2C_PGM:
         program_i2c();
         return 0;
       case  LSEEK_IRQ_SMART_PGM:
         program_smart_irq();
         return 0;
       case  LSEEK_EARLY_TIMESTAMP_PGM:
         program_early_timestamp();
         return 0;
       default:
         return (x313_JPEG_cmd_wrapper(offset)<0)?-EINVAL:0;
     }
     break;
   default:
     return -EINVAL;
  }
  // truncate position
  if (file->f_pos < 0) {
    file->f_pos = 0;
    return(-EOVERFLOW);
  }
  if (file->f_pos > l) {
    file->f_pos = l;
  }
  return ( file->f_pos );
}

ssize_t x313_senspars_read(struct file * file, char * buf, size_t count, loff_t *off) {
  unsigned long p;
  int l=(P_NUMBER<<3); //4 * P_NUMBER * 2 bytes
  char *  imageParamsRb= (char *)   imageParamsR;
  p = file->f_pos;
  if( (p + count) > l) { // truncate count
    count = l - p;
  }
  if (count && (copy_to_user(buf, & imageParamsRb[p], count)))
          {printk("copy_to_user1 (0x%x) error\n",(int) count);return -EFAULT;}

  file->f_pos+=count;
  return count;
}
// both first and second half will write to imageParamsW (but not in a single call)
ssize_t x313_senspars_write(struct file * file, const char * buf, size_t count, loff_t *off) {
  unsigned long flags; 

  unsigned long p,p0;
  int l=(P_NUMBER<<2); //4 * P_NUMBER bytes
  char *  imageParamsWb= (char *)   imageParamsW;
  D(printk("x313_senspars_write, count= %x\n", (int) count));
  p = file->f_pos;
  if (p >= (l<<1))  p = (l<<1);
  p0=p;
  if (p0 >= l) p0-=l;
  if( (p0 + count) > l) { // truncate count
    count = l - p0;
  }
  D(printk("x313_senspars_write, p=%x, p0=%x, count= %x\n", (int) p, (int) p0, (int) count));

  if (count) {
    if (copy_from_user(&imageParamsWb[p0],buf, count)) return -EFAULT;
    file->f_pos+=count;
                if ((count==4) && (p0==(P_UPDATE<<2))) { 
      local_irq_save(flags);
      //local_irq_disable();
      if (imageParamsW[P_UPDATE]) imageParamsR[P_UPDATE]=2;     // waiting to be updated
      else imageParamsR[P_UPDATE]=0; // will not be updated
      local_irq_restore(flags);
      if (imageParamsW[P_UPDATE]==1) programSensor(0); 
      else if (imageParamsW[P_UPDATE]>=3) programSensor(1); 
    }
  }
  return count;
}

int x313_senspars_mmap (struct file *file, struct vm_area_struct *vma) {
     int rslt;
   /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
     rslt=remap_pfn_range(vma,
             vma->vm_start,
//             ((unsigned long)(&imageParamsR[0])) >> PAGE_SHIFT,
             ((unsigned long) virt_to_phys(imageParamsR)) >> PAGE_SHIFT,
             vma->vm_end-vma->vm_start,
             vma->vm_page_prot);

     MD6(printk("remap_pfn_range returned=%x\r\n",rslt));
     if (rslt) return -EAGAIN;
//   vma->vm_ops = &simple_remap_vm_ops;
//   simple_vma_open(vma);
     return 0;
}

static int x313_JPEG_cmd_wrapper(int arg) {
               switch (arg) {
MD6(printk("IO_CCAM_JPEG cmd=0x%x arg=0x%x\r\n", cmd,arg)); //never got here???
             case PROGRAM_SENSOR_0: imageParamsR[P_PARS_CHANGED]=1; programSensor(0); return 0;
             case PROGRAM_SENSOR_1: imageParamsR[P_PARS_CHANGED]=1; programSensor(1); return 0;
             case JPEG_CMD_N_DONE: return (JPEG_nfr >0)?0:1;
             case JPEG_CMD_L_DONE: return (JPEG_len < JPEG_lfr )?0:1;
             case JPEG_CMD_DUMP: camSeq_dump (); // and fall to default
             default: {return x313_JPEG_cmd(arg);}
          }
}

static int ccam_DMA_ioctl(struct inode *inode, struct file *file,unsigned int cmd, unsigned long arg) {
//      struct timeval tv;
//  unsigned char i2cdata[2];
  unsigned long flags;
          int i1,r;

//MD(printk("_IOC_NR(cmd)=%lx\n", _IOC_NR(cmd)));
//MD1(printk("_IOC_NR(cmd)=%lx, arg=%lx\n", _IOC_NR(cmd),arg));
      switch(_IOC_NR(cmd)){
      case IO_CCAM_DMA : switch (arg) {
               case CCAM_DMA_CMD_STOP:  {x313_dma_stop(); return 0;}
               case CCAM_DMA_CMD_START: {x313_dma_start();return 0;}
               default:return -EINVAL ;
          }
      case IO_CCAM_JPEG_QUALITY: {
            if (arg <1)   arg=1;
            if (arg >100) arg=100;
            imageParamsR[P_QUALITY]=arg;
            imageParamsW[P_QUALITY]=arg;
            return 0;
      }
      case IO_CCAM_JPEG_GET_N: {
            if (getCamSeqState() != CAMSEQ_JPEG) x313_dma_update_jpeg_header(); // needed only first time
            return camSeqStartClip(arg, -1); // any length, 1 frame
      }
      case IO_CCAM_JPEG_GET_L: {
            if (getCamSeqState() != CAMSEQ_JPEG) x313_dma_update_jpeg_header(); // needed only first time
            return camSeqStartClip(-1, arg); // any numer, this length
      }
          case IO_CCAM_JPEG:  return x313_JPEG_cmd_wrapper(arg);
#if 0
  switch (arg) {
MD6(printk("IO_CCAM_JPEG cmd=0x%x arg=0x%x\r\n", cmd,arg)); //never got here???
             case JPEG_CMD_N_DONE: return (JPEG_nfr >0)?0:1;
             case JPEG_CMD_L_DONE: return (JPEG_len < JPEG_lfr )?0:1;
             case JPEG_CMD_DUMP: camSeq_dump (); // and fall to default
             default: {return x313_JPEG_cmd(arg);}
          }
#endif
          case IO_CCAM_JPEG_CTRL: { x313_JPEG_ctrl(arg); return 0;}

          case IO_CCAM_MONITOR_SEQ : {
MD( printk("IO_CCAM_MONITOR_SEQ, arg=%x,getCamSeqCount()=%x, getCamSeqState()=%x\r\n",(int) arg, (int) getCamSeqCount(),(int) getCamSeqState()));
            if (arg) return  getCamSeqCount();
// update image read page
            if (((r=getCamSeqState())==CAMSEQ_DONE) && (imageParamsR[P_PAGE_ACQ]!= imageParamsR[P_PAGE_READ])) {
              x313_f_invalidate();  // SDRAM line in buffer is not valid anymore
MD1(printk ("imageParamsR[P_PAGE_READ]=0x%lx, imageParamsR[P_PAGE_ACQ]=0x%lx\n",imageParamsR[P_PAGE_READ],imageParamsR[P_PAGE_ACQ]));
              imageParamsR[P_PAGE_READ] = imageParamsR[P_PAGE_ACQ];
            }
            return r;
         }
          case IO_CCAM_SET_EXT_EXPOSURE : {
    MD1(printk("+OBSOLETE?+IO_CCAM_SET_EXT_EXPOSURE, arg=%x\r\n",(int) arg));
         if (arg) camSeqStart(); 
         else {camSeqStop();
         }
             return 0;
           }
          case IO_CCAM_CR_MODIFY : {
      local_irq_save(flags);
      //local_irq_disable();
                i1=((ccam_cr_shadow & (1<<(arg>>2)))!=0);
                switch (arg & 3) {
                  case 1: {ccam_cr_shadow &= ~(1<<(arg>>2));break;}
                  case 2: {ccam_cr_shadow |=  (1<<(arg>>2));break;}
                  case 3: {ccam_cr_shadow ^=  (1<<(arg>>2));break;}
                }
                port_csp0_addr[X313_WA_WCTL]= ccam_cr_shadow;
                local_irq_restore(flags);
MD(printk("ccam_cr_shadow=0x%x\n",ccam_cr_shadow));
                return i1;
           }
          case IO_CCAM_PINS_WRITE : {
//              i1 = arg & 0x3FFF;
                i1 = arg;
      local_irq_save(flags);
      //local_irq_disable();
                port_csp0_addr[X313_WA_IOPINS] = i1;
                local_irq_restore(flags);
MD(printk("write_iopins=0x%x\n", i1));
                return i1;
           }
          case IO_CCAM_PINS_READ : {
      local_irq_save(flags);
      //local_irq_disable();
//              i1=port_csp0_addr[X313__RA__IOPINS] & 0x3F;
//              i1=port_csp0_addr[X313__RA__IOPINS];
      i1=X313_IOPINS; 
                local_irq_restore(flags);
MD(printk("read_iopins=0x%x\n", i1));
                return i1;
           }
        }
MD(printk("CCAM_CTRL(cmd)=%lx\n", CCAM_CTRL(cmd)));

        switch(CCAM_CTRL(cmd)){
// read (abstract) sensor parameters 0..63
    case CCAM_RPARS:{

 MD(printk("CCAM_RPARS: imageParamsR[%lx]=%lx\n",CCAM_ADDR(cmd),imageParamsR[CCAM_ADDR(cmd)]));

          return  imageParamsR[CCAM_ADDR(cmd)];
        }

//  write (abstract) sensor parameters 0..63  (if [P_UPDATE] is off)
//      trigger update if necessary
    case CCAM_WPARS: {
     if (CCAM_ADDR(cmd) == P_UPDATE) {
// MD(printk("CCAM_ADDR(cmd) == P_UPDATE\n"));
//do_gettimeofday(&tv);
//printk("CCAM_ADDR(cmd) == P_UPDATE; %d:%d\r\n", tv.tv_sec, tv.tv_usec);
       if (imageParamsR[P_UPDATE] == 3)  return -EINVAL ; // too late to abort... TODO: support waiting, change error code
       local_irq_save(flags);
       //local_irq_disable();
//       imageParamsW[P_UPDATE]= (arg>2)? 2: arg;
       imageParamsW[P_UPDATE]= arg; // now 3 - update "on the fly" - only some parameters
       if (imageParamsW[P_UPDATE]) imageParamsR[P_UPDATE]=2;    // waiting to be updated
       else imageParamsR[P_UPDATE]=0; // will not be updated
       local_irq_restore(flags);
       if (imageParamsW[P_UPDATE]==1) return programSensor(0); 
       if (imageParamsW[P_UPDATE]>=3) return programSensor(1); 
// add an option with "nonstop" (1)      
       return 0;
     } else { //P_UPDATE / normal write
       if (imageParamsR[P_UPDATE]>1) {
 MD(printk("*****No write permitted if update is schedulled\n"));
             return -EINVAL ; // no write permitted if update is schedulled. TODO: Change error code
       }
       imageParamsR[P_PARS_CHANGED] |=  (imageParamsW[CCAM_ADDR(cmd)]!=arg);
       imageParamsW[CCAM_ADDR(cmd)]=arg;
 MD(printk("writing: imageParamsW[%lx]=%lx\n",CCAM_ADDR(cmd),arg));
       return 0;
     }
   } //CCAM_WPARS

    default:return -EINVAL ;
  }


}

// file r/w operations for the FPGA tables - move to a separate file later

// use static buffer, so will not work with simultaneous accesses (naturally fpga also has just one set of tables)
 
//#define CX313_FPGA_TABLES_SIZE 0x800 //=2000 bytes, 32-bit wide, LSB first, some tables use less
//#define CX313_FPGA_TABLES_GAMMA 0x400 //0x400 words gamma-correction (or arbitrary table)

unsigned long fpga_tables_buffer[CX313_FPGA_TABLES_SIZE];
// now tables will store 257 corner points (currently - 10 bits). FPGA specifics will be calculated by the driver
// and written to fpga when closing the file. The shadow array will be available for reading too.
//unsigned short gamma_tables_soft[1028];
//int gamma_tables_changed;
// called from driver space or when closing (if it was written)
int write_gamma_fpga (unsigned short gamma_table[1028]) {
  int i,n,base,diff,d;
printk("\nwrite_gamma_fpga()\n");

  port_csp0_addr[X313_WA_COMP_TA]=CX313_FPGA_TABLES_GAMMA;
  for (n=0;n<4;n++) {
    for (i=0;i<256;i++) {
     base=gamma_table[257*n+i];
     diff=gamma_table[257*n+i+1];
     diff-=base;
     if ((diff>63) || (diff < -64)) {
       diff=(diff+8)>>4;
       d=(base & 0x3ff) | ((diff & 0x7f) << 10) | (1 << 17);
     } else {
       d=(base & 0x3ff) | ((diff & 0x7f) << 10);
     }
     port_csp0_addr[X313_WA_COMP_TD]=d;  // 18-bit data, will autoincrement address
    }
  }
  port_csp0_addr[X313_WA_COMP_TA] = CX313_FPGA_TABLES_GAMMA; // there is a one write pipeline, any write to fpga to actually do the last write to 

  gamma_tables_changed=0;
  return 0;
}

void x313_tables_gammainitlinear(void) {
  int i,j;
  for (j=0; j<4; j++) {
    for (i = 0; i <= 256; i+=1) {
      gamma_tables_soft[257*j+i]=4*i;
    }  
    gamma_tables_soft[257*j+256]=1023;
  }  
  gamma_tables_changed=1;
  write_gamma_fpga(gamma_tables_soft);

}

loff_t  x313_gamma_lseek(struct file * file, loff_t offset, int orig){
 //  orig 0: position from begning of eeprom
 //  orig 1: relative from current position
 //  orig 2: position from last eeprom address
// printk("x313_gamma_lseek\n");

  int l;
  l=(1028<<1);

  switch (orig)
  {
   case 0:
     file->f_pos = offset;
     break;
   case 1:
     file->f_pos += offset;
     break;
   case 2:
     file->f_pos = l + offset;
     break;
   default:
     return -EINVAL;
  }
  // truncate position
  if (file->f_pos < 0) {
    file->f_pos = 0;
    return(-EOVERFLOW);
  }
  if (file->f_pos > l) {
    file->f_pos = l;
  }
  return ( file->f_pos );
}

//unsigned short gamma_tables_soft[1028];
//int gamma_tables_changed;
// will read just from shadow buffer
ssize_t x313_gamma_read(struct file * file, char * buf, size_t count, loff_t *off) {
  unsigned long p;
  char *  gamma_tables_char= (char *)   gamma_tables_soft;
  D(printk("x313_gamma_read\n"));
  p = file->f_pos;
  
  if( (p + count) > (1028 << 1)) { // truncate count
    count = (1028 << 1) - p;
  }
  if (count && (copy_to_user(buf, &gamma_tables_char[p], count)))
          {printk("copy_to_user1 (0x%x) error\n",(int) count);return -EFAULT;}

  file->f_pos+=count;
  return count;
}

ssize_t x313_gamma_write(struct file * file, const char * buf, size_t count, loff_t *off) {
  unsigned long p;
  char *  gamma_tables_char= (char *)   gamma_tables_soft;
  D(printk("x313_gamma_write, count= %x\n", (int) count));
  p = file->f_pos;
  if (p >= (1028 << 1))  p = (1028 << 1);
  if( (p + count) > (1028 << 1)) { // truncate count
    count = (1028 << 1) - p;
  }
  D(printk("x313_gamma_write, p=%x, count= %x\n", (int) p,(int) count));

  if (count) {

    if (copy_from_user(&gamma_tables_char[p],buf, count)) return -EFAULT;
    file->f_pos+=count;
    gamma_tables_changed=1;
  }
  return count;
}

loff_t  x313_tables_lseek(struct file * file, loff_t offset, int orig){
 //  orig 0: position from begning of eeprom
 //  orig 1: relative from current position
 //  orig 2: position from last eeprom address
// make it always stop DMA (needed?)

  int l;
  l=(CX313_FPGA_TABLES_SIZE<<2);

  switch (orig)
  {
   case 0:
     file->f_pos = offset;
     break;
   case 1:
     file->f_pos += offset;
     break;
   case 2:
     file->f_pos = l + offset;
     break;
   default:
     return -EINVAL;
  }

  // truncate position
  if (file->f_pos < 0) {
    file->f_pos = 0;
    return(-EOVERFLOW);
  }


  if (file->f_pos > l) {
    file->f_pos = l;
  }
  return ( file->f_pos );
}


ssize_t x313_tables_write(struct file * file, const char * buf, size_t count, loff_t *off) {
  unsigned long flags;
  unsigned long p;
  char * fpga_tables_char= (char *)  fpga_tables_buffer;
  int sa,l,i;
  D(printk("x313_tables_write, count= %x\n", (int) count));
  p = file->f_pos;
  if (p >= (CX313_FPGA_TABLES_SIZE<<2))  p = (CX313_FPGA_TABLES_SIZE<<2);
  if( (p + count) > (CX313_FPGA_TABLES_SIZE<<2)) { // truncate count
    count = (CX313_FPGA_TABLES_SIZE<<2) - p;
  }
  D(printk("x313_tables_write, p=%x, count= %x\n", (int) p,(int) count));

  if (count) {

    if (copy_from_user(&fpga_tables_char[p],buf, count)) return -EFAULT;
    file->f_pos+=count;
    sa= p>>2;
    l=count>>2;
    local_irq_save(flags);
    //local_irq_disable();
    port_csp0_addr[X313_WA_COMP_TA]=sa; // open fpga for writing table(s)
    for (i = 0; i < l; i++) {
        port_csp0_addr[X313_WA_COMP_TD]=fpga_tables_buffer[sa++];       // will autoincrement address
    }    
    port_csp0_addr[X313_WA_COMP_TA]=sa; // there is a one write pipeline, any write to fpga to actually do the last write to table
    local_irq_restore(flags);
  }
  return count;
}




ssize_t x313_tables_read(struct file * file, char * buf, size_t count, loff_t *off) {
  unsigned long sa,p;
//  unsigned long l,i;
  char * fpga_tables_char= (char *)  fpga_tables_buffer;

  D(printk("x313_tables_read\n"));
  p = file->f_pos;
  sa=p>>2;
  
  if( (p + count) > (CX313_FPGA_TABLES_SIZE<<2)) { // truncate count
    count = (CX313_FPGA_TABLES_SIZE<<2) - p;
  }
  if (count && (copy_to_user(buf, &fpga_tables_char[p], count)))
          {printk("copy_to_user1 (0x%x) error\n",(int) count);return -EFAULT;}

  file->f_pos+=count;
  return count;
}

//---------------------------------------------------------
#define CX313_FPGA_HISTOGRAM_SIZE 0x400 //=0x1000 bytes, 32-bit wide, LSB first

loff_t  x313_histogram_lseek(struct file * file, loff_t offset, int orig){
 //  orig 0: position from begning of eeprom
 //  orig 1: relative from current position
 //  orig 2: position from last eeprom address
// make it always stop DMA (needed?)
// printk("x313_histogram_lseek\n");

  int l;
  l=(CX313_FPGA_HISTOGRAM_SIZE<<2);

  switch (orig)
  {
   case 0:
     file->f_pos = offset;
     break;
   case 1:
     file->f_pos += offset;
     break;
   case 2:
     file->f_pos = l + offset;
     break;
   default:
     return -EINVAL;
  }

  // truncate position
  if (file->f_pos < 0) {
    file->f_pos = 0;
    return(-EOVERFLOW);
  }


  if (file->f_pos > l) {
    file->f_pos = l;
  }
  return ( file->f_pos );
}

//  #define   X313_WA_HIST_POS  0x40
//  #define   X313_WA_HIST_SIZE 0x41
//  #define   X313_WA_HIST_ADDR 0x42
//  #define   X313_RA_HIST_DATA 0x43  // use CSP4 with wait cycles to have a pulse


ssize_t x313_histogram_read(struct file * file, char * buf, size_t count, loff_t *off) {
  unsigned long sa,p,l,i;
  int    histogram_buffer[1024];
  char *  histogram_buffer_char= (char *)   histogram_buffer;

  D(printk("x313_histogram_read\n"));
//  printk("x313_histogram_read\n");
  p = file->f_pos;
  sa=p>>2;
  
  if( (p + count) > (CX313_FPGA_HISTOGRAM_SIZE<<2)) { // truncate count
    count = (CX313_FPGA_HISTOGRAM_SIZE<<2) - p;
  }
  l=((p+count-1)>>2)-sa+1; // number of 32-bit s to read
  port_csp0_addr[X313_WA_COMP_TA]=sa;  
  for (i=0;i<l;i++) {
    port_csp0_addr[X313_WA_HIST_ADDR]=sa;
    X3X3_AFTERWRITE ; 
    fpga_tables_buffer[sa++]=port_csp4_addr[X313_RA_HIST_DATA];
  }
  
  if (count && (copy_to_user(buf, &histogram_buffer_char[p], count)))
          {printk("copy_to_user1 (0x%x) error\n",(int) count);return -EFAULT;}

  file->f_pos+=count;
  return count;
}



void init_autoexp_struct(void) {
  autoexp_state = (struct autoexp_t *)      &imageParamsR[P_AUTOEXP];
  autoexp_set=    (struct autoexp_t *)      &imageParamsW[P_AUTOEXP];
  aexp_window=    (struct aexp_window_t * ) &imageParamsR[P_AEXPWND];
  aexp_window_set=(struct aexp_window_t * ) &imageParamsW[P_AEXPWND];
}

//---------------------------------------------------------

/* this makes sure that cmoscam_init is called during boot */

module_init(cmoscam_init);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andrey Filippov <andrey@elphel.com>.");
MODULE_DESCRIPTION(MY_MODULE_DESCRIPTION);
MODULE_DESCRIPTION("Elphel  Model 353 camera driver");
/****************** END OF FILE cc353.c ********************************/

---