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 "fpgactrl.h"  // defines port_csp0_addr, port_csp4_addr 

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

#include "cc3x3.h"
#include "cxdma.h"
#include "x3x3.h"
#include "hist.h"
#include "fpga_io.h"

//#include "helper.h"

#define STREAM_MAJOR 127

#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_fp100s;
        unsigned long p_fpslm;
};

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_fp100s = get_imageParamsR(P_FP100S);
                ctx->p_fpslm = get_imageParamsR(P_FPSLM);
printk("P_FPSLM read == 0x%08lX\n", ctx->p_fpslm);
                ctx->p_fpslm = get_imageParamsW(P_FPSLM);
printk("P_FPSLM write == 0x%08lX\n", ctx->p_fpslm);
                set_imageParamsW(P_FP100S, arg);
                set_imageParamsW(P_FPSLM, 0x03);
                set_imageParamsR(P_FP100S, arg);
                set_imageParamsR(P_FPSLM, 0x03);
                program_sensor_exposition_just();
/*
//              program_exposure_mt9x001();
                int c = 0;
                while(program_sensor_exposition() == -1) {
                        yield();
                        c++;
                        if(c > 256)
                                break;
                }
*/
                break;
        case IOC_STREAM_GET_QTABLES:
                jpeg_set_quality(_IOC_NR(cmd), QTABLES_TABLE, (void *)&qtable[0]);
                copy_to_user((void *)arg, (void *)&qtable[0], 128);
                break;
        case IOC_STREAM_GET_TIME:
                do_gettimeofday(&sys_1);
                // read FPGA time
                port_csp0_addr[X313_WA_RTC_LATCH] = 0xFF;
                get_time_rez[2] = port_csp0_addr[X313_RA_RTC_SEC];
                get_time_rez[3] = port_csp0_addr[X313_RA_RTC_USEC];
                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) {
                        set_imageParamsR(P_FP100S, ctx->p_fp100s);
                        set_imageParamsR(P_FPSLM, ctx->p_fpslm);
                }
                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);

---