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

Go to the documentation of this file.

/*
 * Copyright (C) 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/>.
 */

#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/ext353.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 "exif.h"

#define EXT353_MAJOR 124

extern unsigned long *ccam_dma;
extern unsigned long t_sign;
//------------------------------------------------------------------------------

struct image_t image = {
        .tv_sec = 0,
        .tv_usec = 0,
};

unsigned char exif_header[] = {
        //.....PExif..MM.*.............A...b......
        0xFF,0xD8,0xFF,0xE1, 0x01,0x50,0x45,0x78, 0x69,0x66,0x00,0x00, 0x4D,0x4D,0x00,0x2A,
        0x00,0x00,0x00,0x08, 0x00,0x07,0x01,0x0E, 0x00,0x02,0x00,0x00, 0x00,0x41,0x00,0x00,
        0x00,0x62,0x01,0x0F, 0x00,0x02,0x00,0x00,

        //...................1...........2........
        0x00,0x0C,0x00,0x00, 0x00,0xA4,0x01,0x10,
        0x00,0x02,0x00,0x00, 0x00,0x07,0x00,0x00, 0x00,0xB0,0x01,0x31, 0x00,0x02,0x00,0x00,
        0x00,0x1C,0x00,0x00, 0x00,0xB8,0x01,0x32, 0x00,0x02,0x00,0x00, 0x00,0x14,0x00,0x00,

        //...;...........i..............Seq:010203
        0x00,0xD4,0x01,0x3B, 0x00,0x02,0x00,0x00, 0x00,0x12,0x00,0x00, 0x00,0xE8,0x87,0x69,
//      0x00,0x04,0x00,0x00, 0x00,0x01,0x00,0x00, 0x00,0xFA,0x00,0x00, 0x00,0x00,0x53,0x65,
        0x00,0x04,0x00,0x00, 0x00,0x01,0x00,0x00, 0x00,0xFA,0x00,0x00, 0x00,0x00,0x20,0x00,
        0x71,0x3A,0x30,0x31, 0x30,0x32,0x30,0x33,

        //04;Trig:00000001______==================
        0x30,0x34,0x3B,0x54, 0x72,0x69,0x67,0x3A,
        0x30,0x30,0x30,0x30, 0x30,0x30,0x30,0x31, 0x5F,0x5F,0x5F,0x5F, 0x5F,0x5F,0x3D,0x3D,
        0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x3D,0x3D,

        //==============..Elphel, Inc.323   ..c323
        0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x3D,0x3D, 0x3D,0x3D,0x00,0x00,
        0x45,0x6C,0x70,0x68, 0x65,0x6C,0x2C,0x20, 0x49,0x6E,0x63,0x00, 0x33,0x35,0x33,0x20,
        0x20,0x20,0x00,0x00, 0x63,0x33,0x35,0x33,

        // 6.3.3.2-01234567890AB .2007:05:31 17:10
        0x20,0x36,0x2E,0x33, 0x2E,0x33,0x2E,0x32,
        0x2D,0x30,0x31,0x32, 0x33,0x34,0x35,0x36, 0x37,0x38,0x39,0x30, 0x41,0x42,0x20,0x00,
        0x32,0x30,0x30,0x37, 0x3A,0x30,0x35,0x3A, 0x33,0x31,0x20,0x31, 0x37,0x3A,0x31,0x30,

        //:48.00:0E:64:32:30:10..............$....
        0x3A,0x34,0x38,0x00, 0x30,0x30,0x3A,0x30,
        0x45,0x3A,0x36,0x34, 0x3A,0x33,0x32,0x3A, 0x33,0x30,0x3A,0x31, 0x30,0x00,0x00,0x03,
        0x82,0x9A,0x00,0x05, 0x00,0x00,0x00,0x01, 0x00,0x00,0x01,0x24, 0x90,0x03,0x00,0x02,

        //.......,...........@............2007:05:
        0x00,0x00,0x00,0x14, 0x00,0x00,0x01,0x2C,
        0x92,0x91,0x00,0x02, 0x00,0x00,0x00,0x07, 0x00,0x00,0x01,0x40, 0x00,0x00,0x00,0x00,
        0x00,0x00,0x89,0xC4, 0x00,0x00,0x03,0xE8, 0x32,0x30,0x30,0x37, 0x3A,0x30,0x35,0x3A,

        //31 17:10:48.857266......JFIF............
        0x33,0x31,0x20,0x31, 0x37,0x3A,0x31,0x30,
        0x3A,0x34,0x38,0x00, 0x38,0x35,0x37,0x32, 0x36,0x36,0x00,0x00, 0xFF,0xE0
//      0x33,0x31,0x20,0x31, 0x37,0x3A,0x31,0x30,
//      0x3A,0x34,0x38,0x00, 0x38,0x35,0x37,0x32, 0x36,0x36,0x00,0x00, 0xFF,0xE0,0x00,0x10,
//      0x4A,0x46,0x49,0x46, 0x00,0x01,0x01,0x00, 0x00,0x01,0x00,0x01, 0x00,0x00,0xFF,0xDB,
};

int exif_header_length(void) {
        return sizeof(exif_header);
}

struct exif_desc_t exif_desc = {
        .date_time = {
                '1', '9', '7', '0', ':', '0', '1', ':', '3', '2', ' ', '2', '3', ':', '5', '9', ':', '5', '9', '\0'
        },
        .date_time_or = {
                '1', '9', '7', '0', ':', '0', '1', ':', '3', '2', ' ', '2', '3', ':', '5', '9', ':', '6', '0', '\0'
        },
        .subsec = {
                '0', '0', '0', '0', '0', '1', '\0'
        },
        .artist = {
                'M', 'A', ':', 'C', ' ', ':', 'E', 'T', ':', 'H', 'E', ':', 'R', 'N', ':', 'E', 'T', '\0'
        },
        .firmware = {
                'c', '3', '5', '3', ' ', ' ', ' ', ' ', ' ', ' ',
                ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
                ' ', ' ', ' ', ' ', ' ', ' ', ' ',
        },
        .exp = { 1, 10000 },
};

void get_image_time(unsigned long *t) {
        struct timeval tv;
        do_gettimeofday(&tv);
        t[0] = tv.tv_sec;
        t[1] = tv.tv_usec;
        unsigned long jpeg_wp = camSeqGetJPEG_wp();
        int i = 0;
//printk("system_time  == %d:%06d\n", (int) t[0], (int)t[1]);
//printk("jpeg_wp      == 0x%08X\n", (int) jpeg_wp);
//printk("ccam_dma == 0x%08X\n", (int) ccam_dma);
        for(i = 0; i < 20; i++) {
//              printk("ccam_dma[0 - %d] == 0x%08X\n", i, (int) ccam_dma[jpeg_wp - i]);
                if(ccam_dma[jpeg_wp - i] == t_sign) {
                        t[1] = ccam_dma[jpeg_wp - i - 1];
                        t[0] = ccam_dma[jpeg_wp - i - 2];
                i--;
//              printk("!!! ccam_dma[0 - %d] == 0x%08X\n", i, (int) ccam_dma[jpeg_wp - i]);
                i--;
//              printk("!!! ccam_dma[0 - %d] == 0x%08X\n", i, (int) ccam_dma[jpeg_wp - i]);
                        break;
                }
        }
//printk("FPGA_time    == %d:%06d\n\n", (int) t[0], (int) t[1]);
}

/*******************************************************************************
 *
 *
 */

static int ext353__open(struct inode *inode, struct file *filp);
static int ext353__ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
static int ext353__release(struct inode *inode, struct file *filp);
static int ext353__mmap(struct file *filp, struct vm_area_struct *vma);

static struct file_operations ext353__fops = {
        owner:          THIS_MODULE,
        open:           ext353__open,
        ioctl:          ext353__ioctl,
        mmap:           ext353__mmap,
        release:        ext353__release,
};

int ext353__open(struct inode *inode, struct file *filp) {
        return 0;
}

static int ext353__mmap(struct file *filp, struct vm_area_struct *vma) {
        struct _ext_jpeg_mmap_desc_t mdesc;
        ext_fill_jpeg_mmap_desc_(&mdesc);
        int rez = 0;
//      long off = 0;
        if(vma->vm_end - vma->vm_start == mdesc.exif_length)
                rez = remap_pfn_range(vma, vma->vm_start, ((unsigned long)mdesc.exif_start) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot);
        if(vma->vm_end - vma->vm_start == mdesc.jpeg_length)
                rez = remap_pfn_range(vma, vma->vm_start, ((unsigned long)mdesc.jpeg_start) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot);
/*
//      rez = remap_pfn_range(vma, vma->vm_start, virt_to_phys(mdesc.exif_start), mdesc.exif_length, vma->vm_page_prot);
        off += mdesc.exif_length;
        remap_pfn_range(vma, vma->vm_start + off, virt_to_phys(mdesc.jpeg_start), mdesc.jpeg_length, vma->vm_page_prot);
        off += mdesc.jpeg_length;
        remap_pfn_range(vma, vma->vm_start + off, virt_to_phys(mdesc.jpeg_start), mdesc.jpeg_length, vma->vm_page_prot);
//      int rez = remap_pfn_range(vma, vma->vm_start, virt_to_phys(b->buf) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot);
*/
        return rez;
}

static int ext353__ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) {
        int ret = 0;
        unsigned long get_time_rez[4];
        struct timeval sys_1, sys_2;
//printk("ext353 - ioctl!!!\n");
        switch(cmd) {
                case EXIF_IOC_MAC_SET: {
//printk("mac set\n");
                        copy_from_user(exif_desc.artist, (void *)arg, EXIF_ARTIST_LEN - 1);
                        break;
                }
                case EXIF_IOC_FIRMWARE_SET: {
//printk("firmware set\n");
                        copy_from_user(exif_desc.firmware, (void *)arg, EXIF_FIRMWARE_LEN - 1);
                        break;
                }
                case EXIF_IOC_TIME_SET: {
                        copy_from_user(exif_desc.date_time, (void *)arg, EXIF_DATE_TIME_LEN - 1);
//printk("time set: %s\n", exif_desc.date_time);
                        break;
                }
                case EXIF_IOC_TIME_OR_SET: {
                        copy_from_user(exif_desc.date_time_or, (void *)arg, EXIF_DATE_TIME_OR_LEN - 1);
//printk("time_or set: %s\n", exif_desc.date_time_or);
                        break;
                }
                case EXIF_IOC_SUBSEC_OR_SET: {
//printk("subsec_or set\n");
                        copy_from_user(exif_desc.subsec, (void *)arg, EXIF_SUBSEC_OR_LEN - 1);
                        break;
                }
                case EXIF_IOC_TIME_GET: {
                        unsigned long t[2];
                        get_image_time((unsigned long*) &t);
                        copy_to_user((void *)arg, (void *)t, sizeof(unsigned long) * 2);
//printk("time get: %d:%d\n", (int) t[0], (int)t[1]);
                        break;
                }
                // TODO !!!
                case EXT_JPEG_MMAP_DESC: {
                        struct ext_jpeg_mmap_desc_t mdesc;
                        ext_fill_jpeg_mmap_desc(&mdesc);
                        copy_to_user((struct ext_jpeg_mmap_desc_t *)arg, &mdesc, sizeof(struct ext_jpeg_mmap_desc_t));
                        break;
                }
                case EXT_GET_TIME_SYNC: {
                        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 ret;
}

int ext353__release(struct inode *inode, struct file *filp) {
        return 0;
}

static int __init ext353__init(void) {
        int res;

        /* register autoexposure device */
        res = register_chrdev(EXT353_MAJOR, "ext353", &ext353__fops);
        if(res < 0) {
                printk(KERN_ERR "ext353: couldn't get a major number.\n");
                return res;
        }
        return res;
}

static void __exit ext353__exit(void) {
        unregister_chrdev(EXT353_MAJOR, "ext353");
}

module_init(ext353__init);
module_exit(ext353__exit);

---