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

Go to the documentation of this file.

/*!********************************************************************************
*! FILE NAME  : histograms.c
*! DESCRIPTION: Handles histograms storage, access and percentile calculation
*! 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: histograms.c,v $
*!  Revision 1.1.1.1  2008/11/27 20:04:00  elphel
*!
*!
*!  Revision 1.17  2008/11/14 07:08:11  elphel
*!  no request for the histogram if past histogram is needed and some exist in the past
*!
*!  Revision 1.16  2008/11/13 05:40:45  elphel
*!  8.0.alpha16 - modified histogram storage, profiling
*!
*!  Revision 1.15  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.14  2008/10/28 07:04:28  elphel
*!  driver returns histogram frame number (it lags one frame from the real frame number)
*!
*!  Revision 1.13  2008/10/25 19:59:48  elphel
*!  added lseek() calls to enable/disable daemons at events (compressed frame available, any frame available, histogram-Y and histograms-C available)
*!
*!  Revision 1.12  2008/10/23 18:26:14  elphel
*!  Fixed percentile calculations in histograms
*!
*!  Revision 1.11  2008/10/23 08:05:56  elphel
*!  added 2 wait queues for histogram data - separately for G1 (used as Y for autoexposure) and other color components (for color balancing and histogram display)
*!
*!  Revision 1.10  2008/10/12 16:46:22  elphel
*!  snapshot
*!
*!  Revision 1.9  2008/10/04 16:10:12  elphel
*!  snapshot
*!
*!  Revision 1.8  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.7  2008/09/12 00:23:59  elphel
*!  removed cc353.c, cc353.h
*!
*!  Revision 1.6  2008/09/07 19:48:09  elphel
*!  snapshot
*!
*!  Revision 1.5  2008/09/05 23:20:26  elphel
*!  just a snapshot
*!
*!  Revision 1.4  2008/07/27 23:25:07  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 "fpga_io.h"//fpga_table_write_nice
#include "framepars.h"        // for debug mask

//#include "cc3x3.h"
#include "histograms.h"

#if ELPHEL_DEBUG
  #define MDF21(x) { if (GLOBALPARS(G_DEBUG) & (1 <<21)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
  #define MDF22(x) { if (GLOBALPARS(G_DEBUG) & (1 <<22)) {printk("%s:%d:%s ",__FILE__,__LINE__,__FUNCTION__);x ;} }
#else
  #define MDF21(x)
  #define MDF22(x)
#endif

#define  X3X3_HISTOGRAMS_DRIVER_NAME "Elphel (R) Model 353 Histograms device driver"

static struct histogram_stuct_t histograms[HISTOGRAM_CACHE_NUMBER] __attribute__ ((aligned (PAGE_SIZE)));

       struct histogram_stuct_t * histograms_p; // to use with mmap

wait_queue_head_t hist_y_wait_queue;    
wait_queue_head_t hist_c_wait_queue;    


struct histograms_pd {
    int                minor;
    unsigned long      frame;
    int                frame_index; 
    int                needed;
    int                wait_mode;  
    int                request_en; 
    struct wait_queue *hist_y_wait_queue;    
    struct wait_queue *hist_c_wait_queue;    

};

int        histograms_open   (struct inode *inode, struct file *file);
int        histograms_release(struct inode *inode, struct file *file);
loff_t     histograms_lseek  (struct file * file, loff_t offset, int orig);
int        histograms_mmap   (struct file *file, struct vm_area_struct *vma);
static int __init histograms_init(void);


inline void  histogram_calc_cumul       ( unsigned long * hist,        unsigned long * cumul_hist );
inline void  histogram_calc_percentiles ( unsigned long * cumul_hist,  unsigned char * percentile);


/*
   unsigned long gtab_r;
   unsigned long gtab_g;
   unsigned long gtab_gb;
   unsigned long gtab_b;

*/

void init_histograms(void) {
  unsigned long flags;
  int i;
  histograms_p=histograms;
  MDF21(printk("\n"));
  local_irq_save(flags);
  for (i=0; i < HISTOGRAM_CACHE_NUMBER; i++) {
    histograms[i].frame=0xffffffff;
    histograms[i].valid=0;
  }
  local_irq_restore(flags);
}

int set_histograms (unsigned long frame, int needed, unsigned long * gammaHash) {
//  unsigned long flags;
//hist_next_index
  int i, color_start;
  if (histograms[GLOBALPARS(G_HIST_LAST_INDEX)].frame!=frame) {
       GLOBALPARS(G_HIST_LAST_INDEX)=(GLOBALPARS(G_HIST_LAST_INDEX)+1) & (HISTOGRAM_CACHE_NUMBER-1);
       histograms[GLOBALPARS(G_HIST_LAST_INDEX)].valid=0;     
       histograms[GLOBALPARS(G_HIST_LAST_INDEX)].frame=frame; 
       memcpy (&(histograms[GLOBALPARS(G_HIST_LAST_INDEX)].gtab_r), gammaHash, 16); // copy provided 4 hash32 values
  } else {
      needed &= ~histograms[GLOBALPARS(G_HIST_LAST_INDEX)].valid; 
  }
  for (i=0; i<4; i++) if (needed & ( 1 << i )) {
    color_start= i<<8 ;
    fpga_hist_read_nice (color_start, 256, (unsigned long *) &histograms[GLOBALPARS(G_HIST_LAST_INDEX)].hist[color_start]);
    histograms[GLOBALPARS(G_HIST_LAST_INDEX)].valid |= 1 << i;
  }
  return 0;
}



int get_histograms (unsigned long frame, int needed) {
//  unsigned long flags;
//hist_next_index
  int i, color_start;
  int index=GLOBALPARS(G_HIST_LAST_INDEX);
  int raw_needed=(needed | (needed>>4) | needed>>8) & 0xf;
  for (i=0;i<HISTOGRAM_CACHE_NUMBER;i++) {
    MDF21(printk("index=%d, needed=0x%x\n",index,needed));
    if ((histograms[index].frame <= frame) && ((histograms[index].valid & raw_needed)==raw_needed)) break;
    index = (index-1) & (HISTOGRAM_CACHE_NUMBER-1);
  }
  if (i>=HISTOGRAM_CACHE_NUMBER) {
     ELP_KERR(printk("no histograms exist for requested colors (0x$%x), requested 0x%x\n",raw_needed,needed));
     return -1; 
  }
  needed &= ~0x0f; 
  MDF22(printk("needed=0x%x\n",needed));
  needed |= ((needed >>4) & 0xf0); 
  needed &= ~histograms[index].valid;
  MDF22(printk("needed=0x%x\n",needed));
  if (needed & 0xf0) { 
    for (i=0; i<4; i++) if (needed & ( 0x10 << i )) {
       color_start= i<<8 ;
       histogram_calc_cumul ( (unsigned long *) &histograms[index].hist[color_start],  (unsigned long *) &histograms[index].cumul_hist[color_start] );
       histograms[index].valid |= 0x10 << i;
    }
    MDF21(printk("needed=0x%x, valid=0x%lx\n",needed,histograms[index].valid));
  }
  if (needed & 0xf00) { 
    for (i=0; i<4; i++) if (needed & ( 0x100 << i )) {
       color_start= i<<8 ;
       histogram_calc_percentiles ( (unsigned long *) &histograms[index].cumul_hist[color_start],  (unsigned char *) &histograms[index].percentile[color_start] );
       histograms[index].valid |= 0x100 << i;
    }
    MDF21(printk("needed=0x%x, valid=0x%lx\n",needed, histograms[index].valid));
  }
  return index;
}

inline void  histogram_calc_cumul       ( unsigned long * hist,        unsigned long * cumul_hist ) {
  int i;
  cumul_hist[0]=hist[0];
  for (i=1; i<256;i++) cumul_hist[i]=cumul_hist[i-1]+hist[i];
}

inline void  histogram_calc_percentiles ( unsigned long * cumul_hist,  unsigned char * percentile) {
  unsigned long v256=0; 
  unsigned long inc_v256=cumul_hist[255];  
  int shiftl=8;
  while (inc_v256>0xffffff) { 
    inc_v256 >>= 1;
    shiftl--;
  }
  int p=0; 
  int x=0; 
  while ((p<256) && (x<256)) {
    percentile[x]=p;
    if ((p<255) && ( (cumul_hist[p] << shiftl) <= v256)) {
      p++;
    } else {
      x++;
      v256+=inc_v256;
    }
  }
}



#define HISTOGRAMS_FILE_SIZE HISTOGRAM_CACHE_NUMBER
static struct file_operations histograms_fops = {
   owner:    THIS_MODULE,
   llseek:   histograms_lseek,
   open:     histograms_open,
   mmap:     histograms_mmap,
   release:  histograms_release
};

int histograms_open(struct inode *inode, struct file *file) {
   int res;
   struct histograms_pd * privData;
   privData= (struct histograms_pd *) kmalloc(sizeof(struct histograms_pd),GFP_KERNEL);
   if (!privData) return -ENOMEM;
   file->private_data = privData;
   privData-> minor=MINOR(inode->i_rdev);
   MDF21(printk("minor=0x%x\n",privData-> minor));
   switch (privData-> minor) {
     case  CMOSCAM_MINOR_HISTOGRAMS :
        inode->i_size = HISTOGRAMS_FILE_SIZE;
        privData->frame=0xffffffff;
        privData->frame_index=-1;
        privData->needed= 0;
        privData->wait_mode=0;  
        privData->request_en=1; 
        return 0;
     default:
       kfree(file->private_data); // already allocated
       return -EINVAL;
   }
   file->f_pos = 0;
   return res;
}

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


loff_t histograms_lseek (struct file * file, loff_t offset, int orig) {
   struct histograms_pd * privData = (struct histograms_pd *) file->private_data;
   unsigned long reqAddr,reqFrame;

 MDF21(printk("offset=0x%x, orig=0x%x\n",(int) offset, (int) orig));
   switch (privData->minor) {
       case CMOSCAM_MINOR_HISTOGRAMS :
         switch(orig) {
         case SEEK_CUR: 
           offset+=(privData-> wait_mode)?GLOBALPARS(G_HIST_C_FRAME):GLOBALPARS(G_HIST_Y_FRAME);
         case SEEK_SET:
           privData->frame=offset;
           if (privData->request_en) {
             reqAddr=(privData-> wait_mode)?P_HISTRQ_C:P_HISTRQ_Y;
             reqFrame=getThisFrameNumber();
             if (offset > reqFrame) {
               if (offset > (reqFrame+5)) reqFrame+=5;
               else                       reqFrame=offset;
             }
             if ((offset < reqFrame) && 
                (((privData->frame_index = get_histograms (offset, privData->needed))) >=0)) {
                 file->f_pos=privData->frame_index;
                 return file->f_pos;
             }
             setFramePar(&framepars[reqFrame & PARS_FRAMES_MASK], reqAddr, 1);
             if (reqFrame < getThisFrameNumber()) {
               setFramePar(&framepars[getThisFrameNumber() & PARS_FRAMES_MASK], reqAddr, 1);
             }
           }
           if (privData-> wait_mode)  wait_event_interruptible (hist_c_wait_queue,GLOBALPARS(G_HIST_C_FRAME)>=offset);
           else                       wait_event_interruptible (hist_y_wait_queue,GLOBALPARS(G_HIST_Y_FRAME)>=offset);
           privData->frame_index = get_histograms (offset, privData->needed);
           if (privData->frame_index <0) {
             return -EFAULT;
           } else {
             file->f_pos=privData->frame_index;
             return file->f_pos;
           }
           break; 
         case SEEK_END:
           if (offset < 0) {
             return -EINVAL;
           } else {
             if (offset < LSEEK_HIST_NEEDED) {
               switch (offset) {
                 case 0:
                   break;
                 case  LSEEK_HIST_REQ_EN: 
                   privData->request_en=1; 
                   break;
                 case  LSEEK_HIST_REQ_DIS: 
                   privData->request_en=0;
                   break;
                 case  LSEEK_HIST_WAIT_Y: 
                   privData-> wait_mode=0;
                   break;
                 case  LSEEK_HIST_WAIT_C: 
                   privData-> wait_mode=1;
                   break;
                 default:
                   switch (offset & ~0x1f) {
                     case  LSEEK_DAEMON_HIST_Y: 
                       MDF21(printk("wait_event_interruptible (hist_y_wait_queue,0x%x & 0x%x)\n",(int) get_imageParamsThis(P_DAEMON_EN), (int) (1<<(offset & 0x1f))));
                       wait_event_interruptible (hist_y_wait_queue, get_imageParamsThis(P_DAEMON_EN) & (1<<(offset & 0x1f)));
                       break;
                     case  LSEEK_DAEMON_HIST_C: 
                       MDF21(printk("wait_event_interruptible (hist_c_wait_queue,0x%x & 0x%x)\n",(int) get_imageParamsThis(P_DAEMON_EN), (int) (1<<(offset & 0x1f))));
                       wait_event_interruptible (hist_c_wait_queue, get_imageParamsThis(P_DAEMON_EN) & (1<<(offset & 0x1f)));
                       break;
                     default:
                     return -EINVAL;
                   }
               }
             } else if (offset < (LSEEK_HIST_NEEDED + 0x10000)) {
                privData->needed= (offset & 0xffff);
             } else  {
               return -EINVAL;
             }
             file->f_pos= HISTOGRAMS_FILE_SIZE;
             return file->f_pos;
           }
           break;
         default:  
            return -EINVAL;
         } 
         return  file->f_pos ;
       default: 
         return -EINVAL;
  }
}
int histograms_mmap (struct file *file, struct vm_area_struct *vma) {
  int result;
  struct histograms_pd * privData = (struct histograms_pd *) file->private_data;
  MDF21(printk("minor=0x%x\n",privData-> minor));
     switch (privData->minor) {
       case  CMOSCAM_MINOR_HISTOGRAMS :
           result=remap_pfn_range(vma,
                  vma->vm_start,
                 ((unsigned long) virt_to_phys(histograms_p)) >> PAGE_SHIFT, 
                  vma->vm_end-vma->vm_start,
                  vma->vm_page_prot);
           MDF21(printk("remap_pfn_range returned=%x\r\n",result));
           if (result) return -EAGAIN;
           return 0;
       default: return -EINVAL;
  }
}

static int __init histograms_init(void) {
   int res;
   init_histograms();
   res = register_chrdev(HISTOGRAMS_MAJOR, "gamma_tables_operations", &histograms_fops);
   if(res < 0) {
     printk(KERN_ERR "histograms_init: couldn't get a major number %d.\n",HISTOGRAMS_MAJOR);
     return res;
   }
//   init_waitqueue_head(&histograms_wait_queue);
   init_waitqueue_head(&hist_y_wait_queue);    
   init_waitqueue_head(&hist_c_wait_queue);    
   printk(X3X3_HISTOGRAMS_DRIVER_NAME"\r\n");
   return 0;
}


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

---