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

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : circbuf.c
*! DESCRIPTION: drivers to manipulate large circular buffer thet holds compressed
*! images/video. Buffer frame data is filled in by the FPGA, frame pointers and
*! essential frames metadata filled during servicing of the interruptsl
*! This code is based on the code from cxdma.c
*!
*! 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: circbuf.c,v $
*!  Revision 1.10  2008/04/11 23:16:51  elphel
*!  removed unneeded local_irq_disable() after local_irq_save_flags()
*!
*!  Revision 1.8  2007/12/03 08:28:46  elphel
*!  Multiple changes, mostly cleanup
*!
*!  Revision 1.7  2007/11/16 08:56:19  elphel
*!  Added support for 2 additional commands to check circbuf usage
*!
*!  Revision 1.6  2007/11/05 06:08:25  elphel
*!  fixed "first/second" bug introduced while fixing the previous one
*!
*!  Revision 1.5  2007/11/05 01:40:51  elphel
*!  fixed wrong count of frames available, "second" frame
*!
*!  Revision 1.4  2007/11/04 05:46:06  elphel
*!  removed debug, rearranged code to avoid a warning
*!
*!  Revision 1.3  2007/11/01 18:59:37  elphel
*!  debugging mmap/caching problems
*!
*!  Revision 1.2  2007/10/27 00:55:32  elphel
*!  untested revision - need to go
*!
*!  Revision 1.1.1.1  2007/10/02 23:54:58  elphel
*!  This is a fresh tree based on elphel353-2.10
*!
*!  Revision 1.6  2007/10/02 23:54:58  elphel
*!  CIRCLSEEK_LAST will now return just write pointer, not an error if there are no frames yet available. Moving to previous will still generate error.
*!
*!  Revision 1.5  2007/10/02 22:29:38  elphel
*!  made that only 0,SEEK_END can move beyond circbuf, fro SEEK_CUR and SEET_SET it will roll over to 0
*!
*!  Revision 1.4  2007/10/02 19:35:15  elphel
*!  minor circbuf interface changes, bug fixes
*!
*!  Revision 1.3  2007/09/30 07:07:08  elphel
*!  minor bug fix, disabled debug output
*!
*!  Revision 1.2  2007/09/30 03:19:56  elphel
*!  Cleanup, fixed broken acquisition of individual JPEG images into circbuf (in mode 7)
*!
*!  Revision 1.1  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
*!
*/

/****************** 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/svinto.h> obsolete
#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/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"

#define MD12(x)
#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
//#if 0
#define JPEG_HEADER_SIZE    0x26f
#if 0
#define TRAILER_SIZE   0x02
#define HEADER_YQTABLE 0x19
#define HEADER_CQTABLE 0x5e

#define HEADER_HEIGHT  0xa3
#define HEADER_WIDTH   0xa5
#endif
/* really huge static DMA buffer (1288+8)*1032/3=445824 long-s */
// DMA_SIZE - in 32-bit words, not bytes
//static unsigned long ccam_dma_buf[CCAM_DMA_SIZE + PAGE_SIZE>>2)] __attribute__ ((aligned (PAGE_SIZE)));
static unsigned long ccam_dma_buf[CCAM_DMA_SIZE + (PAGE_SIZE>>2)] __attribute__ ((aligned (PAGE_SIZE)));
unsigned long  * ccam_dma_buf_ptr = NULL;
unsigned long * ccam_dma =         NULL; 
void init_ccam_dma_buf_ptr(void) {
    ccam_dma_buf_ptr = ccam_dma_buf;
    ccam_dma =         ccam_dma_buf; //&ccam_dma_buf[0]; Use in autoexposure
}
extern struct frame_params_t frame_params; // cc353.c
wait_queue_head_t circbuf_wait_queue;
#define CIRCBUF_MAJOR 135
#define CIRCBUF_DRIVER_NAME "Elphel (R) Model 353 video buffer device driver"
static struct file_operations circbuf_fops = {
   owner:    THIS_MODULE,
   llseek:   circbuf_all_lseek,
   read:     circbuf_all_read,
   write:    circbuf_all_write,
   ioctl:    circbuf_all_ioctl,
   open:     circbuf_all_open,
   mmap:     circbuf_all_mmap,
   poll:     circbuf_all_poll,
   release:  circbuf_all_release
};

// Read/write to circular buffer.  Needed to find out what Axis DMA is doing
// also - jpeg header

//.typedef 
struct circbuf_pd {
    int                minor;
    struct wait_queue *circbuf_wait_queue;
// something else to be added here?
};

int circbuf_all_open(struct inode *inode, struct file *filp) {
   int res;
   struct circbuf_pd * privData;
   privData= (struct circbuf_pd *) kmalloc(sizeof(struct circbuf_pd),GFP_KERNEL);
   if (!privData) return -ENOMEM;
   filp->private_data = privData;
   privData-> minor=MINOR(inode->i_rdev);
 MD10(printk("circbuf_all_open, minor=0x%x\n",privData-> minor));
  switch (privData-> minor) {
    case  CMOSCAM_MINOR_CIRCBUF :
        res=circbuf_open(inode,filp);
        break;
    case  CMOSCAM_MINOR_JPEAGHEAD :
        res=jpeghead_open(inode,filp);
        break;
    default:
       kfree(filp->private_data); // already allocated
       return -EINVAL;
  }
  return res;
}
int circbuf_all_release(struct inode *inode, struct file *filp) {
  int res=0;
  int p = MINOR(inode->i_rdev);
 MD10(printk("circbuf_all_release, minor=0x%x\n",p));
  switch ( p ) {
    case  CMOSCAM_MINOR_CIRCBUF :
//        res=circbuf_release(inode,filp);
        break;
    case  CMOSCAM_MINOR_JPEAGHEAD :
//        res=jpeghead_release(inode,filp);
        break;
    default:
        return -EINVAL; 
    }
  kfree(filp->private_data);
  return res;
}

loff_t circbuf_all_lseek(struct file * file, loff_t offset, int orig) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
 MD10(printk("circbuf_all_lseek, minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case CMOSCAM_MINOR_CIRCBUF :    return  circbuf_lseek (file, offset, orig);
       case CMOSCAM_MINOR_JPEAGHEAD :  return  jpeghead_lseek (file, offset, orig);
       default:                        return -EINVAL;
     }
}

ssize_t circbuf_all_read(struct file * file, char * buf, size_t count, loff_t *off) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
 MD10(printk("circbuf_all_read, minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case CMOSCAM_MINOR_CIRCBUF :      return  circbuf_read   (file, buf, count, off);
       case CMOSCAM_MINOR_JPEAGHEAD :    return  jpeghead_read  (file, buf, count, off);
       default:                          return -EINVAL;
    }
}
ssize_t circbuf_all_write(struct file * file, const char * buf, size_t count, loff_t *off) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
 MD10(printk("circbuf_all_write, minor=0x%x, count=%d, off=%d\n",privData-> minor, (int) count,(int)*off));
     switch (privData->minor) {
       case CMOSCAM_MINOR_CIRCBUF :       return  circbuf_write (file, buf, count, off);
       case CMOSCAM_MINOR_JPEAGHEAD :     return  jpeghead_write     (file, buf, count, off); // same as other - write header
       default:                           return -EINVAL;
    }
}


int circbuf_all_mmap (struct file *file, struct vm_area_struct *vma) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
 MD10(printk("circbuf_all_mmap, minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case  CMOSCAM_MINOR_CIRCBUF :   return  circbuf_mmap   (file, vma);
       default: return -EINVAL;
    }
}

unsigned int circbuf_all_poll (struct file *file, poll_table *wait) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
 MD10(printk("circbuf_all_poll, minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case  CMOSCAM_MINOR_CIRCBUF :
          return circbuf_poll (file, wait);
       default:                           return -EINVAL;
    }
}

int circbuf_all_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) {
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) filp->private_data;
     printk("\n========== IOCTL is not implemented in circbuf_all_ioctl, minor=0x%x, cmd=0x%x, _IOC_NR(cmd)=0x%x, arg=0x%x\n",privData-> minor, (int) cmd, _IOC_NR(cmd), (int) arg);
     return -EINVAL;
}




int circbuf_open(struct inode *inode, struct file *filp) { // set filesize
   inode->i_size = ((CCAM_DMA_SIZE) << 2);
 MD10(printk("circbuf_open, inode->i_size=0x%x\n", (int)inode->i_size));
   circbuf_lseek(filp, CIRCLSEEK_LAST, SEEK_END); 
//      printk("buffer size is %d bytes\r\n",((CCAM_DMA_SIZE)<<2));
   return 0;
}
//#define CIRCLSEEK_FREE  12
//#define CIRCLSEEK_USED  13







int circbufValidPointer(int rp, struct frame_params_t ** fpp) {
  if (rp & 0x1f) {  
       MD10(printk("circbufValidPointer: misaligned pointer\n"));
       return -2;
  }
  int wp=camSeqGetJPEG_wp();
  int p= rp >> 2; // index inccam_dma_buf
  struct frame_params_t * fp;
  fp = (struct frame_params_t *) &ccam_dma_buf[X313_BUFFSUB(p, 8)]; 

 MD10(printk("rp=0x%x (0x%x), offset=0x%x\n",rp,p,(int)&ccam_dma_buf[p]-(int)fp); dumpFrameParams(fp, "in circbufValidPointer:"));

  *fpp=fp;
 MD11(printk("p=0x%x , wp==0x%x\n",p,wp));
 if (p == wp) {
     return 0; // frame not yet acquired, fp - not valid
  }
  if (fp->signffff != 0xffff) { 
     MD10(printk("circbufValidPointer: signanure overwritten\n"));
     return -1;
  }
  if ((fp->timestamp_sec) & X313_LENGTH_MASK) return 0; 
  return 1;
   
}

loff_t circbuf_lseek(struct file * file, loff_t offset, int orig) {
 //  orig 0: position from begning
 //  orig 1: relative from current
 //  orig 2: position from last  address
   int l = (CCAM_DMA_SIZE << 2);
   int fl=0;// frame length
   struct frame_params_t * fp;
   int fvld=-1;
   int rp, bp, prev_p, preprev_p; //, p;
   int nf;   
   int nz=1; 
MD12(int dbg_i);
//   int pf; // previous frame
 MD11(printk("circbuf_lseek, offset=0x%x, orig=0x%x\n",(int) offset, (int) orig));
   switch(orig) {
   case SEEK_SET:
     file->f_pos = offset;
     break;
   case SEEK_CUR:
     if (offset) file->f_pos += offset;
     else if (circbufValidPointer(file->f_pos, &fp) <0 ) return -EINVAL; 
     break;
   case SEEK_END:
     if (offset <= 0) {
        file->f_pos = l + offset;
     } else { 

        switch (offset) {
          case CIRCLSEEK_TORP:
              file->f_pos=camSeqGetJPEG_rp()<<2; 
          case CIRCLSEEK_PREV:
          case CIRCLSEEK_NEXT:
          case CIRCLSEEK_SETP:
          case CIRCLSEEK_VALID:
          case CIRCLSEEK_READY:
          case CIRCLSEEK_FREE:
          case CIRCLSEEK_USED:
             if (((fvld=circbufValidPointer(file->f_pos, &fp))) <0 )
                return -EINVAL; 
        }
        switch (offset) {
          case CIRCLSEEK_FREE:
             bp=(file->f_pos - (camSeqGetJPEG_wp()<<2));
//             return (bp>0)?bp:(bp+l); //!will return full buffer size if current pointer is a write pointer (waiting for the next frame)
             return (file->f_pos=(bp>0)?bp:(bp+l)); 
          case CIRCLSEEK_USED:
             bp=((camSeqGetJPEG_wp()<<2) - file->f_pos);
//             return (bp>=0)?bp:(bp+l); //!will return 0 if current pointer is a write pointer (waiting for the next frame)
             return (file->f_pos=(bp>0)?bp:(bp+l)); 
          case CIRCLSEEK_TORP:
             break;
          case CIRCLSEEK_TOWP:
             file->f_pos=camSeqGetJPEG_wp()<<2; // no checking if it is valid
             break;
          case CIRCLSEEK_LAST:
             file->f_pos=camSeqGetJPEG_wp()<<2;
             fvld=circbufValidPointer(file->f_pos, &fp); 
          case CIRCLSEEK_PREV:
             rp= file->f_pos >> 2;
             fl=ccam_dma_buf[X313_BUFFSUB(rp, 9)] ^ X313_LENGTH_MASK;
 MD11(printk("CIRCLSEEK_PREV: rp=0x%x, fvld=%d, fl=0x%x\n", rp, fvld,fl));
             if (fl & X313_LENGTH_MASK) {
                if (offset==CIRCLSEEK_LAST) break; // just don't move pointer, leave it at write pointer and return no error
                return -EOVERFLOW; 
             }
             bp = (X313_BUFFSUB(rp, X313_PADDED_FRAME(fl))<<2); // in bytes
 MD11(printk("CIRCLSEEK_PREV: bp=0x%x (0x%x), circbufValidPointer=%d\n", bp, bp>>2,circbufValidPointer(rp>>2, &fp)));
             if (circbufValidPointer(bp, &fp) < 0 ) { 
                if (offset==CIRCLSEEK_LAST) break; // just don't move pointer, leave it at write pointer and return no error
                return -EOVERFLOW; 
             }
             file->f_pos=bp;
             break;
          case CIRCLSEEK_NEXT:
 MD11(printk("CIRCLSEEK_NEXT: rp=0x%x, fvld=%d, fp->timestamp_sec=0x%x\n", file->f_pos >> 2, fvld, fp->timestamp_sec));
             if (fvld <=0) 
                return -EOVERFLOW; 
             file->f_pos = X313_BUFFADD(file->f_pos >> 2, X313_PADDED_FRAME(fp->timestamp_sec)) <<2 ;// do it even if the next frame does not yet exist
             break;
          case CIRCLSEEK_FIRST:
          case CIRCLSEEK_SCND:
             rp=camSeqGetJPEG_wp();
             prev_p=rp;
             preprev_p=prev_p; // for second
             nf=0;
             nz=1;
             file->f_pos=rp<<2;
             while ((((fvld=circbufValidPointer(rp<<2, &fp))) >= 0) & (nz>=0)) {
               nf++;
//               file->f_pos=rp<<2;
               preprev_p=prev_p; 
               prev_p=rp;        
               fl=ccam_dma_buf[X313_BUFFSUB(rp, 9)] ^ X313_LENGTH_MASK;
 MD11(printk("\nf=%d, rp=0x%x, fvld=%d, fl=0x%x\n",nf, rp, fvld, fl));
               if (fl & X313_LENGTH_MASK) break;  

               rp= X313_BUFFSUB(rp, X313_PADDED_FRAME(fl));
               if (rp > prev_p) nz-- ; // rolled through zero - make sure we'll not stuck in this loop forever
             }

 MD11(printk("after while{}: nf=%d, rp=0x%x, fvld=%d, fl=0x%x\n",nf, rp, fvld, fl));
             file->f_pos=((offset==CIRCLSEEK_SCND)?preprev_p:prev_p) << 2;
             break;
          case CIRCLSEEK_SETP:
             camSeqSetJPEG_rp(file->f_pos>>2);
             break;
          case CIRCLSEEK_VALID:
             break;
          case CIRCLSEEK_READY:
             if (fvld <=0) return -EINVAL; 
             break;
          case CIRCLSEEK_WAIT:
#if 0
              fvld=circbufValidPointer(file->f_pos, &fp);
              if (fvld < 0) return -ESPIPE;      
              if (fvld > 0) return file->f_pos ; 
// for (dbg_i= (file->f_pos >>2)
 MD12(printk ("\n%s:%d: before wait_event_interruptible: WP= 0x%x, file->f_pos=0x%x\n",__FILE__,__LINE__,(int)camSeqGetJPEG_wp(),(int)file->f_pos));
 MD12(for (dbg_i= 8; dbg_i>0 ;dbg_i--) printk("%08x ",(int) ccam_dma_buf[X313_BUFFSUB(file->f_pos>>2, dbg_i)]));
              wait_event_interruptible (circbuf_wait_queue,(camSeqGetJPEG_wp()<<2)!=file->f_pos);
 MD12(printk ("\n\nafter wait_event_interruptible: WP= 0x%x, file->f_pos=0x%x\n",(int)camSeqGetJPEG_wp(),(int)file->f_pos));
 MD12(for (dbg_i= 8; dbg_i>0 ;dbg_i--) printk("%08x ",(int) ccam_dma_buf[X313_BUFFSUB(file->f_pos>>2, dbg_i)]));

              return file->f_pos ; // wait over (maybe signal - anyway)
#endif

              while (((fvld=circbufValidPointer(file->f_pos, &fp)))==0) { 
                wait_event_interruptible (circbuf_wait_queue,(camSeqGetJPEG_wp()<<2)!=file->f_pos);
              }
              if (fvld < 0) return -ESPIPE;      
              return file->f_pos ; 
        }
//        if (offset==CIRCLSEEK_SCND) //! use the second oldest, not the very oldest frame
//          file->f_pos=prev_p<<2;

        return ( file->f_pos ); 
     }
     break;
   default:
      return -EINVAL;
   }
   // roll-over position
   while (file->f_pos < 0) file->f_pos+=l;
   while (file->f_pos > l) file->f_pos-=l;
   if ((orig !=SEEK_END) && (file->f_pos == l)) file->f_pos=0; 
   return  file->f_pos ;
}

ssize_t circbuf_write(struct file * file, const char * buf, size_t count, loff_t *off) {
   unsigned long p;
   char *char_pb = (char *)ccam_dma_buf;
   D(printk("circbuf_write\n"));
//   p = file->f_pos;
   p = *off;
   if(p >= (CCAM_DMA_SIZE << 2))
     p = (CCAM_DMA_SIZE << 2);
   if((p + count) > (CCAM_DMA_SIZE << 2)) { // truncate count
     count = (CCAM_DMA_SIZE << 2) - p;
   }
   if(count) {
     if(copy_from_user(&char_pb[p], buf, count))
        return -EFAULT;
//   file->f_pos+=count;
     *off += count;
   }
   return count;
}

ssize_t circbuf_read(struct file * file, char * buf, size_t count, loff_t *off) {
  unsigned long p;
  char * char_pb = (char *) ccam_dma_buf;
//  p = file->f_pos;
  p = *off;
  D(printk("circbuf_read pos=%d,count=%d, off=%d\r\n",p,count,off ));
  if (p >= (CCAM_DMA_SIZE<<2))  p = (CCAM_DMA_SIZE<<2);
  if( (p + count) > (CCAM_DMA_SIZE<<2)) { // truncate count
    count = (CCAM_DMA_SIZE<<2) - p;
  }
  if (count) {
    if (copy_to_user(buf, &char_pb[p], count)) return -EFAULT;
//    file->f_pos+=count;
    *off+=count;
  }
  return count;
}
int   circbuf_mmap   (struct file *file, struct vm_area_struct *vma) {

     int rslt;

     MD7(printk("vm_start=%lx\r\n",vma->vm_start));
     MD7(printk("vm_end=%lx\r\n",vma->vm_end));
     MD7(printk("vm_pgoff=%lx\r\n",vma->vm_pgoff));
     MD7(printk("vm_file=%lx\r\n",(unsigned long) (vma->vm_file)));
     MD7(printk("ccam_dma_buf=%lx\r\n",(unsigned long) (virt_to_phys (&ccam_dma_buf[0]))));
   /* Remap-pfn-range will mark the range VM_IO and VM_RESERVED */
     rslt=remap_pfn_range(vma,
             vma->vm_start,
//             ((unsigned long)(&ccam_dma_buf[0])) >> PAGE_SHIFT, // Should be page-aligned
             ((unsigned long) virt_to_phys(&ccam_dma_buf[0])) >> PAGE_SHIFT, // Should be page-aligned
             vma->vm_end-vma->vm_start,
             vma->vm_page_prot);

     MD7(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;
}
unsigned int circbuf_poll (struct file *file, poll_table *wait) {
     struct frame_params_t * fp;
     struct circbuf_pd * privData;
     privData = (struct circbuf_pd *) file->private_data;
     int rslt; 
 MD10(printk("circbuf_poll\n"));
     rslt= circbufValidPointer(file->f_pos, &fp);
     if        (rslt < 0) { 
 MD10(printk("circbuf_poll:invalid pointer\n"));
       return  POLLHUP ;
     } else if (rslt > 0) {
       return POLLIN | POLLRDNORM; 
     } else { 
       poll_wait(file, &circbuf_wait_queue, wait);
            if ((camSeqGetJPEG_wp()<<2)!=file->f_pos) return POLLIN | POLLRDNORM; 
    }
    return 0; // nothing ready
}



int jpeghead_open(struct inode *inode, struct file *filp) { // set filesize
  inode->i_size=JPEG_HEADER_SIZE;
//  printk("buffer size is %d bytes\r\n",((CCAM_DMA_SIZE)<<2));
  return 0;
}

loff_t  jpeghead_lseek(struct file * file, loff_t offset, int orig){
 //  orig 0: position from begning
 //  orig 1: relative from current position
 //  orig 2: position from last  address
// make it always stop DMA (needed?)
  int rp;
  struct frame_params_t * fp;

  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 = JPEG_HEADER_SIZE + offset;
     } else { 
       file->f_pos=0; // anyway reset it to 0
       rp= (offset >>2) & (~7); // convert to index to long, align to 32-bytes
       fp = (struct frame_params_t *) &ccam_dma_buf[X313_BUFFSUB(rp, 8)]; 
       if ((fp->signffff != 0xffff) || 
          ((fp->timestamp_sec) & X313_LENGTH_MASK)) return -EINVAL; 
        setJPEGHeader ((int) fp->quality, (int) fp->width, (int) fp->height);
        return ( file->f_pos ); 
     }
     break;
   default:
     return -EINVAL;
  }

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

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



ssize_t jpeghead_read(struct file * file, char * buf, size_t count, loff_t *off) {
        unsigned long p;

        D(printk("jpeghead_read\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_to_user(buf, &jpeg_header_sbuffer_ptr[p], count))
                        return -EFAULT;
//              file->f_pos+=count;
                *off += count;
        }
        return count;  
}

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

  D(printk("jpeghead_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_ptr[p],buf, count)) return -EFAULT;
//    file->f_pos+=count;
    *off+=count;
  }
  return count;  
}

static int __init circbuf_all_init(void) {
   int res;
   res = register_chrdev(CIRCBUF_MAJOR, "circbuf_operations", &circbuf_fops);
   if(res < 0) {
     printk(KERN_ERR "circbuf_all_init: couldn't get a major number %d.\n",CIRCBUF_MAJOR);
     return res;
   }
   init_waitqueue_head(&circbuf_wait_queue);
   printk(CIRCBUF_DRIVER_NAME"\r\n");
   return 0;
}


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

---