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

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : cxdma353.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: cxdma353.c,v $
*!  Revision 1.8  2008/04/20 06:49:40  elphel
*!  cleanup, bug fixes
*!
*!  Revision 1.7  2008/04/16 20:33:23  elphel
*!  driver cleanup, removed some duplicate actions, working on better recovery after parameter modification
*!
*!  Revision 1.6  2008/02/08 16:36:03  spectr_rain
*!  access to quantization tables from the streamer
*!
*!  Revision 1.5  2007/12/09 05:59:13  elphel
*!  added cache_flush fix
*!
*!  Revision 1.4  2007/12/03 08:28:46  elphel
*!  Multiple changes, mostly cleanup
*!
*!  Revision 1.3  2007/11/04 05:39:11  elphel
*!  removed declaration of unused variable
*!
*!  Revision 1.2  2007/10/11 06:40:33  elphel
*!  Added second RESET command with non-zero value to be compatible with lseek (,,SEEK_END)
*!
*!  Revision 1.1.1.1  2007/10/02 19:36:10  elphel
*!  This is a fresh tree based on elphel353-2.10
*!
*!  Revision 1.17  2007/10/02 19:36:10  elphel
*!  removed unneeded debug output
*!
*!  Revision 1.16  2007/09/30 07:07:27  elphel
*!  only disabled debug output
*!
*!  Revision 1.15  2007/09/30 03:19:56  elphel
*!  Cleanup, fixed broken acquisition of individual JPEG images into circbuf (in mode 7)
*!
*!  Revision 1.14  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.13  2007/09/23 06:45:10  elphel
*!  Restored ccam_dma.raw character device file - it was broken when EXIF headers were added, so I just returned it to the previous state (no Exif, but works)
*!
*!  Revision 1.12  2007/09/05 10:32:40  spectr_rain
*!  reformatting and debug messages
*!
*!  Revision 1.11  2007/08/31 21:47:01  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.10  2007/08/28 21:25:28  spectr_rain
*!  mmap for JPEG files
*!
*!  Revision 1.9  2007/08/17 10:23:18  spectr_rain
*!  switch to GPL3 license
*!
*!  Revision 1.8  2007/08/01 18:56:33  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.7  2007/08/01 15:12:45  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.6  2007/07/20 10:17:44  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.2  2007/03/29 23:38:15  spectr_rain
*!  fix mmap
*!
*!  Revision 1.1.1.1  2007/02/23 10:11:48  elphel
*!  initial import into CVS
*!
*!  Revision 1.5  2007/01/08 17:22:39  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.4  2006/12/28 15:12:15  spectr_rain
*!  *** empty log message ***
*!
*!  Revision 1.3  2006/08/29 18:06:58  spectr_rain
*!  6.5.2
*!
*!  Revision 1.1.1.1  2006/07/11 19:15:00  spectr_rain
*!  unwork with less than 5MPx Micron sensor, initial branch
*!
*!  Revision 1.4  2006/04/16 00:18:09  elphel
*!  added timestamps to frame data in circbuf (streamers are not yet updated)
*!
*!  Revision 1.3  2006/02/22 09:06:46  elphel
*!  Made ccam.cgi return last image from the buffer when streamer is running. Same as acquiring image, with "-" in the options, i.e. "admin-bin/ccam.cgi?opt=vhcxy-" (all parameters will be ignored)
*!
*!  Revision 1.2  2005/05/10 21:08:49  elphel
*!  *** empty log message ***
*!
*/

/****************** INCLUDE FILES SECTION ***********************************/


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

#include <asm/system.h>
#include <asm/arch/memmap.h>
#include <asm/io.h>

#include <asm/arch/dma.h>
#include <asm/arch/hwregs/dma_defs.h>
#include <asm/arch/hwregs/dma.h>
#include <asm/arch/hwregs/reg_map.h>
#include <asm/arch/hwregs/bif_dma_defs.h>


#include <asm/irq.h>
#include <asm/atomic.h>

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

#include <asm/elphel/c313a.h>

#include "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr 

#include "x3x3.h"
#include "cc3x3.h"
#include "cxdma.h"
#include "circbuf.h"
#include "exif.h"

#if ELPHEL_DEBUG
 #define MD1(x) printk("%s:%d:",__FILE__,__LINE__);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)
#else
  #define MD1(x)
  #define MD12(x)
  #define MD13(x)
#endif



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

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

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

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


//#define PRINTQTAB y


#ifdef CONFIG_ETRAX_ELPHEL353
  #define EXT_DMA_0_START \
   do { reg_bif_dma_rw_ch3_start c = {.run=1};\
        REG_WR(bif_dma, regi_bif_dma, rw_ch3_start, (reg_bif_dma_rw_ch3_start) c); } while( 0 )
  #define EXT_DMA_0_STOP \
   do { reg_bif_dma_rw_ch3_start c = {.run=0};\
        REG_WR(bif_dma, regi_bif_dma, rw_ch3_start, (reg_bif_dma_rw_ch3_start) c); } while( 0 )
#else
  #define EXT_DMA_0_START \
   *R_EXT_DMA_0_CMD = (extdma0_cmd_shadow |=    IO_STATE( R_EXT_DMA_0_CMD, run, start ) )
  #define EXT_DMA_0_STOP \
   *R_EXT_DMA_0_CMD = (extdma0_cmd_shadow &=    ~IO_MASK( R_EXT_DMA_0_CMD, run ) )
#endif
/*
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)
len <0, nfr =0 - start constant compressing to buffer (only write pointer is updated
len =0, nfr <0 - stop constant compressing to buffer (wait for CAMSEQ_DONE)

int camSeqStartClip(int nfr, int len);
int  camSeqGetJPEG_wp(void);
int  camSeqGetJPEG_rp(void);
void camSeqSetJPEG_rp(int p);
*/




//#define JPEG_STARTED  (*R_DMA_CH5_CMD)
//#define JPEG_FINISHED ((port_csp0_addr[X313__RA__STATUS] & 0xc0000) == 0xc0000)
//#define JPEG_BUSY     (JPEG_STARTED && !(JPEG_FINISHED))

//#define UPDATE_JPEG if ((JPEG_STARTED) && (JPEG_FINISHED)) {printk ("status=%x, JPEG_FINISHED=%x\n",(int) port_csp0_addr[X313__RA__STATUS],JPEG_FINISHED);x313_dma_stop(); }
//#define UPDATE_JPEG if ((JPEG_STARTED) && (JPEG_FINISHED)) {x313_dma_stop(); }

//#define JPEG_HEADER_SIZE    0x26f
#define TRAILER_SIZE        0x02
#define HEADER_YQTABLE      0x19
#define HEADER_CQTABLE      0x5e

#define HEADER_HEIGHT       0xa3
#define HEADER_WIDTH        0xa5

/* really huge static DMA buffer (1288+8)*1032/3=445824 long-s */
// DMA_SIZE - in 32-bit words, not bytes
extern struct frame_params_t frame_params; // cc353.c


// it seems we could use a single data descriptor (in LX data segment was limited to 16KB), but let's have minimal changes
#ifdef CONFIG_ETRAX_ELPHEL353
  #define DMA_CHUNK 0x4000 // 32-bit words - may increase??
//  #define CCAM_DESCR_DATA_NUM (( CCAM_DMA_SIZE >> 14)+1) // number of data descriptors
  #define CCAM_DESCR_DATA_NUM (( CCAM_DMA_SIZE  / DMA_CHUNK) +1 ) // number of data descriptors
  static dma_descr_data    ccam_dma_descr_data    [CCAM_DESCR_DATA_NUM]  __attribute__ ((__aligned__(16)));
  static dma_descr_context ccam_dma_descr_context __attribute__ ((__aligned__(32)));

#else
  #define DMA_CHUNK 0x4000 // 32-bit words
//  #define CCAM_DESCR_DATA_NUM (( CCAM_DMA_SIZE >> 14)+1) // number of data descriptors
  #define CCAM_DESCR_DATA_NUM (( CCAM_DMA_SIZE  / DMA_CHUNK) +1 ) // number of data descriptors
  static etrax_dma_descr ccam_dma_descr_data[CCAM_DESCR_DATA_NUM];
  static unsigned long extdma0_cmd_shadow=0;

#endif
static unsigned char jpeg_header_sbuffer [JPEG_HEADER_SIZE];
unsigned char *jpeg_header_sbuffer_ptr = NULL; // will be initialized to during DMA init &jpeg_header_sbuffer[0];
static unsigned char trailer[TRAILER_SIZE] = {0xff,0xd9};
static unsigned long DMABufferLength;

//unsigned long *ccam_dma = &ccam_dma_buf_ptr[0];
unsigned long ccam_dma_length = CCAM_DMA_SIZE << 2;
//extern volatile atomic_t dma_update_mess_dis;
//volatile atomic_t dma_update_mess_dis;
//static        
static   int             use_header=1;
static   int             JPEG_ctrl= 0x2ff;

int             jpeg_quality= -1;

int             FPGA_quality=-1;
int             JPEG_header_quality=-1;




int      soft_rp;       // lower by 2 than the actual JPEG data - room for signature and length copy
static   int     save_rp=-1;   // rp saved for two-pass clip processing
static   int     save_wp=-1;    // to verify there was no acquisition after rp was saved



void           x313_dma_reset_jpeg(void);
int                 x313_dma_forget_jpeg(void);



int  x313_dma_catchup_jpeg(void);
//void           jpeg_set_quality (int quality, int writeFPGA);
void           update_JPEG_quality (int quality);
int            x313_setDMABuffer(void);
unsigned long  x313_DMA_size (void);
//int            x313_dma_start_jpeg(int now);
void           x313_dma_update_jpeg_header(void); // uses channel 0 SDRAM FPGA settings - channel 0 should be programmed earlier

void           x313_JPEG_dump (void);
int            X313_dma_update(int latest); // new - latest <0 - build the longest chain
void             x313_dma_reset_chain(void);
int              x313_dma_save_jpeg(void);
int              x313_dma_restore_jpeg(void);


/*
#define IO_CCAM_JPEG            0x0b // JPEG-compressor related commands
#define      JPEG_CMD_RESET     0x00 // Resets pointers - both acquisition and readout
#define      JPEG_CMD_ARM       0x01 // Prepare compressor to read next frame acquired
#define      JPEG_CMD_GET       0x02 // Read current page (will return empty (and length==0) if not ready
#define      JPEG_CMD_FORGET    0x03 // increment read frame pointer
#define      JPEG_CMD_CATCHUP   0x04 // set read pointer to the last acquisition one
#define      JPEG_CMD_ACQUIRE   0x05 // set read pointer to the last acquisition one
JPEG_CMD_DUMP
            if (getCamSeqState() != CAMSEQ_JPEG) 313_dma_update_jpeg_header(); // needed only first time
            return camSeqStartClip(arg, -1); // any length, 1 frame

*/
int x313_JPEG_ctrl(int cmd) {
        JPEG_ctrl= cmd & 0xffff;
        use_header = ((cmd & 0x10000) == 0);
        return 0;
}

int x313_get_JPEG_ctrl(void) {
        return JPEG_ctrl;
}

void prof_msg(const char *msg) {
        struct timeval tv;
        do_gettimeofday(&tv);
        printk("at %d:%06d: %s\n", (int)tv.tv_sec, (int)tv.tv_usec, msg);
}

int     x313_JPEG_cmd(int cmd) {
        MD5(printk ("JPEG_cmd %x: aq=%x,rd=%x, ry=%x\n", cmd, acq_index, read_index, ready_index));
        MD6(printk ("JPEG_cmd %x\r\n", cmd));
        MD8(printk ("JPEG_cmd %x\r\n", cmd));
        MD11(printk ("JPEG_cmd %x, rp=0x%x, wp=0x%x\r\n", cmd,camSeqGetJPEG_rp(),camSeqGetJPEG_wp() ));
        switch(cmd) {
//              case JPEG_CMD_ARM:    {return x313_dma_start_jpeg (0);}
                case JPEG_CMD_GET: {
                        prof_msg("JPEG_CMD_GET\n");
                        camSeqStop(); // just in case, but it should be stopped
                        x313_dma_update_jpeg_header();
                        return camSeqStartClip(0, 0); // just read frame from memory
                }
                case JPEG_CMD_ACQUIRE: {
                        prof_msg("JPEG_CMD_ACQUIRE\n");
                        x313_dma_update_jpeg_header();
                        return camSeqStartClip(1, -1); // acquire one frame
                }
                case JPEG_CMD_RESET0:  // cmd==0x10
                case JPEG_CMD_RESET:  { // cmd==0
                        prof_msg("JPEG_CMD_RESET\n");
                        x313_setDMABuffer(); 
                        x313_dma_reset_jpeg ();
                        return 0;
                }
                case JPEG_CMD_FORGET: {
                        prof_msg("JPEG_CMD_FORGET\n");
                        return x313_dma_forget_jpeg();
                }
                case JPEG_CMD_CATCHUP: {
                        prof_msg("JPEG_CMD_CATCHUP\n");
                        return x313_dma_catchup_jpeg();
                }
                case JPEG_CMD_DUMP: {
                        prof_msg("JPEG_CMD_DUMP\n");
                        x313_JPEG_dump();
                        return 0;
                }
                case JPEG_CMD_SAVE_RP:
                        prof_msg("JPEG_CMD_SAVE_RP\n");
                        return x313_dma_save_jpeg();
                case JPEG_CMD_RESTORE_RP:
                        prof_msg("JPEG_CMD_RESTORE_RP\n");
                        return x313_dma_restore_jpeg();
//#define      JPEG_CMD_START      0x0a // start constant compression mode
//#define      JPEG_CMD_STOP       0x0b // stop constant compression mode (may want to wait for CAMSEQ_DONE)
                case JPEG_CMD_START: {
                        prof_msg("JPEG_CMD_START\n");
                        x313_dma_update_jpeg_header();
                        return camSeqStartClip(0, -1); // start constant compression mode
                }
                case JPEG_CMD_STOP: {
                        prof_msg(" JPEG_CMD_STOP\n");
                        x313_dma_update_jpeg_header(); // needed if there was no start
                        return camSeqStartClip(-1, 0); // stop constant compression mode
                }
                case JPEG_CMD_JUST_STOP: {
                        prof_msg("JPEG_CMD_JUST_STOP\n");
                        return camSeqStartClip(-2, 0); // stop constant compression mode
                }
                case JPEG_CMD_FRAMES: {
                        prof_msg("JPEG_CMD_FRAMES\n");
                        return X313_dma_update(-1); // return number of frames in buffer
                }
                default:
                        return -1;
        }
}

// **************************************************************
//#define X313_DMA_DICARD      8  // number of extra 32-bytes word attached to the data to be discarded (FIFO)
#if 0
#define X313_CHAIN_SIGNATURE  0xffffffff
#define X313_CHAIN_SIGNATURE4 0xffff0000
//#define X313_CHAIN_SIGNATURE4 0xffffffff
#define X313_LENGTH_MASK      0xff000000

#define X313_PADDED_FRAME(x)((((x)+67+CCAM_MMAP_META ) >>2) & 0xfffffff8)
#define X313_BUFFSUB(x,y) (((x)>=(y))? ((x)-(y)) : ((x)+ (CCAM_DMA_SIZE-(y))))
#define X313_BUFFADD(x,y) ((((x) + (y))<=CCAM_DMA_SIZE)? ((x) + (y)) : ((x) - (CCAM_DMA_SIZE-(y))))
#endif

int     x313_dma_save_jpeg(void) {
        save_rp = camSeqGetJPEG_rp();
        save_wp = camSeqGetJPEG_wp();
        return 0;
}

int     x313_dma_restore_jpeg(void) {
        if(save_wp == camSeqGetJPEG_wp()) {
                camSeqSetJPEG_rp(save_rp);
                soft_rp = X313_BUFFSUB(save_rp, 2);
                return 0;
        }
        return -1;
}
void x313_dma_reset_chain(void) {
        soft_rp = CCAM_DMA_SIZE - 2;
        ccam_dma_buf_ptr[soft_rp] |= X313_CHAIN_SIGNATURE4;  // 0xffffxxxx if not overwritten
        ccam_dma_buf_ptr[soft_rp + 1] = X313_CHAIN_SIGNATURE;  // Data length (undefined)
        save_rp = -1;
        save_wp = -1;
}

void x313_dma_reset_jpeg(void) {
        camSeqStop();
        camSeqStop(); // if it was running, first one will stop, and second - buffer pointers
        x313_dma_reset_chain();
}

int     x313_dma_forget_jpeg(void) {
        int i = 0;
        unsigned long rp;
        if(((ccam_dma_buf_ptr[soft_rp] & X313_CHAIN_SIGNATURE4)!= X313_CHAIN_SIGNATURE4) || (ccam_dma_buf_ptr[soft_rp + 1] == X313_CHAIN_SIGNATURE)) // check only 2 bytes
                i = X313_dma_update(0); // build length-ahead
        if(i == 0) {
                soft_rp += X313_PADDED_FRAME(ccam_dma_buf_ptr[soft_rp + 1]);
                if(soft_rp >= CCAM_DMA_SIZE)
                        soft_rp -= CCAM_DMA_SIZE;
                rp = X313_BUFFADD(soft_rp, 2);
                camSeqSetJPEG_rp(rp);
                return rp; 
        }
        return -1;
}

//---- CATCHUP ----
int     x313_dma_catchup_jpeg(void) {
        int i;
        i = X313_dma_update(1);
        if(i == 0)
                return 0;
        return -1;
}

// new! (latest<0) - ignore rp and build the longest chain
// new_new instead of (latest<0) - just rp<0!


int X313_dma_update(int latest) { // builds forward references in acquired data
   int rp,p,p1; //,n;
   int nz=1;
   int nf=0; // number of frames in chain
   int rebuild=(latest<0);
   unsigned long l;
   unsigned long prev_l=0;
   MD1(printk("*** X313_dma_update(latest=%d) - modifies global RP, may interfere with imgsrv or other apps\n",latest));
// MD2(printk("X313_dma_update(latest=%d)\n",latest));
   if(rebuild)
      rp = -1;
   else { // (latest>=0)
      rp = camSeqGetJPEG_rp();
      rebuild = (rp < 0); 
      if ((rebuild == 0) && (!latest)) {  
         soft_rp=X313_BUFFSUB(rp, 2);
         if(((ccam_dma_buf_ptr[soft_rp] & X313_CHAIN_SIGNATURE4) == X313_CHAIN_SIGNATURE4) &&
            (ccam_dma_buf_ptr[soft_rp + 1] != X313_CHAIN_SIGNATURE))
            return 0;  
      }
   }
//Here rebuild (return number) or just rp is invalid - return 0/-error and point the latest/oldest
   if((p = camSeqGetJPEG_wp()) == rp)
      return -1; 

// n = 1;
   camSeqSetJPEG_rp(p); 
   soft_rp = X313_BUFFSUB(p, 2);
 MD2(printk("p=0x%x, rp=0x%x, soft_rp=0x%x\n",p,rp,soft_rp));
   while(1) {
      l = (ccam_dma_buf_ptr[X313_BUFFSUB(p, 9)] ^ X313_LENGTH_MASK); 
      if (!prev_l) { 
         if((l & X313_LENGTH_MASK) == 0) { 
            p = X313_BUFFSUB(p, X313_PADDED_FRAME(l));
            prev_l = l;
         } else return  rebuild?0:-1; 
      } else { //not the WP
        if ((ccam_dma_buf_ptr[X313_BUFFSUB(p, 2)] & X313_CHAIN_SIGNATURE4) == X313_CHAIN_SIGNATURE4) { 
           camSeqSetJPEG_rp(p);
           soft_rp = X313_BUFFSUB(p, 2);
           nf++;
           if((latest > 0) || 
              (p == rp))  
              return 0;
           if((l & X313_LENGTH_MASK) == 0) { 
             p1 = p;
             p = X313_BUFFSUB(p, X313_PADDED_FRAME(l));
             if(p >= p1) {
               if((nz--) <= 0) { // twice went through circular buffer, - should not happen, just in case...
                  printk(" X313_dma_update: twice went through zero - overwritten p=%x, p1=%x\n", p, p1);
                  return rebuild ? nf : -1; // only software mark is present - head of frames chain
               }
             }
             prev_l = l;
           } else {
            return rebuild ? nf : (nf? 0 :-1); // only software mark is present - head of frames chain
           }
        } else { 
            return rebuild? nf : (nf? 0:-2); 
        }
     } // not the WP
  }
}




unsigned long t_sign = 0;

// Here attempt to get size of "bad" buffer will rebuild the chain, but if it will still be empty - will stick forever
unsigned long x313_DMA_size(void) {     // will return 0 if DMA is enabled and not over. If over, will flush and stop it
        int i = 0;
        // trying to prevent getting old frame from the buffer if it address accidentally is the same as current write pointer  
//      if((camSeqGetJPEG_rp() == camSeqGetJPEG_wp()) || (ccam_dma_buf_ptr[soft_rp] != X313_CHAIN_SIGNATURE) || (ccam_dma_buf_ptr[soft_rp + 1] == X313_CHAIN_SIGNATURE))
        if((camSeqGetJPEG_rp() == camSeqGetJPEG_wp()) || ((ccam_dma_buf_ptr[soft_rp] & X313_CHAIN_SIGNATURE4) != X313_CHAIN_SIGNATURE4) || (ccam_dma_buf_ptr[soft_rp + 1] == X313_CHAIN_SIGNATURE))
                i = X313_dma_update(0); // build length-ahead
//      printk("x313_DMA_size: X313_dma_update(0)returned 0x%x\n", i);
        if((i >= 0) && (ccam_dma_buf_ptr[soft_rp + 1] != X313_CHAIN_SIGNATURE)) {
                t_sign = ccam_dma_buf_ptr[soft_rp + 1] + 0xFF000000;
                return ccam_dma_buf_ptr[soft_rp + 1];
        }
//      printk("x313_DMA_size got X313_dma_update(0) = %x\n", i); 
        return 0;
}

int x313_dma_stop(void) {
 MD12(printk("==========x313_dma_stop\n"));
        port_csp0_addr[X313_WA_DMACR] = 0;
        EXT_DMA_0_STOP ; // for testing - no reset DMA after acquisition
        udelay(10) ; //?
        DMA_RESET( regi_dma9 );
        // put here restoring of the .after pointer ?
        return 0;
}

void x313_dma_start(void) {
        unsigned long dai;
        int i = 0;

//x313_dma_stop(); ///  testing if that will help


 MD12(printk("----------x313_dma_start\n"));

        DMA_RESET(regi_dma9);
        // need to restore pointers after previous stop DMA - maybe later move there?
        for(dai = 0; dai < CCAM_DMA_SIZE; dai += DMA_CHUNK) { // DMA_CHUNK==0x4000
                if(dai + DMA_CHUNK >= CCAM_DMA_SIZE)  //last descriptor
                        ccam_dma_descr_data[i].after = (char *)virt_to_phys(&ccam_dma_buf_ptr[CCAM_DMA_SIZE]);
                else  // not the last one
                        ccam_dma_descr_data[i].after = (char *)virt_to_phys(&ccam_dma_buf_ptr[dai + DMA_CHUNK]);
//     flush_dma_descr((dma_descr_data*) & ccam_dma_descr_data[i], 0); //!We do not need dma descriptors, just reusing code Axis made already to fix a similar bug
       flush_dma_descr( & ccam_dma_descr_data[i], 0);

                i++;
        }
        DMA_ENABLE(regi_dma9);
        port_csp0_addr[X313_WA_DMACR] = 0;
        // NOTE: needs to be here (not in x313_dma_init) - word width is reset by channel reset !!!
        DMA_WR_CMD(regi_dma9, regk_dma_set_w_size4);  //32-bit transfers
        // point to the beginning of the buffer?
        ccam_dma_descr_context.saved_data = (dma_descr_data*)virt_to_phys(&ccam_dma_descr_data[0]);
        ccam_dma_descr_context.saved_data_buf = ccam_dma_descr_data[0].buf;
   flush_dma_descr((dma_descr_data*) & ccam_dma_descr_context, 0);

        DMA_START_CONTEXT(regi_dma9, virt_to_phys(&ccam_dma_descr_context));
        EXT_DMA_0_START ;// updated
        port_csp0_addr[X313_WA_DMACR] = 0x30000;
        // enable DMA in JPEG mode - now it is always JPEG (no raw DMA mode) 
}

//Using external dma 3 (input) with dma channel 9 
unsigned long x313_dma_init(void) {
        int rslt;
        jpeg_header_sbuffer_ptr = &jpeg_header_sbuffer[0];
        reg_dma_rw_cfg cfg = {.en = regk_dma_yes}; //  if disabled - will be busy and hang on attemt of DMA_WR_CMD
        reg_bif_dma_rw_ch3_ctrl exdma_ctrl = {
                .bw          = regk_bif_dma_bw32,
                .burst_len   = regk_bif_dma_burst8, // changed - updated FPGA to use 8-word bursts
                .cont        = 1,                   // continuous transfer mode (probably - don't care)
                .end_discard = 0,                   // discard end of burst date (don't care)
                .cnt         = 0,                   // transfer counter ignored
                .dreq_pin    = 0,                   // use hsh0
                .dreq_mode   = regk_bif_dma_norm,   // normal - active high DREQ from pin (see above)
                .tc_in_pin   = 0,                   // don't care - tc pin number
                .tc_in_mode  = 0,                   // no tc pin
                .bus_mode    = regk_bif_dma_master, // bus mode - master
                .rate_en     = 0                    // no rate limiting
        };
        reg_bif_dma_rw_ch3_addr exdma_addr = {.addr = MEM_CSR0_START | MEM_NON_CACHEABLE};
        reg_bif_dma_rw_pin0_cfg exdma_pin0 = {
                .master_ch   = 0,                   // don't care
                .master_mode = regk_bif_dma_off,    // off
                .slave_ch    = 0,                   // don't care
                .slave_mode  = regk_bif_dma_off     // off
        };
        reg_bif_dma_rw_pin1_cfg exdma_pin1 = {
                .master_ch   = 3,                   // ext DMA channel #
                .master_mode = regk_bif_dma_dack,   // use DACK, active high
                .slave_ch    = 3,                   // don't care
                .slave_mode  = regk_bif_dma_off     // off
        };
//      atomic_set(&dma_update_mess_dis, 0); // atomic_set with value==0???
        // just in case - free DMA channel (we are only using it here)
        crisv32_free_dma(EXTDMA3_RX_DMA_NBR);
        printk("Initializing DMA registers for EXTDMA3 - ");
        MD7(printk("x313_dma_init(void)"));

        D0(printk ("before crisv32_request_dma\n");
        udelay (500000));
        rslt = crisv32_request_dma(EXTDMA3_RX_DMA_NBR,
                "compressed data in from fpga",
                DMA_VERBOSE_ON_ERROR,
                0,
                dma_ext3);
        D0(printk ("after crisv32_request_dma - result=%d\n",rslt);
        udelay(500000));

        if(rslt) {
                printk("failed\n");
                crisv32_free_dma(EXTDMA3_RX_DMA_NBR);
                printk(KERN_CRIT "Can't allocate external dma port for compressed data in from fpga");
        } else { // dma channel 9 allocated for ext dma 3
                // setup source of hsh0, shs1
                REG_WR(bif_dma, regi_bif_dma, rw_pin0_cfg, exdma_pin0); // just in case - turn hsh0 off
                REG_WR(bif_dma, regi_bif_dma, rw_pin1_cfg, exdma_pin1); // make hsh1 DACK
                // Configure ext DMA 3
                REG_WR(bif_dma, regi_bif_dma, rw_ch3_ctrl, exdma_ctrl);
                REG_WR(bif_dma, regi_bif_dma, rw_ch3_addr, exdma_addr);
                REG_WR(dma, regi_dma9, rw_cfg, cfg);    //  DMA configuration (bit 0 - enable, bit 1 - stop) - stopped
/*
#define DMA_WR_CMD( inst, cmd_par ) \
   do { reg_dma_rw_stream_cmd r = {0}; \
        do { r = REG_RD( dma, inst, rw_stream_cmd ); } while( r.busy ); \
        r.cmd = (cmd_par); \
        REG_WR( dma, inst, rw_stream_cmd, r ); \
      } while( 0 )
*/
//   D0(do {reg_dma_rw_stream_cmd rr = REG_RD( dma, regi_dma9, rw_stream_cmd ); printk ("rr=0x%x\n", ((int *) &rr)[0]);} while (0); udelay (500000));
// Not a safe command - if always busy - will silently hang forever ...
         // Set up wordsize = 4 bytes for DMAs.
//     MD7(printk("Set up wordsize = 4 bytes for DMAs\n");
//         DMA_WR_CMD (regi_dma9, regk_dma_set_w_size4);  //32-bit transfers
   // initialize static DMA descriptor list
}
        DMABufferLength = 0;
        x313_setDMABuffer();
        x313_dma_reset_jpeg();
        return ((unsigned long)virt_to_phys(ccam_dma_buf_ptr)) | 0x80000000;
}

int x313_setDMABuffer(void) {
        unsigned long dai;
        int i = 0;
        // Stop DMA (just in case)
        EXT_DMA_0_STOP;
//      ccam_dma_length = 0;
        for(dai = 0; dai < CCAM_DMA_SIZE; dai += DMA_CHUNK) { // DMA_CHUNK==0x4000
                ccam_dma_descr_data[i].buf = (char *)virt_to_phys(&ccam_dma_buf_ptr[dai]);
//              ((unsigned long) virt_to_phys (&ccam_dma_buf_ptr[dai]))   | 0x80000000;
                ccam_dma_descr_data[i].intr = 0;
                ccam_dma_descr_data[i].wait = 0;
                ccam_dma_descr_data[i].eol = 0; // we probably do not need to use eol as the descriptors are linked in a loop anyway
                if(dai + DMA_CHUNK >= CCAM_DMA_SIZE) { //last descriptor
                        ccam_dma_descr_data[i].after = (char *)virt_to_phys(&ccam_dma_buf_ptr[CCAM_DMA_SIZE]);
                        ccam_dma_descr_data[i].next = (dma_descr_data*)virt_to_phys(&ccam_dma_descr_data[0]);
                } else { // not the last one
                        ccam_dma_descr_data[i].after = (char *)virt_to_phys(&ccam_dma_buf_ptr[dai + DMA_CHUNK]);
                        ccam_dma_descr_data[i].next = (dma_descr_data*)virt_to_phys(&ccam_dma_descr_data[i + 1]);
//                      ccam_dma_length += 0x10000;
                }
      flush_dma_descr( & ccam_dma_descr_data[i], 0);
                i++;
        }
    set_imageParamsR(P_CIRCBUFSIZE,CCAM_DMA_SIZE<<2);
// moved next 2 lines to x313_dma_start(void) 
//  ccam_dma_descr_context.saved_data = (dma_descr_data*)virt_to_phys(&ccam_dma_descr_data[0]);
//  ccam_dma_descr_context.saved_data_buf = ccam_dma_descr_data[0].buf;
//*********************** TEMPORARY ********************************       
        MD8(printk ("filling DMA buffer with natural numbers - just test \n"));
        for(dai = 0; dai < CCAM_DMA_SIZE; dai++)
                ccam_dma_buf_ptr[dai] = dai;
        return 0;
}

void x313_JPEG_dump(void) {
//      int i;
        printk("port_csp0_addr[X313__RA__STATUS] = 0x%x\n", (int)port_csp0_addr[X313__RA__STATUS]);
#if 0
   printk ("(*R_DMA_CH5_HWSW)=0x%x\n", (int) *R_DMA_CH5_HWSW);
   printk ("(*R_DMA_CH5_DESCR)=0x%x\n", (int) *R_DMA_CH5_DESCR);
   printk ("(*R_DMA_CH5_NEXT)=0x%x\n", (int) *R_DMA_CH5_NEXT);
   printk ("(*R_DMA_CH5_BUF)=0x%x\n", (int) *R_DMA_CH5_BUF);
   printk ("(*R_DMA_CH5_FIRST)=0x%x\n", (int) *R_DMA_CH5_FIRST);
   printk ("(*R_DMA_CH5_CMD)=0x%x\n", (int) *R_DMA_CH5_CMD);
   printk ("(*R_DMA_CH5_STATUS)=0x%x\n", (int) *R_DMA_CH5_STATUS);
#endif
#if 0
typedef struct dma_descr_data {
  struct dma_descr_data        *next;
  char                         *buf;
  unsigned                      eol        : 1;
  unsigned                                 : 2;
  unsigned                      out_eop    : 1;
  unsigned                      intr       : 1;
  unsigned                      wait       : 1;
  unsigned                                 : 2;
  unsigned                                 : 3;
  unsigned                      in_eop     : 1;
  unsigned                                 : 4;
  unsigned                      md         : 16;
  char                         *after;
} dma_descr_data;
#endif
#if 0
        printk("\nDMA desriptor table (buf,after,next\n");
        for(i=0; i < CCAM_DESCR_DATA_NUM; i++)
                printk("%3x: %8x %8x %8x\n", i, (int)ccam_dma_descr_data[i].buf,
                        (int)ccam_dma_descr_data[i].after, 
                        (int)ccam_dma_descr_data[i].next);
#endif
        printk("    use_header=  %x\n", use_header);
        printk("    JPEG_ctrl=   %x\n", JPEG_ctrl);
        printk("    jpeg_quality=%x\n", jpeg_quality);
        printk("    soft_rp=     %x\n", soft_rp);
        printk("    ccam_dma_buf_ptr[soft_rp]= %lx\n", ccam_dma_buf_ptr[soft_rp]);
        printk("    ccam_dma_buf_ptr[soft_rp+1]= %lx\n", ccam_dma_buf_ptr[soft_rp + 1]);
}

//  return (l<<2)+(use_header? (JPEG_HEADER_SIZE+TRAILER_SIZE)  : 0 );

int cmoscam_open_dma(struct inode *inode, struct file *filp) { // set filesize
        int exif_len = exif_header_length();
        int exif_off = exif_len - EXIF_OFFSET;
        int header_size = JPEG_HEADER_SIZE + exif_off;
        int l;
        // avoid calculating size while compressor is running in constant mode (return 0) - do it in cc313.c
        l = x313_DMA_size();
//      if ((l>0) && use_header) l += (JPEG_HEADER_SIZE + TRAILER_SIZE);
        if((l > 0) && use_header)
                l += (header_size + TRAILER_SIZE);
        inode->i_size = l;
//      inode->i_atime=0x7ffffff;
//      inode->i_mtime=0x7ffffff;
//      inode->i_ctime=0x7ffffff;
        return 0;
}

loff_t x313_dma_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  address
        // make it always stop DMA (needed?)
        int exif_len = exif_header_length();
        int exif_off = exif_len - EXIF_OFFSET;
        int header_size = JPEG_HEADER_SIZE + exif_off;

        int l;
        l = x313_DMA_size();
//      printk("from x313_dma_lseek: l == %d, ", l);
//      if ((l>0) && use_header) l += (JPEG_HEADER_SIZE + TRAILER_SIZE);
        if((l > 0) && use_header)
                l += (header_size + TRAILER_SIZE);
//      printk("and with EXIF l == %d\r\n", l);
        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) {
                printk("x313_dma_lseek: file->fpose - negative! l=%d\n",l);
                printk("x313_dma_lseek orig=%d\n",orig);
                file->f_pos = 0;
                return(-EOVERFLOW);
        }
  
        if(file->f_pos > l) {
                file->f_pos = l;
        }
        return( file->f_pos );
}

unsigned long cpu_to_le(unsigned long in) {
        unsigned long r = (in & 0xFF) << 24;
        r += (in & 0xFF00) << 8;
        r += (in & 0xFF0000) >> 8;
        r += (in & 0xFF00) >> 24;
        return r;
}

void get_image_exp(unsigned long *e) {
        *e = get_imageParamsR(P_EXPOS);
//      printk("--==--> exposition time:\r\n");
//      printk("get_imageParamsR(P_EXPOS) == %d\r\n", get_imageParamsR(P_EXPOS));
//      printk("get_imageParamsW(P_EXPOS) == %d\r\n", get_imageParamsW(P_EXPOS));
}

static unsigned char ext_mjpeg_header[PAGE_SIZE] __attribute__ ((aligned (PAGE_SIZE)));

/*
 * EXT_JPEG_MMAP
 */
// mmap'ing functions
/*
unsigned long ext_jpeg_buf_ptr(void) {
        return (unsigned long)ccam_dma_buf_ptr;
}

unsigned long ext_jpeg_buf_length(void) {
        return CCAM_DMA_SIZE;
}
*/
unsigned long ext_make_jpeg_header(void);

void ext_fill_jpeg_mmap_desc(struct ext_jpeg_mmap_desc_t *mdesc) {
//      mdesc->jpeg_addr = PAGE_SIZE + ((X313_BUFFADD(soft_rp, 2)) << 2);
//      mdesc->jpeg_addr = (unsigned long)((X313_BUFFADD(soft_rp, 2)) << 2) - (unsigned long)ccam_dma_buf_ptr;
        mdesc->jpeg_addr = ((X313_BUFFADD(soft_rp, 2)) << 2);
//      mdesc->jpeg_addr = ((X313_BUFFADD(soft_rp, 2) - CCAM_DMA_SIZE) << 2);
//      mdesc->jpeg_addr = 0;
//printk("jpeg_addr (start offset) == 0x%08X, soft_rp == 0x%08X, offset == 0x%08X, offset_2 = 0x%08X\r\n", mdesc->jpeg_addr, soft_rp, (soft_rp + 2) << 2, (soft_rp + 2 - CCAM_DMA_SIZE) << 2);
        mdesc->jpeg_length = x313_DMA_size();
        mdesc->exif_length = ext_make_jpeg_header();
        mdesc->mmap_start = 0;
        mdesc->mmap_exif_length = PAGE_SIZE;
        mdesc->mmap_jpeg_length = CCAM_DMA_SIZE << 2;
//printk("mmap: mmap_start: 0x%08X, mmap_exif_length: 0x%08X, mmap_jpeg_length: 0x%08X\n", mdesc->mmap_start, mdesc->mmap_exif_length, mdesc->mmap_jpeg_length);
}

void ext_fill_jpeg_mmap_desc_(struct _ext_jpeg_mmap_desc_t *mdesc) {
        mdesc->exif_start = (void *)&ext_mjpeg_header[0];
        mdesc->exif_length = PAGE_SIZE;
        mdesc->jpeg_start = (unsigned long *) ccam_dma_buf_ptr;
        mdesc->jpeg_length = CCAM_DMA_SIZE << 2;
//printk("mmap: exif_start: 0x%08X, exif_length: 0x%08X, jpeg_start: 0x%08X, jpeg_length: 0x%08X\n", mdesc->exif_start, mdesc->exif_length, mdesc->jpeg_start, mdesc->jpeg_length);
}

// Create JPEG header (in mmap'ed area) with current EXIF fields and return length of JPEG header
unsigned long ext_make_jpeg_header(void) {
        unsigned char *jpeg_header = ext_mjpeg_header;
        int exif_len = exif_header_length();
        int exif_off = exif_len - EXIF_OFFSET;
//      int header_size = JPEG_HEADER_SIZE + exif_off + TRAILER_SIZE;
        int header_size = JPEG_HEADER_SIZE + exif_off;// + TRAILER_SIZE;

        unsigned long ne_exp[2];
        /* fill EXIF with current data */
        // get the length and pointer to memory
        memcpy(jpeg_header + exif_off, jpeg_header_sbuffer, JPEG_HEADER_SIZE);
        memcpy(jpeg_header, exif_header, exif_len);
        unsigned char *exif = jpeg_header;
        /* install EXIF items */
        memcpy(exif + EXIF_FIRMWARE, exif_desc.firmware, EXIF_FIRMWARE_LEN);
        memcpy(exif + EXIF_ARTIST, exif_desc.artist, EXIF_ARTIST_LEN);
        memcpy(exif + EXIF_DATE_TIME, exif_desc.date_time, EXIF_DATE_TIME_LEN);
        memcpy(exif + EXIF_DATE_TIME_OR, exif_desc.date_time_or, EXIF_DATE_TIME_OR_LEN);
        memcpy(exif + EXIF_SUBSEC_OR, exif_desc.subsec, EXIF_SUBSEC_OR_LEN);
        get_image_exp(&exif_desc.exp[0]);
        ne_exp[0] = cpu_to_le(exif_desc.exp[0]);
        ne_exp[1] = cpu_to_le(exif_desc.exp[1]);
        memcpy(exif + EXIF_EXP, ne_exp, EXIF_EXP_LEN);

        return header_size;
}
//#define EXIF y
#ifdef EXIF
ssize_t x313_dma_read(struct file * file, char * buf, size_t count, loff_t *off) {
        unsigned long p, l, i, left, l1;
        int rp;
        char *bp = buf;

        unsigned char jpeg_header[2048];
        int exif_len = exif_header_length();
        int exif_off = exif_len - EXIF_OFFSET;
        int header_size = JPEG_HEADER_SIZE + exif_off;
//      unsigned char exif_desc.date_time[EXIF_DATE_TIME_LEN];

        D(printk("x313_dma_read\n"));
//  x313_dma_stop();
//      p = file->f_pos;
        p = *off;
//      if((p + count) > ((l = x313_DMA_size()) + (use_header ? (JPEG_HEADER_SIZE + TRAILER_SIZE) : 0))) { // truncate count 
//              count = l + (use_header ? (JPEG_HEADER_SIZE + TRAILER_SIZE) : 0) - p;
        if((p + count) > ((l = x313_DMA_size()) + (use_header ? (header_size + TRAILER_SIZE) : 0))) { // truncate count 
                count = l + (use_header ? (header_size + TRAILER_SIZE) : 0) - p;
        }
        left = count;
// read header (if needed)
        if(use_header) {
                unsigned long ne_exp[2];
                /* fill EXIF with current data */
                // get the length and pointer to memory
                memcpy(jpeg_header + exif_off, jpeg_header_sbuffer, JPEG_HEADER_SIZE);
                memcpy(jpeg_header, exif_header, exif_len);
                unsigned char *exif = jpeg_header;
                /* install EXIF items */
                memcpy(exif + EXIF_FIRMWARE, exif_desc.firmware, EXIF_FIRMWARE_LEN);
                memcpy(exif + EXIF_ARTIST, exif_desc.artist, EXIF_ARTIST_LEN);
                memcpy(exif + EXIF_DATE_TIME, exif_desc.date_time, EXIF_DATE_TIME_LEN);
                memcpy(exif + EXIF_DATE_TIME_OR, exif_desc.date_time_or, EXIF_DATE_TIME_OR_LEN);
                memcpy(exif + EXIF_SUBSEC_OR, exif_desc.subsec, EXIF_SUBSEC_OR_LEN);
                get_image_exp(&exif_desc.exp[0]);
                ne_exp[0] = cpu_to_le(exif_desc.exp[0]);
                ne_exp[1] = cpu_to_le(exif_desc.exp[1]);
                memcpy(exif + EXIF_EXP, ne_exp, EXIF_EXP_LEN);

                if(p < header_size) {
                        i = left;
                        if(i > (header_size - p))
                                i = header_size - p;
                        if(i && (copy_to_user(bp, &jpeg_header[p], i))) {
                                printk("copy_to_user1 (0x%x) error\n",( int)i);
                                return -EFAULT;
                        }
                        bp += i;
                        left -= i;
                        p = 0;
                } else
                        p -= header_size;
        }  // if (use_header)

        if(left == 0) {
                *off += count;
                return count;
        }

        // copy image data itself - the buffer may be broken it two parts.
        if(p < l) {
//              rp=soft_rp+2;if (rp>=CCAM_DMA_SIZE) rp-=CCAM_DMA_SIZE;
                rp = X313_BUFFADD(soft_rp, 2);
                MD9(printk("rp == 0x%08X; rp << 2 == 0x%08X\r\n", rp, rp << 2));
                // part I - from the beginning read_index up...
                l1 = ((CCAM_DMA_SIZE - rp) << 2);
                if(l1 > l)
                        l1 = l;         
                if(p < l1) {
                        i = left;
                        if(i > (l1 - p))
                                i = l1 - p;
                        if(i && (copy_to_user(bp, ((char *) ccam_dma_buf_ptr) + (rp << 2)+ p, i))) {
                                printk("copy_to_user2 (0x%x) error\n",(int) i);
                                return -EFAULT;
                        }
//printk("offset == 0x%08X\n", (rp << 2) + p - header_size);
                        bp += i;
                        left -= i;
                        p = 0;
                } else
                        p -= l1;
                // Part II - continue from the start of the DMA buffer
                l -= l1;
                if(p < l) {
                        i = left;
                        if(i > (l - p))
                                i = l - p;
//printk("offset == 0x%08X; 0x%08X\n", p - header_size, p);
                        if(i && (copy_to_user(bp, ((char *)ccam_dma_buf_ptr) + p, i))) {
                                printk("copy_to_user3 (0x%x) error\n", (int)i);
                                printk("soft_rp=0x%x\n", (int)soft_rp);
                                printk("*off=0x%x\n", (int) *off);
                                printk("count=0x%x, left=0x%x, l=0x%x, i=0x%x, p=0x%x\n", (int)count, (int)left, (int)l, (int)i, (int)p);
                                return -EFAULT;
                        }
                        bp += i;
                        left -= i;
                        p = 0;
                } else
                        p -= l;
        } else
                p -= l; // pointer got into the trailer
        // copy image trailer (EOI marker). 'left' should be already 0 if (use_header==0)
        if(left > 0) {
                i = left;
//              if(i > (TRAILER_SIZE - p)) i = TRAILER_SIZE - p;
                if(i > TRAILER_SIZE)
                        i = TRAILER_SIZE;
                if(i && (copy_to_user(bp, &trailer[p], i))) {
                        // sometimes we get here with 'negative' i
                        printk("copy_to_user4 (0x%x) error\n", (int)i);
                        printk("soft_rp=0x%x\n", (int)soft_rp);
                        printk("*off=0x%x\n", (int)*off);
                        printk("count=0x%x, left=0x%x, l=0x%x, i=0x%x, p=0x%x\n", (int)count, (int)left, (int)l, (int)i, (int)p);
                        return -EFAULT;
                }
        } // if (left>0)
//      file->f_pos += count;
        *off += count;
        return count;  
}

#else
// w/o EXIF stuff
ssize_t x313_dma_read(struct file * file, char * buf, size_t count, loff_t *off) {
        unsigned long p, l, i, left, l1;
        int rp;
        char *bp = buf;

        MD9(printk("x313_dma_read\n"));
//  x313_dma_stop();
//      p = file->f_pos;
        p = *off;
        if((p + count) > ((l = x313_DMA_size()) + (use_header ? (JPEG_HEADER_SIZE + TRAILER_SIZE) : 0))) { // truncate count 
                count = l + (use_header ? (JPEG_HEADER_SIZE + TRAILER_SIZE) : 0) - p;
        }
        left = count;
// read header (if needed)
        if (use_header) {
          if (p < JPEG_HEADER_SIZE) {
            i=left;
            if (i>(JPEG_HEADER_SIZE-p)) i= JPEG_HEADER_SIZE-p;
            if (i && (copy_to_user(bp, &jpeg_header_sbuffer[p], i)))
               {printk("copy_to_user1 (0x%x) error\n",(int) i);return -EFAULT;}
            bp+=i;
            left-=i;
            p=0;
          } else p-=JPEG_HEADER_SIZE;
        }  // if (use_header)

        if(left == 0) {
                *off += count;
                return count;
        }

        // copy image data itself - the buffer may be broken it two parts.
        if(p < l) {
//              rp=soft_rp+2;if (rp>=CCAM_DMA_SIZE) rp-=CCAM_DMA_SIZE;
                rp = X313_BUFFADD(soft_rp, 2);
                MD9(printk("rp == 0x%08X; rp << 2 == 0x%08X\r\n", rp, rp << 2));
                // part I - from the beginning read_index up...
                l1 = ((CCAM_DMA_SIZE - rp) << 2);
                if(l1 > l)
                        l1 = l;         
                if(p < l1) {
                        i = left;
                        if(i > (l1 - p))
                                i = l1 - p;
                        if(i && (copy_to_user(bp, ((char *) ccam_dma_buf_ptr) + (rp << 2)+ p, i))) {
                                printk("copy_to_user2 (0x%x) error\n",(int) i);
                                return -EFAULT;
                        }
                        bp += i;
                        left -= i;
                        p = 0;
                } else
                        p -= l1;
                // Part II - continue from the start of the DMA buffer
                l -= l1;
                if(p < l) {
                        i = left;
                        if(i > (l - p))
                                i = l - p;
                        if(i && (copy_to_user(bp, ((char *)ccam_dma_buf_ptr) + p, i))) {
                                printk("copy_to_user3 (0x%x) error\n", (int)i);
                                printk("soft_rp=0x%x\n", (int)soft_rp);
                                printk("*off=0x%x\n", (int) *off);
                                printk("count=0x%x, left=0x%x, l=0x%x, i=0x%x, p=0x%x\n", (int)count, (int)left, (int)l, (int)i, (int)p);
                                return -EFAULT;
                        }
                        bp += i;
                        left -= i;
                        p = 0;
                } else
                        p -= l;
        } else
                p -= l; // pointer got into the trailer
        // copy image trailer (EOI marker). 'left' should be already 0 if (use_header==0)
        if(left > 0) {
                i = left;
//              if(i > (TRAILER_SIZE - p)) i = TRAILER_SIZE - p;
                if(i > TRAILER_SIZE)
                        i = TRAILER_SIZE;
                if(i && (copy_to_user(bp, &trailer[p], i))) {
                        // sometimes we get here with 'negative' i
                        printk("copy_to_user4 (0x%x) error\n", (int)i);
                        printk("soft_rp=0x%x\n", (int)soft_rp);
                        printk("*off=0x%x\n", (int)*off);
                        printk("count=0x%x, left=0x%x, l=0x%x, i=0x%x, p=0x%x\n", (int)count, (int)left, (int)l, (int)i, (int)p);
                        return -EFAULT;
                }
        } // if (left>0)
//      file->f_pos += count;
        *off += count;
        return count;  
}

#endif
ssize_t x313_dma_write(struct file * file, const char * buf, size_t count, loff_t *off) {
  unsigned long p;

  D(printk("x313_dma_write\n"));
//  p = file->f_pos;
  p = *off;
  if (p >= JPEG_HEADER_SIZE)  p = JPEG_HEADER_SIZE;
  if( (p + count) > JPEG_HEADER_SIZE) { // truncate count 
    count = JPEG_HEADER_SIZE - p;
  }
  if (count) { 
    if (copy_from_user(&jpeg_header_sbuffer[p],buf, count)) return -EFAULT;
//    file->f_pos+=count;
    *off+=count;
  }
  return count;  
}
#if 0
int             FPGA_quality=-1;
int             JPEG_header_quality=-1;
int             JPEG_header_width=-1;
int             JPEG_header_height-1;
#endif

void setJPEGHeader (int quality, int width, int height) {
MD9(printk("setJPEGHeader(quality=%d,width=%d, height=%d)\n",quality, width, height));
        jpeg_header_sbuffer[HEADER_HEIGHT    ] = (height >> 8) & 0xff;
        jpeg_header_sbuffer[HEADER_HEIGHT + 1] = height & 0xff;
        jpeg_header_sbuffer[HEADER_WIDTH     ] = (width >> 8) & 0xff;
        jpeg_header_sbuffer[HEADER_WIDTH + 1 ] = width & 0xff;
//   if (quality != JPEG_header_quality) jpeg_set_quality ( quality, 0);
   if (quality != JPEG_header_quality) jpeg_set_quality(quality, QTABLES_EXIF, NULL);
}

void x313_dma_update_jpeg_header(void) { // uses channel 0 SDRAM FPGA settings - channel 0 should be programmed earlier
        int x, y;
        MD8(printk("x313_dma_update_jpeg_header W(P_QUALITY)=%d,R(P_QUALITY)=%d\n",(int)get_imageParamsW(P_QUALITY),(int)get_imageParamsR(P_QUALITY)));
        update_JPEG_quality(get_imageParamsW(P_QUALITY));
        // Data should be acquired in 8 bit mode
//      y = ((port_csp0_addr[X313_WA_SDCH0_CTL2] & 0x07f0)>>4)+1;
//      x = ((port_csp0_addr[X313_WA_SDCH0_CTL1] & 0x0ff0)>>4)+1;
        // it actually uses channel2, not channel1!!
        y = ((port_csp0_addr[X313_WA_SDCH2_CTL2] & 0x0ff0) >> 4) + 1;
        x = ((port_csp0_addr[X313_WA_SDCH2_CTL1] & 0x1ff0) >> 4) + 1;
        MD6(printk("x313_dma_update_jpeg_header x=0x%x, y=0x%x\r\n",x,y));
   MD13(printk("x313_dma_update_jpeg_header x=0x%x, y=0x%x (used SDRAM CHN2)\r\n",x,y));
        // set the same size into header area
        jpeg_header_sbuffer[HEADER_HEIGHT    ] = (y >> 4) & 0xff;
        jpeg_header_sbuffer[HEADER_HEIGHT + 1] = (y << 4) & 0xff;
        jpeg_header_sbuffer[HEADER_WIDTH     ] = (x >> 4) & 0xff;
        jpeg_header_sbuffer[HEADER_WIDTH + 1 ] = (x << 4) & 0xff;
}

// set JPEG quantization tables exactly as in standard software compression
#define DCTSIZE2 64
void update_JPEG_quality(int quality) { // compressor quality
  if((quality != get_imageParamsR(P_QUALITY)) || (quality != jpeg_quality)) {
    set_imageParamsR(P_QUALITY, quality);
//    jpeg_set_quality(quality, 1); // program FPGA too
    jpeg_set_quality(quality, QTABLES_FPGA | QTABLES_EXIF, NULL); // program FPGA too
    jpeg_quality = quality;
    frame_params.quality=quality;
  }
}
// add parameter updateFPGA, and header_width, header_height, header_quality
//void jpeg_set_quality (int quality, int writeFPGA){
void jpeg_set_quality (int quality, int target, void *table){
  /* These are the sample quantization tables given in JPEG spec section K.1.
   * The spec says that the values given produce "good" quality, and
   * when divided by 2, "very good" quality.
   */
        int i, temp;
        int prev = 0;// supress warning
        unsigned char *qtable = NULL;
//   if (quality == (writeFPGA ? FPGA_quality : JPEG_header_quality)) return; // nothing to do
        if((target & QTABLES_FPGA) && quality == FPGA_quality)
                target &= ~QTABLES_FPGA;
        if((target & QTABLES_EXIF) && quality == JPEG_header_quality)
                target &= ~QTABLES_EXIF;
        if(target & QTABLES_TABLE) {
                if(table == NULL)
                        target &= ~QTABLES_TABLE;
                else
                        qtable = (unsigned char *)table;
        }
        if(target == 0)
                return; // nothing to do


        const unsigned int zig_zag[DCTSIZE2] = {
                 0, 1, 5, 6,14,15,27,28,
                 2, 4, 7,13,16,26,29,42,
                 3, 8,12,17,25,30,41,43,
                 9,11,18,24,31,40,44,53,
                10,19,23,32,39,45,52,54,
                20,22,33,38,46,51,55,60,
                21,34,37,47,50,56,59,61,
                35,36,48,49,57,58,62,63   
        };
  
        const unsigned int std_quant_tbls[2 * DCTSIZE2] = {

    16,  11,  10,  16,  24,  40,  51,  61,
    12,  12,  14,  19,  26,  58,  60,  55,
    14,  13,  16,  24,  40,  57,  69,  56,
    14,  17,  22,  29,  51,  87,  80,  62,
    18,  22,  37,  56,  68, 109, 103,  77,
    24,  35,  55,  64,  81, 104, 113,  92,
    49,  64,  78,  87, 103, 121, 120, 101,
    72,  92,  95,  98, 112, 100, 103,  99,

    17,  18,  24,  47,  99,  99,  99,  99,
    18,  21,  26,  66,  99,  99,  99,  99,
    24,  26,  56,  99,  99,  99,  99,  99,
    47,  66,  99,  99,  99,  99,  99,  99,
    99,  99,  99,  99,  99,  99,  99,  99,
    99,  99,  99,  99,  99,  99,  99,  99,
    99,  99,  99,  99,  99,  99,  99,  99,
    99,  99,  99,  99,  99,  99,  99,  99
  };

 /* Convert a user-specified quality rating to a percentage scaling factor
 * for an underlying quantization table, using our recommended scaling curve.
 * The input 'quality' factor should be 0 (terrible) to 100 (very good).
 */
  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
        if(quality <= 0)
                quality = 1;
        if(quality > 100)
                quality = 100;

  /* The basic table is used as-is (scaling 100) for a quality of 50.
   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
   * note that at Q=100 the scaling is 0, which will cause jpeg_add_quant_table
   * to make all the table entries 1 (hence, minimum quantization loss).
   * Qualities 1..50 are converted to scaling percentage 5000/Q.
   */
        if(quality < 50)
            quality = 5000 / quality;
        else
                quality = 200 - quality * 2;


        /* Set up two quantization tables using the specified scaling */
//      if (writeFPGA) port_csp0_addr[X313_WA_COMP_TA] = 0x0; // open fpga for writing Q-table (address 0)

#ifdef PRINTQTAB
        printk ("writing quantization table to FPGA\n");
#endif
   MD13(printk ("writing quantization table, target=%x (FPGA=%x,EXIF=%x)\n", (int) target, (int)QTABLES_FPGA, (int) QTABLES_EXIF));
   unsigned long flags; 
   local_irq_save(flags);
   if(target & QTABLES_FPGA) port_csp0_addr[X313_WA_COMP_TA] = 0x0; // open fpga for writing Q-table (address 0)
        for(i = 0; i < 2 * DCTSIZE2; i++) {
                temp = (std_quant_tbls[i] * quality + 50) / 100;
                /* limit the values to the valid range */
                if(temp <= 0) temp = 1;
                if(temp > 255) temp = 255; // max quantizer needed for 12 bits
                // fix the tables knowing that FPGA actually multiplies, not divides:
                temp = ((8192/temp) + 1) >> 1;
                if(temp > 4095) temp = 4095;
                if(i & 1) {
//                      if (writeFPGA) port_csp0_addr[X313_WA_COMP_TD] = (temp << 16) | prev;   // will autoincrement address
                        if(target & QTABLES_FPGA) port_csp0_addr[X313_WA_COMP_TD] = (temp << 16) | prev;        // will autoincrement address
#ifdef PRINTQTAB
                        printk ("%08x ",(temp << 16) | prev);
                        if((i & 0x07) == 0x07) printk ("\n");
#endif
                } else
                        prev = temp;
                temp = ((8192 / temp) + 1) >> 1;
                if(target & QTABLES_EXIF)
                        jpeg_header_sbuffer[((i < DCTSIZE2) ? HEADER_YQTABLE : HEADER_CQTABLE) + zig_zag[i & 0x3f]] = temp;
                if(target & QTABLES_TABLE)
                        qtable[((i < DCTSIZE2) ? 0 : 64) + zig_zag[i & 0x3F]] = temp;
        }
   local_irq_restore(flags);

        if(target & QTABLES_EXIF)
                JPEG_header_quality = quality;
        if(target & QTABLES_FPGA)
                FPGA_quality = quality;
//   JPEG_header_quality=quality;
//   if (writeFPGA)  FPGA_quality=quality;
}

---