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

Go to the documentation of this file.

/*!********************************************************************************
*! FILE NAME  : gamma_tables.c
*! DESCRIPTION: Handles "gamma"tables storage and scaling
*!              exposes device driver to manipulate custom "gamma" tables
*!              "Gamma" tables are calculated in several steps, leaving the
*!              exponent calculation to the application, but handling scaling inside.
*!              Scaling (with saturation if >1.0)is used for color balancing.
*!              Gamma table calulation involves several intermediate tables:
*!              - forward table
*!              - reverse table (for histogram corrections)
*!              - FPGA format
*!              And the driver caches intermediate tables when possible, calculates
*!              them when needed.
*! Copyright (C) 2008 Elphel, Inc.
*! -----------------------------------------------------------------------------**
*!
*!  This program is free software: you can redistribute it and/or modify
*!  it under the terms of the GNU General Public License as published by
*!  the Free Software Foundation, either version 3 of the License, or
*!  (at your option) any later version.
*!
*!  This program is distributed in the hope that it will be useful,
*!  but WITHOUT ANY WARRANTY; without even the implied warranty of
*!  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*!  GNU General Public License for more details.
*!
*!  You should have received a copy of the GNU General Public License
*!  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*! -----------------------------------------------------------------------------**
*!  $Log: gamma_tables.c,v $
*!  Revision 1.1.1.1  2008/11/27 20:04:01  elphel
*!
*!
*!  Revision 1.19  2008/11/13 05:40:45  elphel
*!  8.0.alpha16 - modified histogram storage, profiling
*!
*!  Revision 1.18  2008/10/29 04:18:28  elphel
*!  v.8.0.alpha10 made a separate structure for global parameters (not related to particular frames in a frame queue)
*!
*!  Revision 1.17  2008/10/25 19:51:06  elphel
*!  Changed word order in writes to gamma tables driver
*!
*!  Revision 1.16  2008/10/23 08:04:19  elphel
*!  reenabling IRQ in debug mode
*!
*!  Revision 1.15  2008/10/12 16:46:22  elphel
*!  snapshot
*!
*!  Revision 1.14  2008/10/06 08:31:08  elphel
*!  snapshot, first images
*!
*!  Revision 1.13  2008/10/05 05:13:33  elphel
*!  snapshot003
*!
*!  Revision 1.12  2008/10/04 16:10:12  elphel
*!  snapshot
*!
*!  Revision 1.11  2008/09/22 22:55:48  elphel
*!  snapshot
*!
*!  Revision 1.10  2008/09/20 00:29:50  elphel
*!  moved driver major/minor numbers to a single file - include/asm-cris/elphel/driver_numbers.h
*!
*!  Revision 1.9  2008/09/19 04:37:25  elphel
*!  snapshot
*!
*!  Revision 1.8  2008/09/16 00:49:32  elphel
*!  snapshot
*!
*!  Revision 1.7  2008/09/12 00:23:59  elphel
*!  removed cc353.c, cc353.h
*!
*!  Revision 1.6  2008/09/11 01:05:32  elphel
*!  snapshot
*!
*!  Revision 1.5  2008/09/05 23:20:26  elphel
*!  just a snapshot
*!
*!  Revision 1.4  2008/07/27 04:27:49  elphel
*!  next snapshot
*!
*!  Revision 1.3  2008/06/16 06:51:21  elphel
*!  work in progress, intermediate commit
*!
*!  Revision 1.2  2008/06/10 00:02:42  elphel
*!  fast calculation of 8-bit reverse functions for "gamma" tables and histograms
*!
*!  Revision 1.1  2008/06/08 23:46:45  elphel
*!  added drivers files for handling quantization tables, gamma tables and the histograms
*!
*!
*/

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

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

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

#include <asm/irq.h>

#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm/elphel/driver_numbers.h>
#include <asm/elphel/c313a.h>
#include <asm/elphel/exifa.h>
#include "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr 
#include "framepars.h"        // for debug mask

//#include "fpga_io.h"//fpga_table_write_nice

//#include "cc3x3.h"
//#include "x3x3.h" // just for FPGA_NQTAB

//#include "framepars.h"
//#include "quantization_tables.h"
#include "gamma_tables.h"
#if ELPHEL_DEBUG
  #define MDF(x) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;}
  #define D10(x) { if (GLOBALPARS(G_DEBUG) & (1 <<10)) { x ;} }
//  #define MDD1(x) printk("%s:%d:",__FILE__,__LINE__); x ; udelay (ELPHEL_DEBUG_DELAY)
  #define MDF10(x) { if (GLOBALPARS(G_DEBUG) & (1 <<10)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
  #define MDF11(x) { if (GLOBALPARS(G_DEBUG) & (1 <<11)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }

//  #define MDD1(x)
  #define D1I(x) x

#else
  #define MDF(x)
  #define D10(x)
  #define D1I(x) x
  #define MDF10(x)
  #define MDF11(x)


#endif

#define  X3X3_GAMMAS_DRIVER_NAME "Elphel (R) Model 353 Gamma Tables device driver"

#define GAMMA_THRESH (GAMMA_CACHE_NUMBER/16)

static struct gamma_stuct_t gammas[GAMMA_CACHE_NUMBER] __attribute__ ((aligned (PAGE_SIZE)));
       struct gamma_stuct_t * gammas_p; 

struct gammas_pd {
    int                minor;
    unsigned short     scale;
    unsigned short     hash16;
    unsigned char      mode;
    unsigned char      color;
};

int        gammas_open   (struct inode *inode, struct file *file);
int        gammas_release(struct inode *inode, struct file *file);
loff_t     gammas_lseek  (struct file * file, loff_t offset, int orig);
ssize_t    gammas_write  (struct file * file, const char * buf, size_t count, loff_t *off);
int        gammas_mmap   (struct file *file, struct vm_area_struct *vma);
static int __init gammas_init(void);


inline void remove_from_nonscaled(int index) {
    gammas[gammas[index].newer_non_scaled].older_non_scaled=gammas[index].older_non_scaled;
    gammas[gammas[index].older_non_scaled].newer_non_scaled=gammas[index].newer_non_scaled;
    gammas[0].non_scaled_length--;
}

inline void remove_from_scaled   (int index) {
    if (likely(gammas[index].newer_scaled)) { 
     gammas[gammas[index].newer_scaled].older_scaled=gammas[index].older_scaled;
     gammas[gammas[index].older_scaled].newer_scaled=gammas[index].newer_scaled;
    }
}

inline void remove_from_all      (int index) { 
    gammas[gammas[index].newer_all].older_all=gammas[index].older_all;
    gammas[gammas[index].older_all].newer_all=gammas[index].newer_all;
}

inline void insert_first_nonscaled(int index) {
  MDF11(printk("index=%d\n",index));
    gammas[gammas[0].newest_non_scaled].newer_non_scaled= index; // 1 ==[0].oldest_non_scaled
    gammas[index].older_non_scaled=  gammas[0].newest_non_scaled; // 4
    gammas[0].newest_non_scaled=index; // 5
    gammas[index].newer_non_scaled=0; // 6
    gammas[0].non_scaled_length++;
    gammas[index].this_non_scaled=0; // none
    gammas[index].newest_scaled=index; 
    gammas[index].oldest_scaled=index; 

}

inline void insert_first_scaled   (int non_scaled, int index) {
  MDF11(printk("non_scaled=%d, index=%d\n",non_scaled, index));
    gammas[index].older_scaled=     gammas[non_scaled].newest_scaled; //4
    gammas[gammas[non_scaled].newest_scaled].newer_scaled= index; //1
//    gammas[index].older_scaled=     gammas[non_scaled].newest_scaled; //4

    gammas[index].newer_scaled= non_scaled; //6
    gammas[non_scaled].newest_scaled=     index; //5
//    gammas[index].newer_scaled= non_scaled; //6
    gammas[index].this_non_scaled=non_scaled;
}

inline void insert_first_all      (int index) {
    gammas[gammas[0].newest_all].newer_all= index; //1
    gammas[index].older_all=     gammas[0].newest_all; //4
    gammas[0].newest_all=         index; //5
    gammas[index].newer_all= 0; //6
}

void init_gammas(void) {
  unsigned long flags;
  int i;
  gammas_p=gammas;
  local_irq_save(flags);
  gammas[0].oldest_non_scaled=0;
  gammas[0].newest_non_scaled=0;
  gammas[0].oldest_all=GAMMA_CACHE_NUMBER-1;
  gammas[0].newest_all=1;
  MDF10(printk("\n"));
  for (i=1; i < GAMMA_CACHE_NUMBER;i++) {
    gammas[i].this_non_scaled=-1; 

    gammas[i].newer_all=i-1;
    gammas[i].older_all= (i==(GAMMA_CACHE_NUMBER-1))? 0: (i+1);
    gammas[i].locked=0;
    gammas[i].valid=0;
  }
  gammas[0].non_scaled_length=0;
  for (i=1; i < 4;i++) {
    gammas[0].locked_color[i]=0;
  }
  local_irq_restore(flags);
}


int is_gamma_current (unsigned short hash16, unsigned short scale, int index) {
  return ((gammas[index].hash16 == hash16) && (gammas[index].scale == scale))?1:0;
}

int is_gamma_valid (unsigned short hash16, unsigned short scale, int index) {
  return ((gammas[index].hash16 == hash16) && (gammas[index].scale == scale) && (gammas[index].valid != 0))?1:0;
}


unsigned long get_locked_hash32(int color) {
  int index=gammas[0].locked_color[color];
  return index?gammas[index].hash32:0;
}

inline void lock_gamma_node (int index, int color) {
  int tmp_p;
  if (likely((color<4) && (color >=0))) { 
    if (((tmp_p=gammas[0].locked_color[color]))!=0) { 
      gammas[tmp_p].locked &= ~(1 << color); 
    }
    gammas[0].locked_color[color]= index;
    gammas[index].locked |= (1 << color);
  }
}
int unlock_gamma_node (int color) {
  unsigned long flags;
  int index;
  MDF11(printk("color=0x%x\n",color));
  if (unlikely((color>= 4) || (color<0))) return -1;
  local_irq_save(flags);
  index =gammas[0].locked_color[color];
  if (index) {
    gammas[index].locked &= ~(1 <<  color); 
    gammas[0].locked_color[color]=0;
  }
  local_irq_restore(flags);
  return index;
}
unsigned long * get_gamma_fpga(int color) { 
  int index;
  if (unlikely((color>=4) || (color<0))) return NULL; //
  index =gammas[0].locked_color[color];
  MDF11(printk(" index=%d(0x%x)\n",index,index));
  if (index) return gammas[index].fpga;
  else return NULL;
}


int gamma_new_node(void) {
   int tmp_p;
   if ((gammas[0].non_scaled_length > GAMMA_THRESH) && (gammas[gammas[0].oldest_non_scaled].newest_scaled == gammas[0].oldest_non_scaled)) { 

    tmp_p=gammas[0].oldest_non_scaled;
     remove_from_nonscaled(tmp_p);
   } else { 
    tmp_p=gammas[0].oldest_all;
    while ((tmp_p!=0) && gammas[tmp_p].locked) tmp_p=gammas[tmp_p].newer_all;
    if (tmp_p==0) return 0; // none (unlocked) nodes are found
    remove_from_all   (tmp_p);
    remove_from_scaled   (tmp_p);
   }
   gammas[tmp_p].valid=0;
   return tmp_p;
}

void gamma_encode_fpga(unsigned short * gamma_in, unsigned long * gamma_out) {
  int i,base,diff;
  MDF11(printk("\n"));
  for (i=0;i<256;i++) {
    base=(gamma_in[i] >> 6);
    diff=(gamma_in[i+1] >> 6);
    diff-=base;
    if ((diff>63) || (diff < -64)) {
      diff=(diff+8)>>4;
      gamma_out[i]=(base & 0x3ff) | ((diff & 0x7f) << 10) | (1 << 17);
    } else {
      gamma_out[i]=(base & 0x3ff) | ((diff & 0x7f) << 10);
    }
  }
}

void  gamma_calc_scaled (unsigned short scale,unsigned short * gamma_in, unsigned short * gamma_out) {
  int i;
  unsigned long d;
  unsigned long max_scaled=0xffff << GAMMA_SCALE_SHIFT;
  MDF11(printk("\n"));
  for (i=0; i<257; i++) {
    d= ((unsigned long) scale ) * ((unsigned long) gamma_in[i] ) + (1 <<(GAMMA_SCALE_SHIFT-1)); 
    if (d>max_scaled) d=max_scaled;
    gamma_out[i]=d >> GAMMA_SCALE_SHIFT;
  }
}

void  gamma_calc_reverse(unsigned short * gamma_in, unsigned char * gamma_out) {
  unsigned long gcurr=0; 
  int r=0; 
  int x=0; 
  MDF11(printk("\n"));
  while ((r<256) && (x<256)) {
    gamma_out[x]=r;
//    if ((r<255) && (( gamma_in[r]<<8) <= gcurr)) {
    if ((r<255) && ( gamma_in[r] <= gcurr)) {
      r++;
    } else {
      x++;
      gcurr+=256;
    }
  }
}

//#define GAMMA_MODE_LOCK         8  // Lock the table for the specified color (used from irq/tasklet - it is needed because all 4 tables in FPGA have to be overwritten at once)
int set_gamma_table (unsigned short hash16, unsigned short scale, unsigned short * gamma_proto,  unsigned char mode, int color) {
  D1I(unsigned long flags);
  int tmp_p, tmp_p1; //,tmp_p0;
  unsigned short gamma_linear[257]=
      {0x0000,0x0100,0x0200,0x0300,0x0400,0x0500,0x0600,0x0700,0x0800,0x0900,0x0a00,0x0b00,0x0c00,0x0d00,0x0e00,0x0f00,
       0x1000,0x1100,0x1200,0x1300,0x1400,0x1500,0x0600,0x1700,0x1800,0x1900,0x1a00,0x1b00,0x1c00,0x1d00,0x1e00,0x1f00,
       0x2000,0x2100,0x2200,0x2300,0x2400,0x2500,0x0600,0x2700,0x2800,0x2900,0x2a00,0x2b00,0x2c00,0x2d00,0x2e00,0x2f00,
       0x3000,0x3100,0x3200,0x3300,0x3400,0x3500,0x0600,0x3700,0x3800,0x3900,0x3a00,0x3b00,0x3c00,0x3d00,0x3e00,0x3f00,
       0x4000,0x4100,0x4200,0x4300,0x4400,0x4500,0x0600,0x4700,0x4800,0x4900,0x4a00,0x4b00,0x4c00,0x4d00,0x4e00,0x4f00,
       0x5000,0x5100,0x5200,0x5300,0x5400,0x5500,0x0600,0x5700,0x5800,0x5900,0x5a00,0x5b00,0x5c00,0x5d00,0x5e00,0x5f00,
       0x6000,0x6100,0x6200,0x6300,0x6400,0x6500,0x0600,0x6700,0x6800,0x6900,0x6a00,0x6b00,0x6c00,0x6d00,0x6e00,0x6f00,
       0x7000,0x7100,0x7200,0x7300,0x7400,0x7500,0x0600,0x7700,0x7800,0x7900,0x7a00,0x7b00,0x7c00,0x7d00,0x7e00,0x7f00,
       0x8000,0x8100,0x8200,0x8300,0x8400,0x8500,0x0600,0x8700,0x8800,0x8900,0x8a00,0x8b00,0x8c00,0x8d00,0x8e00,0x8f00,
       0x9000,0x9100,0x9200,0x9300,0x9400,0x9500,0x0600,0x9700,0x9800,0x9900,0x9a00,0x9b00,0x9c00,0x9d00,0x9e00,0x9f00,
       0xa000,0xa100,0xa200,0xa300,0xa400,0xa500,0x0600,0xa700,0xa800,0xa900,0xaa00,0xab00,0xac00,0xad00,0xae00,0xaf00,
       0xb000,0xb100,0xb200,0xb300,0xb400,0xb500,0x0600,0xb700,0xb800,0xb900,0xba00,0xbb00,0xbc00,0xbd00,0xbe00,0xbf00,
       0xc000,0xc100,0xc200,0xc300,0xc400,0xc500,0x0600,0xc700,0xc800,0xc900,0xca00,0xcb00,0xcc00,0xcd00,0xce00,0xcf00,
       0xf000,0xd100,0xd200,0xd300,0xd400,0xd500,0x0600,0xd700,0xd800,0xd900,0xda00,0xdb00,0xdc00,0xdd00,0xde00,0xdf00,
       0xe000,0xe100,0xe200,0xe300,0xe400,0xe500,0x0600,0xe700,0xe800,0xe900,0xea00,0xeb00,0xec00,0xed00,0xee00,0xef00,
       0xf000,0xf100,0xf200,0xf300,0xf400,0xf500,0x0600,0xf700,0xf800,0xf900,0xfa00,0xfb00,0xfc00,0xfd00,0xfe00,0xff00,
       0xffff};
  MDF10(printk("hash16=0x%x scale=0x%x gamma_proto=0x%x mode =0x%x color=%x\n", (int) hash16, (int) scale, (int) gamma_proto,  (int) mode,  color));

  if (!gamma_proto & (hash16==0)) {
    gamma_proto=gamma_linear;
    MDF10(printk("Using linear table\n"));
  } else {
    MDF10(printk("Using non-linear table\n")); 
  }
  D1I(local_irq_save(flags));
  tmp_p=gammas[0].newest_non_scaled;

  MDF10(printk("gammas[0].oldest_all=%d\n", gammas[0].oldest_all)); 

  MDF10(printk("gammas[0].newest_all=%d\n", gammas[0].newest_all));
  MDF10(printk("tmp_p=0x%x gammas[tmp_p].hash16=0x%x hash16=0x%x\n", tmp_p, (int) gammas[tmp_p].hash16, (int) hash16 ));
  while ((tmp_p!=0) && (gammas[tmp_p].hash16 != hash16)) {
    D10(printk(" --tmp_p=0x%x\n", tmp_p)); 
    tmp_p=gammas[tmp_p].older_non_scaled;
  }
  MDF10(printk("tmp_p=0x%x\n", tmp_p)); 

  if (tmp_p == 0) { 
    MDF10(printk("Need new table\n")); 
    if (!gamma_proto) { //
      D1I(local_irq_restore(flags));
      MDF10(printk("matching hash not found, new table is not provided\n")); 
      return 0;   
    }
    tmp_p=gamma_new_node();
    MDF10(printk("tmp_p=0x%x\n gamma_proto= 0x%x 0x%x 0x%x 0x%x\n", tmp_p, (int) gamma_proto[0], (int) gamma_proto[1], (int) gamma_proto[2], (int) gamma_proto[3]));
    if (unlikely(!tmp_p)) { 
      D1I(local_irq_restore(flags));
      return 0;   
    }
    gammas[tmp_p].hash16=hash16;
    gammas[tmp_p].scale=0;
    gammas[tmp_p].oldest_scaled=tmp_p;  
    gammas[tmp_p].newest_scaled=tmp_p;  
    if ((mode & GAMMA_MODE_NOT_NICE)==0) {
      D1I(local_irq_restore(flags));
      MDF10(printk("Interrupts reenabled, tmp_p=0x%x\n", tmp_p));
      D1I(local_irq_save(flags));
      if (unlikely(!is_gamma_current (hash16, 0, tmp_p))) {
        D1I(local_irq_restore(flags));
        return 0;   
      }
    }
//    memcpy ((void *)...
    memcpy (gammas[tmp_p].direct, gamma_proto, 257*2) ; 
    gammas[tmp_p].valid |= GAMMA_VALID_MASK;
    MDF10(printk("insert_first_nonscaled(0x%x)\n", tmp_p));
    insert_first_nonscaled(tmp_p);

  } else  if (gammas[tmp_p].newer_non_scaled !=0) { 
    MDF10(printk("remove_from_nonscaled (0x%x)\n", tmp_p)); 
    remove_from_nonscaled (tmp_p);
    MDF10(printk("insert_first_nonscaled (0x%x)\n", tmp_p));
    insert_first_nonscaled(tmp_p);
  }
  MDF10(printk("0x%x\n", tmp_p)); 


  if (scale==0) {
    D1I(local_irq_restore(flags));
    return tmp_p;   
  }
  tmp_p1=gammas[tmp_p].newest_scaled;
  MDF10(printk("tmp_p1=0x%x\n", tmp_p1));  
//  while ((tmp_p1!=0) && (gammas[tmp_p1].scale != scale)){ ///FIXME: got stuck here
  while ((tmp_p1!=tmp_p) && (gammas[tmp_p1].scale != scale)){ 
    D10(printk(" >>tmp_p1=0x%x)\n", tmp_p1));
    tmp_p1=gammas[tmp_p1].older_scaled;
  }
//  if (tmp_p1 == 0) { /// no luck
  if (tmp_p1 == tmp_p) { 
    MDF10(printk("create new scaled table\n"));
    tmp_p1=gamma_new_node();
    if (unlikely(!tmp_p1)) { 
      D1I(local_irq_restore(flags));
      return 0;   
    }
    gammas[tmp_p1].hash16=hash16;
    gammas[tmp_p1].scale= scale;
    insert_first_scaled   (tmp_p, tmp_p1);
    insert_first_all (tmp_p1);
    if ((mode & GAMMA_MODE_NOT_NICE)==0) {
      D1I(local_irq_restore(flags));
      D1I(local_irq_save(flags));
      if (unlikely(!is_gamma_current (hash16, scale, tmp_p1))) {
        D1I(local_irq_restore(flags));
        return 0;   
      }
    }
  } else { 
    MDF10(printk("reuse scaled table\n"));
    if (gammas[tmp_p1].newer_scaled != tmp_p) { 
      remove_from_scaled    (tmp_p1);
      insert_first_scaled   (tmp_p, tmp_p1);
    }
    if (gammas[tmp_p1].newer_all != 0) { 
      remove_from_all       (tmp_p1);
      insert_first_all      (tmp_p1);
    }
  }
  if ((gammas[tmp_p1].valid & GAMMA_VALID_MASK) == 0) {
    gamma_calc_scaled (scale, gammas[tmp_p].direct, gammas[tmp_p1].direct);
    gammas[tmp_p1].valid |= GAMMA_VALID_MASK;
  }
  if (mode & GAMMA_MODE_HARDWARE) {
    if ((gammas[tmp_p1].valid & GAMMA_FPGA_MASK)==0) {
      gamma_encode_fpga(gammas[tmp_p1].direct, gammas[tmp_p1].fpga);
      gammas[tmp_p1].valid |= GAMMA_FPGA_MASK;
    }
  }
  if (mode & GAMMA_MODE_LOCK) {
    lock_gamma_node (tmp_p1, color);
  }
  if (mode & GAMMA_MODE_NEED_REVERSE) {
    if ((gammas[tmp_p1].valid & GAMMA_VALID_REVERSE)==0) {
      if ((mode & GAMMA_MODE_NOT_NICE)==0) {
        D1I(local_irq_restore(flags));
        D1I(local_irq_save(flags));
        if (unlikely(!is_gamma_current (hash16, 0, tmp_p))) {
          D1I(local_irq_restore(flags));
          return 0;   
        }
      }
      gamma_calc_reverse(gammas[tmp_p1].direct, gammas[tmp_p1].reverse);
      gammas[tmp_p1].valid |= GAMMA_VALID_REVERSE;
    }
  }
  D1I(local_irq_restore(flags));
  MDF10(printk("- return %d\n",tmp_p1));
  return tmp_p1;
}



//#define LSEEK_GAMMA_INIT        1 // SEEK_END LSEEK_GAMMA_INIT to initialize all the gamma data structures
//#define LSEEK_GAMMA_ISCURRENT   2 // SEEK_END to check if the selected node(pointed by file pointer) is current - returns 0 if not, otherwise - node index
#define GAMMA_FILE_SIZE GAMMA_CACHE_NUMBER
static struct file_operations gammas_fops = {
   owner:    THIS_MODULE,
   llseek:   gammas_lseek,
   write:    gammas_write,
   open:     gammas_open,
   mmap:     gammas_mmap,
   release:  gammas_release
};
int gammas_open(struct inode *inode, struct file *file) {
   int res;
   struct gammas_pd * privData;
   privData= (struct gammas_pd *) kmalloc(sizeof(struct gammas_pd),GFP_KERNEL);
  MDF10(printk("gammas[0].oldest_all=%d\n", gammas[0].oldest_all));
  MDF10(printk("gammas[0].newest_all=%d\n", gammas[0].newest_all));
   if (!privData) return -ENOMEM;
   file->private_data = privData;
   privData-> minor=MINOR(inode->i_rdev);
   MDF10(printk("gammas_open, minor=0x%x\n",privData-> minor));
   switch (privData-> minor) {
     case CMOSCAM_MINOR_GAMMAS :
        inode->i_size = GAMMA_FILE_SIZE;
        privData-> scale= 0;
        privData-> hash16=0;
        privData-> mode= 0;
        return 0;
     default:
       kfree(file->private_data); 
       return -EINVAL;
   }
   file->f_pos = 0;
   return res;
}

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


loff_t gammas_lseek (struct file * file, loff_t offset, int orig) {
   struct gammas_pd * privData = (struct gammas_pd *) file->private_data;
   MDF10(printk("offset=0x%x, orig=0x%x, file->f_pos=0x%x\n",(int) offset, (int) orig, (int) file->f_pos));
   switch (privData->minor) {
       case CMOSCAM_MINOR_GAMMAS :
         switch(orig) {
         case SEEK_SET:
           file->f_pos = offset;
           break;
         case SEEK_CUR:
//     file->f_pos = getThisFrameNumber() + offset;
           break;
         case SEEK_END:
           if (offset < 0) {
              break;
           } else if (offset == 0) {
              file->f_pos=GAMMA_CACHE_NUMBER;
              break;
           } else {
             switch (offset) {
             case LSEEK_GAMMA_INIT:
                init_gammas();
                file->f_pos=0;
                break;
             case LSEEK_GAMMA_ISCURRENT:
               if (file->f_pos==0) break; 
               if (!is_gamma_current (privData->hash16, privData->scale, (int) file->f_pos)) file->f_pos=0;
               break;
             default: 
               return -EINVAL;
             }
           break;
           }
         default:  
            return -EINVAL;
         } 
   MDF10(printk("file->f_pos=0x%x\n",(int) file->f_pos));
         return  file->f_pos ;
       default: 
         return -EINVAL;
  }
}

ssize_t gammas_write(struct file * file, const char * buf, size_t count, loff_t *off) {
   struct gammas_pd * privData = (struct gammas_pd *) file->private_data;
   struct {
     unsigned short scale;
     unsigned short hash16;
     unsigned char  mode;
     unsigned char  color;
     unsigned short gamma[257];
   } data;

   int     head,   result;
   unsigned short * gamma= data.gamma;
   MDF10(printk(" file->f_pos=0x%x, *off=0x%x\n", (int) file->f_pos, (int) *off));
   switch (privData->minor) {
       case CMOSCAM_MINOR_GAMMAS :
         if (count>sizeof (data)) count = sizeof (data);
         if(count) {
           if(copy_from_user((char *) &data, buf, count))  return -EFAULT;
           head=6;
           if ((count-head) < (2 * 257)) gamma=NULL; 
           if (head>count) head=count;
           memcpy (&(privData->scale),&(data.scale),head);
  MDF10(printk("count=%d, head=%d, hash16=0x%x scale=0x%x mode=0x%x color=%x\n", count, head, (int) data.hash16, (int) data.scale,  (int) data.mode,  (int) data.color));
  MDF10(printk("count=%d, head=%d, hash16=0x%x scale=0x%x mode=0x%x color=%x\n", count, head, (int) privData->hash16, (int) privData->scale,  (int) privData->mode,  (int) privData->color));
           result=set_gamma_table (privData->hash16, privData->scale, gamma,  privData->mode, ( privData->color >> 3) & 3);
           *off= (result>0)?result:0;
         } else *off=0;
   MDF10(printk("file->f_pos=0x%x\n", (int) *off));
         return (*off) ? count: 0; 
       default:                           return -EINVAL;
  }
}

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

static int __init gammas_init(void) {
   int res;
   printk ("Starting "X3X3_GAMMAS_DRIVER_NAME" - %d \n",GAMMAS_MAJOR);
   init_gammas();
   MDF10(printk("set_gamma_table (0, GAMMA_SCLALE_1, NULL,  0, 0)\n"); udelay (ELPHEL_DEBUG_DELAY));
   set_gamma_table (0, GAMMA_SCLALE_1, NULL,  0, 0); 


   res = register_chrdev(GAMMAS_MAJOR, "gamma_tables_operations", &gammas_fops);
   if(res < 0) {
     printk(KERN_ERR "\ngammas_init: couldn't get a major number %d.\n",GAMMAS_MAJOR);
     return res;
   }
//   init_waitqueue_head(&gammas_wait_queue);
   printk(X3X3_GAMMAS_DRIVER_NAME" - %d \n",GAMMAS_MAJOR);
   return 0;
}


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

---