Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Motion Eye video4linux driver for Sony Vaio PictureBook
0004  *
0005  * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
0006  *
0007  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
0008  *
0009  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
0010  *
0011  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
0012  *
0013  * Some parts borrowed from various video4linux drivers, especially
0014  * bttv-driver.c and zoran.c, see original files for credits.
0015  */
0016 #include <linux/module.h>
0017 #include <linux/pci.h>
0018 #include <linux/sched.h>
0019 #include <linux/init.h>
0020 #include <linux/gfp.h>
0021 #include <linux/videodev2.h>
0022 #include <media/v4l2-common.h>
0023 #include <media/v4l2-device.h>
0024 #include <media/v4l2-ioctl.h>
0025 #include <media/v4l2-fh.h>
0026 #include <media/v4l2-event.h>
0027 #include <linux/uaccess.h>
0028 #include <asm/io.h>
0029 #include <linux/delay.h>
0030 #include <linux/interrupt.h>
0031 #include <linux/vmalloc.h>
0032 #include <linux/dma-mapping.h>
0033 
0034 #include "meye.h"
0035 #include <linux/meye.h>
0036 
0037 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
0038 MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
0039 MODULE_LICENSE("GPL");
0040 MODULE_VERSION(MEYE_DRIVER_VERSION);
0041 
0042 /* number of grab buffers */
0043 static unsigned int gbuffers = 2;
0044 module_param(gbuffers, int, 0444);
0045 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
0046 
0047 /* size of a grab buffer */
0048 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
0049 module_param(gbufsize, int, 0444);
0050 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400 (will be rounded up to a page multiple)");
0051 
0052 /* /dev/videoX registration number */
0053 static int video_nr = -1;
0054 module_param(video_nr, int, 0444);
0055 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
0056 
0057 /* driver structure - only one possible */
0058 static struct meye meye;
0059 
0060 /****************************************************************************/
0061 /* Memory allocation routines (stolen from bttv-driver.c)                   */
0062 /****************************************************************************/
0063 static void *rvmalloc(unsigned long size)
0064 {
0065     void *mem;
0066     unsigned long adr;
0067 
0068     size = PAGE_ALIGN(size);
0069     mem = vmalloc_32(size);
0070     if (mem) {
0071         memset(mem, 0, size);
0072         adr = (unsigned long) mem;
0073         while (size > 0) {
0074             SetPageReserved(vmalloc_to_page((void *)adr));
0075             adr += PAGE_SIZE;
0076             size -= PAGE_SIZE;
0077         }
0078     }
0079     return mem;
0080 }
0081 
0082 static void rvfree(void * mem, unsigned long size)
0083 {
0084     unsigned long adr;
0085 
0086     if (mem) {
0087         adr = (unsigned long) mem;
0088         while ((long) size > 0) {
0089             ClearPageReserved(vmalloc_to_page((void *)adr));
0090             adr += PAGE_SIZE;
0091             size -= PAGE_SIZE;
0092         }
0093         vfree(mem);
0094     }
0095 }
0096 
0097 /*
0098  * return a page table pointing to N pages of locked memory
0099  *
0100  * NOTE: The meye device expects DMA addresses on 32 bits, we build
0101  * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
0102  */
0103 static int ptable_alloc(void)
0104 {
0105     u32 *pt;
0106     int i;
0107 
0108     memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
0109 
0110     /* give only 32 bit DMA addresses */
0111     if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
0112         return -1;
0113 
0114     meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
0115                            PAGE_SIZE,
0116                            &meye.mchip_dmahandle,
0117                            GFP_KERNEL);
0118     if (!meye.mchip_ptable_toc) {
0119         meye.mchip_dmahandle = 0;
0120         return -1;
0121     }
0122 
0123     pt = meye.mchip_ptable_toc;
0124     for (i = 0; i < MCHIP_NB_PAGES; i++) {
0125         dma_addr_t dma;
0126         meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
0127                               PAGE_SIZE,
0128                               &dma,
0129                               GFP_KERNEL);
0130         if (!meye.mchip_ptable[i]) {
0131             int j;
0132             pt = meye.mchip_ptable_toc;
0133             for (j = 0; j < i; ++j) {
0134                 dma = (dma_addr_t) *pt;
0135                 dma_free_coherent(&meye.mchip_dev->dev,
0136                           PAGE_SIZE,
0137                           meye.mchip_ptable[j], dma);
0138                 pt++;
0139             }
0140             dma_free_coherent(&meye.mchip_dev->dev,
0141                       PAGE_SIZE,
0142                       meye.mchip_ptable_toc,
0143                       meye.mchip_dmahandle);
0144             meye.mchip_ptable_toc = NULL;
0145             meye.mchip_dmahandle = 0;
0146             return -1;
0147         }
0148         *pt = (u32) dma;
0149         pt++;
0150     }
0151     return 0;
0152 }
0153 
0154 static void ptable_free(void)
0155 {
0156     u32 *pt;
0157     int i;
0158 
0159     pt = meye.mchip_ptable_toc;
0160     for (i = 0; i < MCHIP_NB_PAGES; i++) {
0161         dma_addr_t dma = (dma_addr_t) *pt;
0162         if (meye.mchip_ptable[i])
0163             dma_free_coherent(&meye.mchip_dev->dev,
0164                       PAGE_SIZE,
0165                       meye.mchip_ptable[i], dma);
0166         pt++;
0167     }
0168 
0169     if (meye.mchip_ptable_toc)
0170         dma_free_coherent(&meye.mchip_dev->dev,
0171                   PAGE_SIZE,
0172                   meye.mchip_ptable_toc,
0173                   meye.mchip_dmahandle);
0174 
0175     memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
0176     meye.mchip_ptable_toc = NULL;
0177     meye.mchip_dmahandle = 0;
0178 }
0179 
0180 /* copy data from ptable into buf */
0181 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
0182 {
0183     int i;
0184 
0185     for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
0186         memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
0187         if (start >= pt_pages)
0188             start = 0;
0189     }
0190     memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
0191 }
0192 
0193 /****************************************************************************/
0194 /* JPEG tables at different qualities to load into the VRJ chip             */
0195 /****************************************************************************/
0196 
0197 /* return a set of quantisation tables based on a quality from 1 to 10 */
0198 static u16 *jpeg_quantisation_tables(int *length, int quality)
0199 {
0200     static u16 jpeg_tables[][70] = { {
0201         0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0202         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0203         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0204         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0205         0xffff, 0xffff, 0xffff,
0206         0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0207         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0208         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0209         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0210         0xffff, 0xffff, 0xffff,
0211     },
0212     {
0213         0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
0214         0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
0215         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0216         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0217         0xffff, 0xffff, 0xffff,
0218         0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
0219         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0220         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0221         0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
0222         0xffff, 0xffff, 0xffff,
0223     },
0224     {
0225         0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
0226         0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
0227         0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
0228         0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
0229         0xe6ff, 0xfffd, 0xfff8,
0230         0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
0231         0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
0232         0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
0233         0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
0234         0xf8f8, 0xf8f8, 0xfff8,
0235     },
0236     {
0237         0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
0238         0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
0239         0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
0240         0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
0241         0x99c7, 0xaba8, 0xffa4,
0242         0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
0243         0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
0244         0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
0245         0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
0246         0xa4a4, 0xa4a4, 0xffa4,
0247     },
0248     {
0249         0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
0250         0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
0251         0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
0252         0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
0253         0x7396, 0x817e, 0xff7c,
0254         0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
0255         0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
0256         0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
0257         0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
0258         0x7c7c, 0x7c7c, 0xff7c,
0259     },
0260     {
0261         0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
0262         0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
0263         0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
0264         0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
0265         0x5c78, 0x6765, 0xff63,
0266         0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
0267         0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
0268         0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
0269         0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
0270         0x6363, 0x6363, 0xff63,
0271     },
0272     {
0273         0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
0274         0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
0275         0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
0276         0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
0277         0x4a60, 0x5251, 0xff4f,
0278         0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
0279         0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
0280         0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
0281         0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
0282         0x4f4f, 0x4f4f, 0xff4f,
0283     },
0284     {
0285         0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
0286         0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
0287         0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
0288         0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
0289         0x3748, 0x3e3d, 0xff3b,
0290         0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
0291         0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
0292         0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
0293         0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
0294         0x3b3b, 0x3b3b, 0xff3b,
0295     },
0296     {
0297         0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
0298         0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
0299         0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
0300         0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
0301         0x2530, 0x2928, 0xff28,
0302         0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
0303         0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
0304         0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
0305         0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
0306         0x2828, 0x2828, 0xff28,
0307     },
0308     {
0309         0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
0310         0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
0311         0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
0312         0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
0313         0x1218, 0x1514, 0xff14,
0314         0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
0315         0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
0316         0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
0317         0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
0318         0x1414, 0x1414, 0xff14,
0319     },
0320     {
0321         0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0322         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0323         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0324         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0325         0x0101, 0x0101, 0xff01,
0326         0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0327         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0328         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0329         0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
0330         0x0101, 0x0101, 0xff01,
0331     } };
0332 
0333     if (quality < 0 || quality > 10) {
0334         printk(KERN_WARNING
0335                "meye: invalid quality level %d - using 8\n", quality);
0336         quality = 8;
0337     }
0338 
0339     *length = ARRAY_SIZE(jpeg_tables[quality]);
0340     return jpeg_tables[quality];
0341 }
0342 
0343 /* return a generic set of huffman tables */
0344 static u16 *jpeg_huffman_tables(int *length)
0345 {
0346     static u16 tables[] = {
0347         0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
0348         0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
0349         0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
0350         0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
0351         0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
0352         0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
0353         0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
0354         0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
0355         0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
0356         0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
0357         0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
0358         0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
0359         0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
0360         0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
0361         0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
0362         0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
0363         0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
0364         0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
0365         0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
0366         0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
0367         0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
0368         0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
0369         0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
0370         0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
0371         0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
0372         0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
0373         0xFF0B,
0374         0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
0375         0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
0376         0xFF0B
0377     };
0378 
0379     *length = ARRAY_SIZE(tables);
0380     return tables;
0381 }
0382 
0383 /****************************************************************************/
0384 /* MCHIP low-level functions                                                */
0385 /****************************************************************************/
0386 
0387 /* returns the horizontal capture size */
0388 static inline int mchip_hsize(void)
0389 {
0390     return meye.params.subsample ? 320 : 640;
0391 }
0392 
0393 /* returns the vertical capture size */
0394 static inline int mchip_vsize(void)
0395 {
0396     return meye.params.subsample ? 240 : 480;
0397 }
0398 
0399 /* waits for a register to be available */
0400 static void mchip_sync(int reg)
0401 {
0402     u32 status;
0403     int i;
0404 
0405     if (reg == MCHIP_MM_FIFO_DATA) {
0406         for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
0407             status = readl(meye.mchip_mmregs +
0408                        MCHIP_MM_FIFO_STATUS);
0409             if (!(status & MCHIP_MM_FIFO_WAIT)) {
0410                 printk(KERN_WARNING "meye: fifo not ready\n");
0411                 return;
0412             }
0413             if (status & MCHIP_MM_FIFO_READY)
0414                 return;
0415             udelay(1);
0416         }
0417     } else if (reg > 0x80) {
0418         u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
0419                      : MCHIP_HIC_STATUS_VRJ_RDY;
0420         for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
0421             status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
0422             if (status & mask)
0423                 return;
0424             udelay(1);
0425         }
0426     } else
0427         return;
0428     printk(KERN_WARNING
0429            "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
0430            reg, status);
0431 }
0432 
0433 /* sets a value into the register */
0434 static inline void mchip_set(int reg, u32 v)
0435 {
0436     mchip_sync(reg);
0437     writel(v, meye.mchip_mmregs + reg);
0438 }
0439 
0440 /* get the register value */
0441 static inline u32 mchip_read(int reg)
0442 {
0443     mchip_sync(reg);
0444     return readl(meye.mchip_mmregs + reg);
0445 }
0446 
0447 /* wait for a register to become a particular value */
0448 static inline int mchip_delay(u32 reg, u32 v)
0449 {
0450     int n = 10;
0451     while (--n && mchip_read(reg) != v)
0452         udelay(1);
0453     return n;
0454 }
0455 
0456 /* setup subsampling */
0457 static void mchip_subsample(void)
0458 {
0459     mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
0460     mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
0461     mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
0462     mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
0463     mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
0464     mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
0465 }
0466 
0467 /* set the framerate into the mchip */
0468 static void mchip_set_framerate(void)
0469 {
0470     mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
0471 }
0472 
0473 /* load some huffman and quantisation tables into the VRJ chip ready
0474    for JPEG compression */
0475 static void mchip_load_tables(void)
0476 {
0477     int i;
0478     int length;
0479     u16 *tables;
0480 
0481     tables = jpeg_huffman_tables(&length);
0482     for (i = 0; i < length; i++)
0483         writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
0484 
0485     tables = jpeg_quantisation_tables(&length, meye.params.quality);
0486     for (i = 0; i < length; i++)
0487         writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
0488 }
0489 
0490 /* setup the VRJ parameters in the chip */
0491 static void mchip_vrj_setup(u8 mode)
0492 {
0493     mchip_set(MCHIP_VRJ_BUS_MODE, 5);
0494     mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
0495     mchip_set(MCHIP_VRJ_PDAT_USE, 1);
0496     mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
0497     mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
0498     mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
0499     mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
0500     mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
0501     mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
0502     mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
0503     mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
0504     mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
0505     mchip_set(MCHIP_VRJ_SOF1, 0x601);
0506     mchip_set(MCHIP_VRJ_SOF2, 0x1502);
0507     mchip_set(MCHIP_VRJ_SOF3, 0x1503);
0508     mchip_set(MCHIP_VRJ_SOF4, 0x1596);
0509     mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
0510 
0511     mchip_load_tables();
0512 }
0513 
0514 /* sets the DMA parameters into the chip */
0515 static void mchip_dma_setup(dma_addr_t dma_addr)
0516 {
0517     int i;
0518 
0519     mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
0520     for (i = 0; i < 4; i++)
0521         mchip_set(MCHIP_MM_FIR(i), 0);
0522     meye.mchip_fnum = 0;
0523 }
0524 
0525 /* setup for DMA transfers - also zeros the framebuffer */
0526 static int mchip_dma_alloc(void)
0527 {
0528     if (!meye.mchip_dmahandle)
0529         if (ptable_alloc())
0530             return -1;
0531     return 0;
0532 }
0533 
0534 /* frees the DMA buffer */
0535 static void mchip_dma_free(void)
0536 {
0537     if (meye.mchip_dmahandle) {
0538         mchip_dma_setup(0);
0539         ptable_free();
0540     }
0541 }
0542 
0543 /* stop any existing HIC action and wait for any dma to complete then
0544    reset the dma engine */
0545 static void mchip_hic_stop(void)
0546 {
0547     int i, j;
0548 
0549     meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
0550     if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
0551         return;
0552     for (i = 0; i < 20; ++i) {
0553         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
0554         mchip_delay(MCHIP_HIC_CMD, 0);
0555         for (j = 0; j < 100; ++j) {
0556             if (mchip_delay(MCHIP_HIC_STATUS,
0557                     MCHIP_HIC_STATUS_IDLE))
0558                 return;
0559             msleep(1);
0560         }
0561         printk(KERN_ERR "meye: need to reset HIC!\n");
0562 
0563         mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
0564         msleep(250);
0565     }
0566     printk(KERN_ERR "meye: resetting HIC hanged!\n");
0567 }
0568 
0569 /****************************************************************************/
0570 /* MCHIP frame processing functions                                         */
0571 /****************************************************************************/
0572 
0573 /* get the next ready frame from the dma engine */
0574 static u32 mchip_get_frame(void)
0575 {
0576     return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
0577 }
0578 
0579 /* frees the current frame from the dma engine */
0580 static void mchip_free_frame(void)
0581 {
0582     mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
0583     meye.mchip_fnum++;
0584     meye.mchip_fnum %= 4;
0585 }
0586 
0587 /* read one frame from the framebuffer assuming it was captured using
0588    a uncompressed transfer */
0589 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
0590 {
0591     int pt_id;
0592 
0593     pt_id = (v >> 17) & 0x3FF;
0594 
0595     ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
0596 }
0597 
0598 /* read a compressed frame from the framebuffer */
0599 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
0600 {
0601     int pt_start, pt_end, trailer;
0602     int fsize;
0603     int i;
0604 
0605     pt_start = (v >> 19) & 0xFF;
0606     pt_end = (v >> 11) & 0xFF;
0607     trailer = (v >> 1) & 0x3FF;
0608 
0609     if (pt_end < pt_start)
0610         fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
0611             pt_end * PAGE_SIZE + trailer * 4;
0612     else
0613         fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
0614 
0615     if (fsize > size) {
0616         printk(KERN_WARNING "meye: oversized compressed frame %d\n",
0617                fsize);
0618         return -1;
0619     }
0620 
0621     ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
0622 
0623 #ifdef MEYE_JPEG_CORRECTION
0624 
0625     /* Some mchip generated jpeg frames are incorrect. In most
0626      * (all ?) of those cases, the final EOI (0xff 0xd9) marker
0627      * is not present at the end of the frame.
0628      *
0629      * Since adding the final marker is not enough to restore
0630      * the jpeg integrity, we drop the frame.
0631      */
0632 
0633     for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
0634 
0635     if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
0636         return -1;
0637 
0638 #endif
0639 
0640     return fsize;
0641 }
0642 
0643 /* take a picture into SDRAM */
0644 static void mchip_take_picture(void)
0645 {
0646     int i;
0647 
0648     mchip_hic_stop();
0649     mchip_subsample();
0650     mchip_dma_setup(meye.mchip_dmahandle);
0651 
0652     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
0653     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0654 
0655     mchip_delay(MCHIP_HIC_CMD, 0);
0656 
0657     for (i = 0; i < 100; ++i) {
0658         if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
0659             break;
0660         msleep(1);
0661     }
0662 }
0663 
0664 /* dma a previously taken picture into a buffer */
0665 static void mchip_get_picture(u8 *buf, int bufsize)
0666 {
0667     u32 v;
0668     int i;
0669 
0670     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
0671     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0672 
0673     mchip_delay(MCHIP_HIC_CMD, 0);
0674     for (i = 0; i < 100; ++i) {
0675         if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
0676             break;
0677         msleep(1);
0678     }
0679     for (i = 0; i < 4; ++i) {
0680         v = mchip_get_frame();
0681         if (v & MCHIP_MM_FIR_RDY) {
0682             mchip_cont_read_frame(v, buf, bufsize);
0683             break;
0684         }
0685         mchip_free_frame();
0686     }
0687 }
0688 
0689 /* start continuous dma capture */
0690 static void mchip_continuous_start(void)
0691 {
0692     mchip_hic_stop();
0693     mchip_subsample();
0694     mchip_set_framerate();
0695     mchip_dma_setup(meye.mchip_dmahandle);
0696 
0697     meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
0698 
0699     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
0700     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0701 
0702     mchip_delay(MCHIP_HIC_CMD, 0);
0703 }
0704 
0705 /* compress one frame into a buffer */
0706 static int mchip_compress_frame(u8 *buf, int bufsize)
0707 {
0708     u32 v;
0709     int len = -1, i;
0710 
0711     mchip_vrj_setup(0x3f);
0712     udelay(50);
0713 
0714     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
0715     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0716 
0717     mchip_delay(MCHIP_HIC_CMD, 0);
0718     for (i = 0; i < 100; ++i) {
0719         if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
0720             break;
0721         msleep(1);
0722     }
0723 
0724     for (i = 0; i < 4; ++i) {
0725         v = mchip_get_frame();
0726         if (v & MCHIP_MM_FIR_RDY) {
0727             len = mchip_comp_read_frame(v, buf, bufsize);
0728             break;
0729         }
0730         mchip_free_frame();
0731     }
0732     return len;
0733 }
0734 
0735 #if 0
0736 /* uncompress one image into a buffer */
0737 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
0738 {
0739     mchip_vrj_setup(0x3f);
0740     udelay(50);
0741 
0742     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
0743     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0744 
0745     mchip_delay(MCHIP_HIC_CMD, 0);
0746 
0747     return mchip_comp_read_frame(buf, bufsize);
0748 }
0749 #endif
0750 
0751 /* start continuous compressed capture */
0752 static void mchip_cont_compression_start(void)
0753 {
0754     mchip_hic_stop();
0755     mchip_vrj_setup(0x3f);
0756     mchip_subsample();
0757     mchip_set_framerate();
0758     mchip_dma_setup(meye.mchip_dmahandle);
0759 
0760     meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
0761 
0762     mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
0763     mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
0764 
0765     mchip_delay(MCHIP_HIC_CMD, 0);
0766 }
0767 
0768 /****************************************************************************/
0769 /* Interrupt handling                                                       */
0770 /****************************************************************************/
0771 
0772 static irqreturn_t meye_irq(int irq, void *dev_id)
0773 {
0774     u32 v;
0775     int reqnr;
0776     static int sequence;
0777 
0778     v = mchip_read(MCHIP_MM_INTA);
0779 
0780     if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
0781         meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
0782         return IRQ_NONE;
0783 
0784 again:
0785     v = mchip_get_frame();
0786     if (!(v & MCHIP_MM_FIR_RDY))
0787         return IRQ_HANDLED;
0788 
0789     if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
0790         if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
0791                   sizeof(int), &meye.grabq_lock) != sizeof(int)) {
0792             mchip_free_frame();
0793             return IRQ_HANDLED;
0794         }
0795         mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
0796                       mchip_hsize() * mchip_vsize() * 2);
0797         meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
0798         meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
0799         meye.grab_buffer[reqnr].ts = ktime_get_ns();
0800         meye.grab_buffer[reqnr].sequence = sequence++;
0801         kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
0802                 sizeof(int), &meye.doneq_lock);
0803         wake_up_interruptible(&meye.proc_list);
0804     } else {
0805         int size;
0806         size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
0807         if (size == -1) {
0808             mchip_free_frame();
0809             goto again;
0810         }
0811         if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
0812                   sizeof(int), &meye.grabq_lock) != sizeof(int)) {
0813             mchip_free_frame();
0814             goto again;
0815         }
0816         memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
0817                size);
0818         meye.grab_buffer[reqnr].size = size;
0819         meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
0820         meye.grab_buffer[reqnr].ts = ktime_get_ns();
0821         meye.grab_buffer[reqnr].sequence = sequence++;
0822         kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
0823                 sizeof(int), &meye.doneq_lock);
0824         wake_up_interruptible(&meye.proc_list);
0825     }
0826     mchip_free_frame();
0827     goto again;
0828 }
0829 
0830 /****************************************************************************/
0831 /* video4linux integration                                                  */
0832 /****************************************************************************/
0833 
0834 static int meye_open(struct file *file)
0835 {
0836     int i;
0837 
0838     if (test_and_set_bit(0, &meye.in_use))
0839         return -EBUSY;
0840 
0841     mchip_hic_stop();
0842 
0843     if (mchip_dma_alloc()) {
0844         printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
0845         clear_bit(0, &meye.in_use);
0846         return -ENOBUFS;
0847     }
0848 
0849     for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
0850         meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
0851     kfifo_reset(&meye.grabq);
0852     kfifo_reset(&meye.doneq);
0853     return v4l2_fh_open(file);
0854 }
0855 
0856 static int meye_release(struct file *file)
0857 {
0858     mchip_hic_stop();
0859     mchip_dma_free();
0860     clear_bit(0, &meye.in_use);
0861     return v4l2_fh_release(file);
0862 }
0863 
0864 static int meyeioc_g_params(struct meye_params *p)
0865 {
0866     *p = meye.params;
0867     return 0;
0868 }
0869 
0870 static int meyeioc_s_params(struct meye_params *jp)
0871 {
0872     if (jp->subsample > 1)
0873         return -EINVAL;
0874 
0875     if (jp->quality > 10)
0876         return -EINVAL;
0877 
0878     if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
0879         return -EINVAL;
0880 
0881     if (jp->framerate > 31)
0882         return -EINVAL;
0883 
0884     mutex_lock(&meye.lock);
0885 
0886     if (meye.params.subsample != jp->subsample ||
0887         meye.params.quality != jp->quality)
0888         mchip_hic_stop();   /* need restart */
0889 
0890     meye.params = *jp;
0891     sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
0892                   meye.params.sharpness);
0893     sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
0894                   meye.params.agc);
0895     sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
0896                   meye.params.picture);
0897     mutex_unlock(&meye.lock);
0898 
0899     return 0;
0900 }
0901 
0902 static int meyeioc_qbuf_capt(int *nb)
0903 {
0904     if (!meye.grab_fbuffer)
0905         return -EINVAL;
0906 
0907     if (*nb >= gbuffers)
0908         return -EINVAL;
0909 
0910     if (*nb < 0) {
0911         /* stop capture */
0912         mchip_hic_stop();
0913         return 0;
0914     }
0915 
0916     if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
0917         return -EBUSY;
0918 
0919     mutex_lock(&meye.lock);
0920 
0921     if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
0922         mchip_cont_compression_start();
0923 
0924     meye.grab_buffer[*nb].state = MEYE_BUF_USING;
0925     kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
0926              &meye.grabq_lock);
0927     mutex_unlock(&meye.lock);
0928 
0929     return 0;
0930 }
0931 
0932 static int meyeioc_sync(struct file *file, void *fh, int *i)
0933 {
0934     int unused;
0935 
0936     if (*i < 0 || *i >= gbuffers)
0937         return -EINVAL;
0938 
0939     mutex_lock(&meye.lock);
0940     switch (meye.grab_buffer[*i].state) {
0941 
0942     case MEYE_BUF_UNUSED:
0943         mutex_unlock(&meye.lock);
0944         return -EINVAL;
0945     case MEYE_BUF_USING:
0946         if (file->f_flags & O_NONBLOCK) {
0947             mutex_unlock(&meye.lock);
0948             return -EAGAIN;
0949         }
0950         if (wait_event_interruptible(meye.proc_list,
0951             (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
0952             mutex_unlock(&meye.lock);
0953             return -EINTR;
0954         }
0955         fallthrough;
0956     case MEYE_BUF_DONE:
0957         meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
0958         if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
0959                 sizeof(int), &meye.doneq_lock) != sizeof(int))
0960                     break;
0961     }
0962     *i = meye.grab_buffer[*i].size;
0963     mutex_unlock(&meye.lock);
0964     return 0;
0965 }
0966 
0967 static int meyeioc_stillcapt(void)
0968 {
0969     if (!meye.grab_fbuffer)
0970         return -EINVAL;
0971 
0972     if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
0973         return -EBUSY;
0974 
0975     mutex_lock(&meye.lock);
0976     meye.grab_buffer[0].state = MEYE_BUF_USING;
0977     mchip_take_picture();
0978 
0979     mchip_get_picture(meye.grab_fbuffer,
0980             mchip_hsize() * mchip_vsize() * 2);
0981 
0982     meye.grab_buffer[0].state = MEYE_BUF_DONE;
0983     mutex_unlock(&meye.lock);
0984 
0985     return 0;
0986 }
0987 
0988 static int meyeioc_stilljcapt(int *len)
0989 {
0990     if (!meye.grab_fbuffer)
0991         return -EINVAL;
0992 
0993     if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
0994         return -EBUSY;
0995 
0996     mutex_lock(&meye.lock);
0997     meye.grab_buffer[0].state = MEYE_BUF_USING;
0998     *len = -1;
0999 
1000     while (*len == -1) {
1001         mchip_take_picture();
1002         *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1003     }
1004 
1005     meye.grab_buffer[0].state = MEYE_BUF_DONE;
1006     mutex_unlock(&meye.lock);
1007     return 0;
1008 }
1009 
1010 static int vidioc_querycap(struct file *file, void *fh,
1011                 struct v4l2_capability *cap)
1012 {
1013     strscpy(cap->driver, "meye", sizeof(cap->driver));
1014     strscpy(cap->card, "meye", sizeof(cap->card));
1015     return 0;
1016 }
1017 
1018 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1019 {
1020     if (i->index != 0)
1021         return -EINVAL;
1022 
1023     strscpy(i->name, "Camera", sizeof(i->name));
1024     i->type = V4L2_INPUT_TYPE_CAMERA;
1025 
1026     return 0;
1027 }
1028 
1029 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1030 {
1031     *i = 0;
1032     return 0;
1033 }
1034 
1035 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1036 {
1037     if (i != 0)
1038         return -EINVAL;
1039 
1040     return 0;
1041 }
1042 
1043 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1044 {
1045     mutex_lock(&meye.lock);
1046     switch (ctrl->id) {
1047     case V4L2_CID_BRIGHTNESS:
1048         sony_pic_camera_command(
1049             SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1050         meye.brightness = ctrl->val << 10;
1051         break;
1052     case V4L2_CID_HUE:
1053         sony_pic_camera_command(
1054             SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1055         meye.hue = ctrl->val << 10;
1056         break;
1057     case V4L2_CID_CONTRAST:
1058         sony_pic_camera_command(
1059             SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1060         meye.contrast = ctrl->val << 10;
1061         break;
1062     case V4L2_CID_SATURATION:
1063         sony_pic_camera_command(
1064             SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1065         meye.colour = ctrl->val << 10;
1066         break;
1067     case V4L2_CID_MEYE_AGC:
1068         sony_pic_camera_command(
1069             SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1070         meye.params.agc = ctrl->val;
1071         break;
1072     case V4L2_CID_SHARPNESS:
1073         sony_pic_camera_command(
1074             SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1075         meye.params.sharpness = ctrl->val;
1076         break;
1077     case V4L2_CID_MEYE_PICTURE:
1078         sony_pic_camera_command(
1079             SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1080         meye.params.picture = ctrl->val;
1081         break;
1082     case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1083         meye.params.quality = ctrl->val;
1084         break;
1085     case V4L2_CID_MEYE_FRAMERATE:
1086         meye.params.framerate = ctrl->val;
1087         break;
1088     default:
1089         mutex_unlock(&meye.lock);
1090         return -EINVAL;
1091     }
1092     mutex_unlock(&meye.lock);
1093 
1094     return 0;
1095 }
1096 
1097 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1098                 struct v4l2_fmtdesc *f)
1099 {
1100     if (f->index > 1)
1101         return -EINVAL;
1102 
1103     if (f->index == 0) {
1104         /* standard YUV 422 capture */
1105         f->flags = 0;
1106         f->pixelformat = V4L2_PIX_FMT_YUYV;
1107     } else {
1108         /* compressed MJPEG capture */
1109         f->pixelformat = V4L2_PIX_FMT_MJPEG;
1110     }
1111 
1112     return 0;
1113 }
1114 
1115 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1116                 struct v4l2_format *f)
1117 {
1118     if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1119         f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1120         return -EINVAL;
1121 
1122     if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1123         f->fmt.pix.field != V4L2_FIELD_NONE)
1124         return -EINVAL;
1125 
1126     f->fmt.pix.field = V4L2_FIELD_NONE;
1127 
1128     if (f->fmt.pix.width <= 320) {
1129         f->fmt.pix.width = 320;
1130         f->fmt.pix.height = 240;
1131     } else {
1132         f->fmt.pix.width = 640;
1133         f->fmt.pix.height = 480;
1134     }
1135 
1136     f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1137     f->fmt.pix.sizeimage = f->fmt.pix.height *
1138                    f->fmt.pix.bytesperline;
1139     f->fmt.pix.colorspace = 0;
1140 
1141     return 0;
1142 }
1143 
1144 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1145                     struct v4l2_format *f)
1146 {
1147     switch (meye.mchip_mode) {
1148     case MCHIP_HIC_MODE_CONT_OUT:
1149     default:
1150         f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1151         break;
1152     case MCHIP_HIC_MODE_CONT_COMP:
1153         f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1154         break;
1155     }
1156 
1157     f->fmt.pix.field = V4L2_FIELD_NONE;
1158     f->fmt.pix.width = mchip_hsize();
1159     f->fmt.pix.height = mchip_vsize();
1160     f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1161     f->fmt.pix.sizeimage = f->fmt.pix.height *
1162                    f->fmt.pix.bytesperline;
1163 
1164     return 0;
1165 }
1166 
1167 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1168                     struct v4l2_format *f)
1169 {
1170     if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1171         f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1172         return -EINVAL;
1173 
1174     if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1175         f->fmt.pix.field != V4L2_FIELD_NONE)
1176         return -EINVAL;
1177 
1178     f->fmt.pix.field = V4L2_FIELD_NONE;
1179     mutex_lock(&meye.lock);
1180 
1181     if (f->fmt.pix.width <= 320) {
1182         f->fmt.pix.width = 320;
1183         f->fmt.pix.height = 240;
1184         meye.params.subsample = 1;
1185     } else {
1186         f->fmt.pix.width = 640;
1187         f->fmt.pix.height = 480;
1188         meye.params.subsample = 0;
1189     }
1190 
1191     switch (f->fmt.pix.pixelformat) {
1192     case V4L2_PIX_FMT_YUYV:
1193         meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1194         break;
1195     case V4L2_PIX_FMT_MJPEG:
1196         meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1197         break;
1198     }
1199 
1200     mutex_unlock(&meye.lock);
1201     f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1202     f->fmt.pix.sizeimage = f->fmt.pix.height *
1203                    f->fmt.pix.bytesperline;
1204     f->fmt.pix.colorspace = 0;
1205 
1206     return 0;
1207 }
1208 
1209 static int vidioc_reqbufs(struct file *file, void *fh,
1210                 struct v4l2_requestbuffers *req)
1211 {
1212     int i;
1213 
1214     if (req->memory != V4L2_MEMORY_MMAP)
1215         return -EINVAL;
1216 
1217     if (meye.grab_fbuffer && req->count == gbuffers) {
1218         /* already allocated, no modifications */
1219         return 0;
1220     }
1221 
1222     mutex_lock(&meye.lock);
1223     if (meye.grab_fbuffer) {
1224         for (i = 0; i < gbuffers; i++)
1225             if (meye.vma_use_count[i]) {
1226                 mutex_unlock(&meye.lock);
1227                 return -EINVAL;
1228             }
1229         rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1230         meye.grab_fbuffer = NULL;
1231     }
1232 
1233     gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1234     req->count = gbuffers;
1235     meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1236 
1237     if (!meye.grab_fbuffer) {
1238         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1239         mutex_unlock(&meye.lock);
1240         return -ENOMEM;
1241     }
1242 
1243     for (i = 0; i < gbuffers; i++)
1244         meye.vma_use_count[i] = 0;
1245 
1246     mutex_unlock(&meye.lock);
1247 
1248     return 0;
1249 }
1250 
1251 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1252 {
1253     unsigned int index = buf->index;
1254 
1255     if (index >= gbuffers)
1256         return -EINVAL;
1257 
1258     buf->bytesused = meye.grab_buffer[index].size;
1259     buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1260 
1261     if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1262         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1263 
1264     if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1265         buf->flags |= V4L2_BUF_FLAG_DONE;
1266 
1267     buf->field = V4L2_FIELD_NONE;
1268     v4l2_buffer_set_timestamp(buf, meye.grab_buffer[index].ts);
1269     buf->sequence = meye.grab_buffer[index].sequence;
1270     buf->memory = V4L2_MEMORY_MMAP;
1271     buf->m.offset = index * gbufsize;
1272     buf->length = gbufsize;
1273 
1274     return 0;
1275 }
1276 
1277 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1278 {
1279     if (buf->memory != V4L2_MEMORY_MMAP)
1280         return -EINVAL;
1281 
1282     if (buf->index >= gbuffers)
1283         return -EINVAL;
1284 
1285     if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1286         return -EINVAL;
1287 
1288     mutex_lock(&meye.lock);
1289     buf->flags |= V4L2_BUF_FLAG_QUEUED;
1290     buf->flags &= ~V4L2_BUF_FLAG_DONE;
1291     meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1292     kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1293             sizeof(int), &meye.grabq_lock);
1294     mutex_unlock(&meye.lock);
1295 
1296     return 0;
1297 }
1298 
1299 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1300 {
1301     int reqnr;
1302 
1303     if (buf->memory != V4L2_MEMORY_MMAP)
1304         return -EINVAL;
1305 
1306     mutex_lock(&meye.lock);
1307 
1308     if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1309         mutex_unlock(&meye.lock);
1310         return -EAGAIN;
1311     }
1312 
1313     if (wait_event_interruptible(meye.proc_list,
1314                      kfifo_len(&meye.doneq) != 0) < 0) {
1315         mutex_unlock(&meye.lock);
1316         return -EINTR;
1317     }
1318 
1319     if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1320                sizeof(int), &meye.doneq_lock)) {
1321         mutex_unlock(&meye.lock);
1322         return -EBUSY;
1323     }
1324 
1325     if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1326         mutex_unlock(&meye.lock);
1327         return -EINVAL;
1328     }
1329 
1330     buf->index = reqnr;
1331     buf->bytesused = meye.grab_buffer[reqnr].size;
1332     buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1333     buf->field = V4L2_FIELD_NONE;
1334     v4l2_buffer_set_timestamp(buf, meye.grab_buffer[reqnr].ts);
1335     buf->sequence = meye.grab_buffer[reqnr].sequence;
1336     buf->memory = V4L2_MEMORY_MMAP;
1337     buf->m.offset = reqnr * gbufsize;
1338     buf->length = gbufsize;
1339     meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1340     mutex_unlock(&meye.lock);
1341 
1342     return 0;
1343 }
1344 
1345 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1346 {
1347     mutex_lock(&meye.lock);
1348 
1349     switch (meye.mchip_mode) {
1350     case MCHIP_HIC_MODE_CONT_OUT:
1351         mchip_continuous_start();
1352         break;
1353     case MCHIP_HIC_MODE_CONT_COMP:
1354         mchip_cont_compression_start();
1355         break;
1356     default:
1357         mutex_unlock(&meye.lock);
1358         return -EINVAL;
1359     }
1360 
1361     mutex_unlock(&meye.lock);
1362 
1363     return 0;
1364 }
1365 
1366 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1367 {
1368     mutex_lock(&meye.lock);
1369     mchip_hic_stop();
1370     kfifo_reset(&meye.grabq);
1371     kfifo_reset(&meye.doneq);
1372 
1373     for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1374         meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1375 
1376     mutex_unlock(&meye.lock);
1377     return 0;
1378 }
1379 
1380 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1381                unsigned int cmd, void *arg)
1382 {
1383     switch (cmd) {
1384     case MEYEIOC_G_PARAMS:
1385         return meyeioc_g_params((struct meye_params *) arg);
1386 
1387     case MEYEIOC_S_PARAMS:
1388         return meyeioc_s_params((struct meye_params *) arg);
1389 
1390     case MEYEIOC_QBUF_CAPT:
1391         return meyeioc_qbuf_capt((int *) arg);
1392 
1393     case MEYEIOC_SYNC:
1394         return meyeioc_sync(file, fh, (int *) arg);
1395 
1396     case MEYEIOC_STILLCAPT:
1397         return meyeioc_stillcapt();
1398 
1399     case MEYEIOC_STILLJCAPT:
1400         return meyeioc_stilljcapt((int *) arg);
1401 
1402     default:
1403         return -ENOTTY;
1404     }
1405 
1406 }
1407 
1408 static __poll_t meye_poll(struct file *file, poll_table *wait)
1409 {
1410     __poll_t res = v4l2_ctrl_poll(file, wait);
1411 
1412     mutex_lock(&meye.lock);
1413     poll_wait(file, &meye.proc_list, wait);
1414     if (kfifo_len(&meye.doneq))
1415         res |= EPOLLIN | EPOLLRDNORM;
1416     mutex_unlock(&meye.lock);
1417     return res;
1418 }
1419 
1420 static void meye_vm_open(struct vm_area_struct *vma)
1421 {
1422     long idx = (long)vma->vm_private_data;
1423     meye.vma_use_count[idx]++;
1424 }
1425 
1426 static void meye_vm_close(struct vm_area_struct *vma)
1427 {
1428     long idx = (long)vma->vm_private_data;
1429     meye.vma_use_count[idx]--;
1430 }
1431 
1432 static const struct vm_operations_struct meye_vm_ops = {
1433     .open       = meye_vm_open,
1434     .close      = meye_vm_close,
1435 };
1436 
1437 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1438 {
1439     unsigned long start = vma->vm_start;
1440     unsigned long size = vma->vm_end - vma->vm_start;
1441     unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1442     unsigned long page, pos;
1443 
1444     mutex_lock(&meye.lock);
1445     if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
1446         mutex_unlock(&meye.lock);
1447         return -EINVAL;
1448     }
1449     if (!meye.grab_fbuffer) {
1450         int i;
1451 
1452         /* lazy allocation */
1453         meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1454         if (!meye.grab_fbuffer) {
1455             printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1456             mutex_unlock(&meye.lock);
1457             return -ENOMEM;
1458         }
1459         for (i = 0; i < gbuffers; i++)
1460             meye.vma_use_count[i] = 0;
1461     }
1462     pos = (unsigned long)meye.grab_fbuffer + offset;
1463 
1464     while (size > 0) {
1465         page = vmalloc_to_pfn((void *)pos);
1466         if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1467             mutex_unlock(&meye.lock);
1468             return -EAGAIN;
1469         }
1470         start += PAGE_SIZE;
1471         pos += PAGE_SIZE;
1472         if (size > PAGE_SIZE)
1473             size -= PAGE_SIZE;
1474         else
1475             size = 0;
1476     }
1477 
1478     vma->vm_ops = &meye_vm_ops;
1479     vma->vm_flags &= ~VM_IO;    /* not I/O memory */
1480     vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1481     vma->vm_private_data = (void *) (offset / gbufsize);
1482     meye_vm_open(vma);
1483 
1484     mutex_unlock(&meye.lock);
1485     return 0;
1486 }
1487 
1488 static const struct v4l2_file_operations meye_fops = {
1489     .owner      = THIS_MODULE,
1490     .open       = meye_open,
1491     .release    = meye_release,
1492     .mmap       = meye_mmap,
1493     .unlocked_ioctl = video_ioctl2,
1494     .poll       = meye_poll,
1495 };
1496 
1497 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1498     .vidioc_querycap    = vidioc_querycap,
1499     .vidioc_enum_input  = vidioc_enum_input,
1500     .vidioc_g_input     = vidioc_g_input,
1501     .vidioc_s_input     = vidioc_s_input,
1502     .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1503     .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1504     .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1505     .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1506     .vidioc_reqbufs     = vidioc_reqbufs,
1507     .vidioc_querybuf    = vidioc_querybuf,
1508     .vidioc_qbuf        = vidioc_qbuf,
1509     .vidioc_dqbuf       = vidioc_dqbuf,
1510     .vidioc_streamon    = vidioc_streamon,
1511     .vidioc_streamoff   = vidioc_streamoff,
1512     .vidioc_log_status  = v4l2_ctrl_log_status,
1513     .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1514     .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1515     .vidioc_default     = vidioc_default,
1516 };
1517 
1518 static const struct video_device meye_template = {
1519     .name       = "meye",
1520     .fops       = &meye_fops,
1521     .ioctl_ops  = &meye_ioctl_ops,
1522     .release    = video_device_release_empty,
1523     .device_caps    = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
1524 };
1525 
1526 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1527     .s_ctrl = meye_s_ctrl,
1528 };
1529 
1530 static int __maybe_unused meye_suspend(struct device *dev)
1531 {
1532     meye.pm_mchip_mode = meye.mchip_mode;
1533     mchip_hic_stop();
1534     mchip_set(MCHIP_MM_INTA, 0x0);
1535     return 0;
1536 }
1537 
1538 static int __maybe_unused meye_resume(struct device *dev)
1539 {
1540     pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1541 
1542     mchip_delay(MCHIP_HIC_CMD, 0);
1543     mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1544     msleep(1);
1545     mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1546     msleep(1);
1547     mchip_set(MCHIP_MM_PCI_MODE, 5);
1548     msleep(1);
1549     mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1550 
1551     switch (meye.pm_mchip_mode) {
1552     case MCHIP_HIC_MODE_CONT_OUT:
1553         mchip_continuous_start();
1554         break;
1555     case MCHIP_HIC_MODE_CONT_COMP:
1556         mchip_cont_compression_start();
1557         break;
1558     }
1559     return 0;
1560 }
1561 
1562 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1563 {
1564     static const struct v4l2_ctrl_config ctrl_agc = {
1565         .id = V4L2_CID_MEYE_AGC,
1566         .type = V4L2_CTRL_TYPE_INTEGER,
1567         .ops = &meye_ctrl_ops,
1568         .name = "AGC",
1569         .max = 63,
1570         .step = 1,
1571         .def = 48,
1572         .flags = V4L2_CTRL_FLAG_SLIDER,
1573     };
1574     static const struct v4l2_ctrl_config ctrl_picture = {
1575         .id = V4L2_CID_MEYE_PICTURE,
1576         .type = V4L2_CTRL_TYPE_INTEGER,
1577         .ops = &meye_ctrl_ops,
1578         .name = "Picture",
1579         .max = 63,
1580         .step = 1,
1581     };
1582     static const struct v4l2_ctrl_config ctrl_framerate = {
1583         .id = V4L2_CID_MEYE_FRAMERATE,
1584         .type = V4L2_CTRL_TYPE_INTEGER,
1585         .ops = &meye_ctrl_ops,
1586         .name = "Framerate",
1587         .max = 31,
1588         .step = 1,
1589     };
1590     struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1591     int ret = -EBUSY;
1592     unsigned long mchip_adr;
1593 
1594     if (meye.mchip_dev != NULL) {
1595         printk(KERN_ERR "meye: only one device allowed!\n");
1596         return ret;
1597     }
1598 
1599     ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1600     if (ret < 0) {
1601         v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1602         return ret;
1603     }
1604     ret = -ENOMEM;
1605     meye.mchip_dev = pcidev;
1606 
1607     meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
1608     if (!meye.grab_temp)
1609         goto outvmalloc;
1610 
1611     spin_lock_init(&meye.grabq_lock);
1612     if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1613             GFP_KERNEL))
1614         goto outkfifoalloc1;
1615 
1616     spin_lock_init(&meye.doneq_lock);
1617     if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1618             GFP_KERNEL))
1619         goto outkfifoalloc2;
1620 
1621     meye.vdev = meye_template;
1622     meye.vdev.v4l2_dev = &meye.v4l2_dev;
1623 
1624     ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1625     if (ret) {
1626         v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1627         v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1628         goto outsonypienable;
1629     }
1630 
1631     ret = pci_enable_device(meye.mchip_dev);
1632     if (ret) {
1633         v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1634         goto outenabledev;
1635     }
1636 
1637     ret = -EIO;
1638     mchip_adr = pci_resource_start(meye.mchip_dev,0);
1639     if (!mchip_adr) {
1640         v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1641         goto outregions;
1642     }
1643     if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1644                 pci_resource_len(meye.mchip_dev, 0),
1645                 "meye")) {
1646         v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1647         goto outregions;
1648     }
1649     meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1650     if (!meye.mchip_mmregs) {
1651         v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1652         goto outremap;
1653     }
1654 
1655     meye.mchip_irq = pcidev->irq;
1656     if (request_irq(meye.mchip_irq, meye_irq,
1657             IRQF_SHARED, "meye", meye_irq)) {
1658         v4l2_err(v4l2_dev, "request_irq failed\n");
1659         goto outreqirq;
1660     }
1661 
1662     pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1663     pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1664 
1665     pci_set_master(meye.mchip_dev);
1666 
1667     /* Ask the camera to perform a soft reset. */
1668     pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1669 
1670     mchip_delay(MCHIP_HIC_CMD, 0);
1671     mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1672 
1673     msleep(1);
1674     mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1675 
1676     msleep(1);
1677     mchip_set(MCHIP_MM_PCI_MODE, 5);
1678 
1679     msleep(1);
1680     mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1681 
1682     mutex_init(&meye.lock);
1683     init_waitqueue_head(&meye.proc_list);
1684 
1685     v4l2_ctrl_handler_init(&meye.hdl, 3);
1686     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1687               V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1688     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1689               V4L2_CID_HUE, 0, 63, 1, 32);
1690     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1691               V4L2_CID_CONTRAST, 0, 63, 1, 32);
1692     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1693               V4L2_CID_SATURATION, 0, 63, 1, 32);
1694     v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1695     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1696               V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1697     v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1698     v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1699               V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1700     v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1701     if (meye.hdl.error) {
1702         v4l2_err(v4l2_dev, "couldn't register controls\n");
1703         goto outvideoreg;
1704     }
1705 
1706     v4l2_ctrl_handler_setup(&meye.hdl);
1707     meye.vdev.ctrl_handler = &meye.hdl;
1708 
1709     if (video_register_device(&meye.vdev, VFL_TYPE_VIDEO,
1710                   video_nr) < 0) {
1711         v4l2_err(v4l2_dev, "video_register_device failed\n");
1712         goto outvideoreg;
1713     }
1714 
1715     v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1716            MEYE_DRIVER_VERSION);
1717     v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1718            meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1719 
1720     return 0;
1721 
1722 outvideoreg:
1723     v4l2_ctrl_handler_free(&meye.hdl);
1724     free_irq(meye.mchip_irq, meye_irq);
1725 outreqirq:
1726     iounmap(meye.mchip_mmregs);
1727 outremap:
1728     release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1729                pci_resource_len(meye.mchip_dev, 0));
1730 outregions:
1731     pci_disable_device(meye.mchip_dev);
1732 outenabledev:
1733     sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1734 outsonypienable:
1735     kfifo_free(&meye.doneq);
1736 outkfifoalloc2:
1737     kfifo_free(&meye.grabq);
1738 outkfifoalloc1:
1739     vfree(meye.grab_temp);
1740 outvmalloc:
1741     return ret;
1742 }
1743 
1744 static void meye_remove(struct pci_dev *pcidev)
1745 {
1746     video_unregister_device(&meye.vdev);
1747 
1748     mchip_hic_stop();
1749 
1750     mchip_dma_free();
1751 
1752     /* disable interrupts */
1753     mchip_set(MCHIP_MM_INTA, 0x0);
1754 
1755     free_irq(meye.mchip_irq, meye_irq);
1756 
1757     iounmap(meye.mchip_mmregs);
1758 
1759     release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1760                pci_resource_len(meye.mchip_dev, 0));
1761 
1762     pci_disable_device(meye.mchip_dev);
1763 
1764     sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1765 
1766     kfifo_free(&meye.doneq);
1767     kfifo_free(&meye.grabq);
1768 
1769     vfree(meye.grab_temp);
1770 
1771     if (meye.grab_fbuffer) {
1772         rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1773         meye.grab_fbuffer = NULL;
1774     }
1775 
1776     printk(KERN_INFO "meye: removed\n");
1777 }
1778 
1779 static const struct pci_device_id meye_pci_tbl[] = {
1780     { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1781     { }
1782 };
1783 
1784 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1785 
1786 static SIMPLE_DEV_PM_OPS(meye_pm_ops, meye_suspend, meye_resume);
1787 
1788 static struct pci_driver meye_driver = {
1789     .name       = "meye",
1790     .id_table   = meye_pci_tbl,
1791     .probe      = meye_probe,
1792     .remove     = meye_remove,
1793     .driver.pm  = &meye_pm_ops,
1794 };
1795 
1796 static int __init meye_init(void)
1797 {
1798     gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1799     if (gbufsize > MEYE_MAX_BUFSIZE)
1800         gbufsize = MEYE_MAX_BUFSIZE;
1801     gbufsize = PAGE_ALIGN(gbufsize);
1802     printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1803              gbuffers,
1804              gbufsize / 1024, gbuffers * gbufsize / 1024);
1805     return pci_register_driver(&meye_driver);
1806 }
1807 
1808 static void __exit meye_exit(void)
1809 {
1810     pci_unregister_driver(&meye_driver);
1811 }
1812 
1813 module_init(meye_init);
1814 module_exit(meye_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!