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

Go to the documentation of this file.

/*
 * stream faked device for some io controls
 *
 *  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/>.
 *
 * Copyright (C) 2005-2008 Elphel, Inc
 *
 * Author: Mykhailo Malyshko <spectr@gmail.com>
 *
 */




#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
//#include <linux/tqueue.h>
#include <linux/wait.h>

#include <asm/unistd.h>
#include <asm/semaphore.h>
//#include <asm/smplock.h>
#include <asm/atomic.h>

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/mm.h>
//#include <linux/iobuf.h>
//#include <linux/compatmac.h>
#include <linux/vmalloc.h>
#include <linux/rwsem.h>

#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <asm/io.h>
#include <asm/atomic.h>
#include <asm/page.h>
//#include <linux/wrapper.h>


#include <asm/elphel/driver_numbers.h>
#include <asm/elphel/c313a.h>
#include <asm/elphel/hist.h>
#include <asm/elphel/autoexp.h>

#include "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr // just for the FPGA time
#include "quantization_tables.h" // get_gtables()

//#include "cc3x3.h"
#include "framepars.h"
#include "cxdma.h"
#include "jpeghead.h"
#include "x3x3.h"
//#include "hist.h"
#include "fpga_io.h"

//#include "helper.h"


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



/*******************************************************************************
 *
 * "stream" - faked device, for controlling instances of streamer, and running status
 *
 */

DECLARE_MUTEX(stream_lock);
static int stream__open(struct inode *inode, struct file *filp);
static int stream__ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
static int stream__release(struct inode *inode, struct file *filp);

static struct file_operations stream__fops = {
        owner:          THIS_MODULE,
        open:           stream__open,
        ioctl:          stream__ioctl,
        release:        stream__release,
};

struct stream_ctx_t {
        int fps_flag;
        unsigned long p_fp1000slim;
        unsigned long p_fpsflags;
};

int stream__open(struct inode *inode, struct file *filp) {
        filp->private_data = NULL;
        if(down_trylock(&stream_lock)) {
//              printk("/dev/stream: open() - fail, busy\r\n");
                return -EBUSY;
        }
//      printk("/dev/stream: open()\r\n");
        // init context
        filp->private_data = (struct stream_ctx_t *)kmalloc(sizeof(struct stream_ctx_t), GFP_ATOMIC);
        struct stream_ctx_t *ctx = (struct stream_ctx_t *)filp->private_data;
        ctx->fps_flag = 0;
        return 0;
}

static int stream__ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) {
//      unsigned char *qtable[128];
        struct stream_ctx_t *ctx = (struct stream_ctx_t *)filp->private_data;
        unsigned long get_time_rez[4];
        struct timeval sys_1, sys_2;

        switch(_IOC_TYPE(cmd)) {
        case IOC_STREAM_SET_FPS:
                ctx->fps_flag = 1;
                ctx->p_fp1000slim = get_imageParamsThis(P_FP1000SLIM);
                ctx->p_fpsflags = get_imageParamsThis(P_FPSFLAGS);
               setFramePar(&framepars[getThisFrameNumber() & PARS_FRAMES_MASK], P_FP1000SLIM,  arg);
               setFramePar(&framepars[getThisFrameNumber() & PARS_FRAMES_MASK], P_FPSFLAGS,  3); 

                break;


        case IOC_STREAM_GET_TIME:
                do_gettimeofday(&sys_1);
                // read FPGA time
                X313_GET_FPGA_TIME(get_time_rez[2], get_time_rez[3] );

                do_gettimeofday(&sys_2);
                unsigned long delta;
                if(sys_2.tv_sec != sys_1.tv_sec)
                        sys_2.tv_usec += 1000000;
                delta = sys_2.tv_usec - sys_1.tv_usec;
                sys_1.tv_usec += delta / 2;
                if(sys_1.tv_usec >= 1000000) {
                        sys_1.tv_usec -= 1000000;
                        sys_1.tv_sec -= 1;
                }
                get_time_rez[0] = sys_1.tv_sec;
                get_time_rez[1] = sys_1.tv_usec;
                copy_to_user((void *)arg, (void *)&get_time_rez[0], 4 * sizeof(unsigned long));
                break;
        }
        return 0;
}

int stream__release(struct inode *inode, struct file *filp) {
        if(filp->private_data != NULL) {
                struct stream_ctx_t *ctx = (struct stream_ctx_t *)filp->private_data;
                // release context
                if(ctx->fps_flag) {
                   setFramePar(&framepars[getThisFrameNumber() & PARS_FRAMES_MASK], P_FP1000SLIM,  ctx->p_fp1000slim);
                   setFramePar(&framepars[getThisFrameNumber() & PARS_FRAMES_MASK], P_FPSFLAGS,  ctx->p_fpsflags);

                }
                kfree(filp->private_data);
        }
//      printk("/dev/stream: release()\r\n");
        up(&stream_lock);
        return 0;
}


/*******************************************************************************
 *
 * init
 */

static int __init stream__init(void) {
        int res = register_chrdev(STREAM_MAJOR, "stream", &stream__fops);
        return res;
}

static void __exit stream__exit(void) {
        unregister_chrdev(STREAM_MAJOR, "stream");
}

module_init(stream__init);
module_exit(stream__exit);

---