drivers/media/pci/meye/meye.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Motion Eye video4linux driver for Sony Vaio PictureBook
   4  *
   5  * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
   6  *
   7  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
   8  *
   9  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
  10  *
  11  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  12  *
  13  * Some parts borrowed from various video4linux drivers, especially
  14  * bttv-driver.c and zoran.c, see original files for credits.
  15  */
  16 #include <linux/module.h>
  17 #include <linux/pci.h>
  18 #include <linux/sched.h>
  19 #include <linux/init.h>
  20 #include <linux/gfp.h>
  21 #include <linux/videodev2.h>
  22 #include <media/v4l2-common.h>
  23 #include <media/v4l2-device.h>
  24 #include <media/v4l2-ioctl.h>
  25 #include <media/v4l2-fh.h>
  26 #include <media/v4l2-event.h>
  27 #include <linux/uaccess.h>
  28 #include <asm/io.h>
  29 #include <linux/delay.h>
  30 #include <linux/interrupt.h>
  31 #include <linux/vmalloc.h>
  32 #include <linux/dma-mapping.h>
  33
  34 #include "meye.h"
  35 #include <linux/meye.h>
  36
  37 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
  38 MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
  39 MODULE_LICENSE("GPL");
  40 MODULE_VERSION(MEYE_DRIVER_VERSION);
  41
  42 /* number of grab buffers */
  43 static unsigned int gbuffers = 2;
  44 module_param(gbuffers, int, 0444);
  45 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
  46
  47 /* size of a grab buffer */
  48 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
  49 module_param(gbufsize, int, 0444);
  50 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400 (will be rounded up to a page multiple)");
  51
  52 /* /dev/videoX registration number */
  53 static int video_nr = -1;
  54 module_param(video_nr, int, 0444);
  55 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
  56
  57 /* driver structure - only one possible */
  58 static struct meye meye;
  59
  60 /****************************************************************************/
  61 /* Memory allocation routines (stolen from bttv-driver.c)                   */
  62 /****************************************************************************/
  63 static void *rvmalloc(unsigned long size)
  64 {
  65         void *mem;
  66         unsigned long adr;
  67
  68         size = PAGE_ALIGN(size);
  69         mem = vmalloc_32(size);
  70         if (mem) {
  71                 memset(mem, 0, size);
  72                 adr = (unsigned long) mem;
  73                 while (size > 0) {
  74                         SetPageReserved(vmalloc_to_page((void *)adr));
  75                         adr += PAGE_SIZE;
  76                         size -= PAGE_SIZE;
  77                 }
  78         }
  79         return mem;
  80 }
  81
  82 static void rvfree(void * mem, unsigned long size)
  83 {
  84         unsigned long adr;
  85
  86         if (mem) {
  87                 adr = (unsigned long) mem;
  88                 while ((long) size > 0) {
  89                         ClearPageReserved(vmalloc_to_page((void *)adr));
  90                         adr += PAGE_SIZE;
  91                         size -= PAGE_SIZE;
  92                 }
  93                 vfree(mem);
  94         }
  95 }
  96
  97 /*
  98  * return a page table pointing to N pages of locked memory
  99  *
 100  * NOTE: The meye device expects DMA addresses on 32 bits, we build
 101  * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
 102  */
 103 static int ptable_alloc(void)
 104 {
 105         u32 *pt;
 106         int i;
 107
 108         memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 109
 110         /* give only 32 bit DMA addresses */
 111         if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
 112                 return -1;
 113
 114         meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
 115                                                    PAGE_SIZE,
 116                                                    &meye.mchip_dmahandle,
 117                                                    GFP_KERNEL);
 118         if (!meye.mchip_ptable_toc) {
 119                 meye.mchip_dmahandle = 0;
 120                 return -1;
 121         }
 122
 123         pt = meye.mchip_ptable_toc;
 124         for (i = 0; i < MCHIP_NB_PAGES; i++) {
 125                 dma_addr_t dma;
 126                 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
 127                                                           PAGE_SIZE,
 128                                                           &dma,
 129                                                           GFP_KERNEL);
 130                 if (!meye.mchip_ptable[i]) {
 131                         int j;
 132                         pt = meye.mchip_ptable_toc;
 133                         for (j = 0; j < i; ++j) {
 134                                 dma = (dma_addr_t) *pt;
 135                                 dma_free_coherent(&meye.mchip_dev->dev,
 136                                                   PAGE_SIZE,
 137                                                   meye.mchip_ptable[j], dma);
 138                                 pt++;
 139                         }
 140                         dma_free_coherent(&meye.mchip_dev->dev,
 141                                           PAGE_SIZE,
 142                                           meye.mchip_ptable_toc,
 143                                           meye.mchip_dmahandle);
 144                         meye.mchip_ptable_toc = NULL;
 145                         meye.mchip_dmahandle = 0;
 146                         return -1;
 147                 }
 148                 *pt = (u32) dma;
 149                 pt++;
 150         }
 151         return 0;
 152 }
 153
 154 static void ptable_free(void)
 155 {
 156         u32 *pt;
 157         int i;
 158
 159         pt = meye.mchip_ptable_toc;
 160         for (i = 0; i < MCHIP_NB_PAGES; i++) {
 161                 dma_addr_t dma = (dma_addr_t) *pt;
 162                 if (meye.mchip_ptable[i])
 163                         dma_free_coherent(&meye.mchip_dev->dev,
 164                                           PAGE_SIZE,
 165                                           meye.mchip_ptable[i], dma);
 166                 pt++;
 167         }
 168
 169         if (meye.mchip_ptable_toc)
 170                 dma_free_coherent(&meye.mchip_dev->dev,
 171                                   PAGE_SIZE,
 172                                   meye.mchip_ptable_toc,
 173                                   meye.mchip_dmahandle);
 174
 175         memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 176         meye.mchip_ptable_toc = NULL;
 177         meye.mchip_dmahandle = 0;
 178 }
 179
 180 /* copy data from ptable into buf */
 181 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
 182 {
 183         int i;
 184
 185         for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
 186                 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
 187                 if (start >= pt_pages)
 188                         start = 0;
 189         }
 190         memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
 191 }
 192
 193 /****************************************************************************/
 194 /* JPEG tables at different qualities to load into the VRJ chip             */
 195 /****************************************************************************/
 196
 197 /* return a set of quantisation tables based on a quality from 1 to 10 */
 198 static u16 *jpeg_quantisation_tables(int *length, int quality)
 199 {
 200         static u16 jpeg_tables[][70] = { {
 201                 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 202                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 203                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 204                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 205                 0xffff, 0xffff, 0xffff,
 206                 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 207                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 208                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 209                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 210                 0xffff, 0xffff, 0xffff,
 211         },
 212         {
 213                 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
 214                 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
 215                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 216                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 217                 0xffff, 0xffff, 0xffff,
 218                 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
 219                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 220                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 221                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 222                 0xffff, 0xffff, 0xffff,
 223         },
 224         {
 225                 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
 226                 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
 227                 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
 228                 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
 229                 0xe6ff, 0xfffd, 0xfff8,
 230                 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
 231                 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 232                 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 233                 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 234                 0xf8f8, 0xf8f8, 0xfff8,
 235         },
 236         {
 237                 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
 238                 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
 239                 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
 240                 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
 241                 0x99c7, 0xaba8, 0xffa4,
 242                 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
 243                 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 244                 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 245                 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 246                 0xa4a4, 0xa4a4, 0xffa4,
 247         },
 248         {
 249                 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
 250                 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
 251                 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
 252                 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
 253                 0x7396, 0x817e, 0xff7c,
 254                 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
 255                 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 256                 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 257                 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 258                 0x7c7c, 0x7c7c, 0xff7c,
 259         },
 260         {
 261                 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
 262                 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
 263                 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
 264                 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
 265                 0x5c78, 0x6765, 0xff63,
 266                 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
 267                 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 268                 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 269                 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 270                 0x6363, 0x6363, 0xff63,
 271         },
 272         {
 273                 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
 274                 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
 275                 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
 276                 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
 277                 0x4a60, 0x5251, 0xff4f,
 278                 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
 279                 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 280                 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 281                 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 282                 0x4f4f, 0x4f4f, 0xff4f,
 283         },
 284         {
 285                 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
 286                 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
 287                 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
 288                 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
 289                 0x3748, 0x3e3d, 0xff3b,
 290                 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
 291                 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 292                 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 293                 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 294                 0x3b3b, 0x3b3b, 0xff3b,
 295         },
 296         {
 297                 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
 298                 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
 299                 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
 300                 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
 301                 0x2530, 0x2928, 0xff28,
 302                 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
 303                 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 304                 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 305                 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 306                 0x2828, 0x2828, 0xff28,
 307         },
 308         {
 309                 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
 310                 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
 311                 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
 312                 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
 313                 0x1218, 0x1514, 0xff14,
 314                 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
 315                 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 316                 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 317                 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 318                 0x1414, 0x1414, 0xff14,
 319         },
 320         {
 321                 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 322                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 323                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 324                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 325                 0x0101, 0x0101, 0xff01,
 326                 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 327                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 328                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 329                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 330                 0x0101, 0x0101, 0xff01,
 331         } };
 332
 333         if (quality < 0 || quality > 10) {
 334                 printk(KERN_WARNING
 335                        "meye: invalid quality level %d - using 8\n", quality);
 336                 quality = 8;
 337         }
 338
 339         *length = ARRAY_SIZE(jpeg_tables[quality]);
 340         return jpeg_tables[quality];
 341 }
 342
 343 /* return a generic set of huffman tables */
 344 static u16 *jpeg_huffman_tables(int *length)
 345 {
 346         static u16 tables[] = {
 347                 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
 348                 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
 349                 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
 350                 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
 351                 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
 352                 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
 353                 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
 354                 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
 355                 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
 356                 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
 357                 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
 358                 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
 359                 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
 360                 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
 361                 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
 362                 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
 363                 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
 364                 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
 365                 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
 366                 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
 367                 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
 368                 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
 369                 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
 370                 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
 371                 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
 372                 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
 373                 0xFF0B,
 374                 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
 375                 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
 376                 0xFF0B
 377         };
 378
 379         *length = ARRAY_SIZE(tables);
 380         return tables;
 381 }
 382
 383 /****************************************************************************/
 384 /* MCHIP low-level functions                                                */
 385 /****************************************************************************/
 386
 387 /* returns the horizontal capture size */
 388 static inline int mchip_hsize(void)
 389 {
 390         return meye.params.subsample ? 320 : 640;
 391 }
 392
 393 /* returns the vertical capture size */
 394 static inline int mchip_vsize(void)
 395 {
 396         return meye.params.subsample ? 240 : 480;
 397 }
 398
 399 /* waits for a register to be available */
 400 static void mchip_sync(int reg)
 401 {
 402         u32 status;
 403         int i;
 404
 405         if (reg == MCHIP_MM_FIFO_DATA) {
 406                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 407                         status = readl(meye.mchip_mmregs +
 408                                        MCHIP_MM_FIFO_STATUS);
 409                         if (!(status & MCHIP_MM_FIFO_WAIT)) {
 410                                 printk(KERN_WARNING "meye: fifo not ready\n");
 411                                 return;
 412                         }
 413                         if (status & MCHIP_MM_FIFO_READY)
 414                                 return;
 415                         udelay(1);
 416                 }
 417         } else if (reg > 0x80) {
 418                 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
 419                                          : MCHIP_HIC_STATUS_VRJ_RDY;
 420                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 421                         status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
 422                         if (status & mask)
 423                                 return;
 424                         udelay(1);
 425                 }
 426         } else
 427                 return;
 428         printk(KERN_WARNING
 429                "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
 430                reg, status);
 431 }
 432
 433 /* sets a value into the register */
 434 static inline void mchip_set(int reg, u32 v)
 435 {
 436         mchip_sync(reg);
 437         writel(v, meye.mchip_mmregs + reg);
 438 }
 439
 440 /* get the register value */
 441 static inline u32 mchip_read(int reg)
 442 {
 443         mchip_sync(reg);
 444         return readl(meye.mchip_mmregs + reg);
 445 }
 446
 447 /* wait for a register to become a particular value */
 448 static inline int mchip_delay(u32 reg, u32 v)
 449 {
 450         int n = 10;
 451         while (--n && mchip_read(reg) != v)
 452                 udelay(1);
 453         return n;
 454 }
 455
 456 /* setup subsampling */
 457 static void mchip_subsample(void)
 458 {
 459         mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
 460         mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
 461         mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
 462         mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
 463         mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
 464         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
 465 }
 466
 467 /* set the framerate into the mchip */
 468 static void mchip_set_framerate(void)
 469 {
 470         mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
 471 }
 472
 473 /* load some huffman and quantisation tables into the VRJ chip ready
 474    for JPEG compression */
 475 static void mchip_load_tables(void)
 476 {
 477         int i;
 478         int length;
 479         u16 *tables;
 480
 481         tables = jpeg_huffman_tables(&length);
 482         for (i = 0; i < length; i++)
 483                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 484
 485         tables = jpeg_quantisation_tables(&length, meye.params.quality);
 486         for (i = 0; i < length; i++)
 487                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 488 }
 489
 490 /* setup the VRJ parameters in the chip */
 491 static void mchip_vrj_setup(u8 mode)
 492 {
 493         mchip_set(MCHIP_VRJ_BUS_MODE, 5);
 494         mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
 495         mchip_set(MCHIP_VRJ_PDAT_USE, 1);
 496         mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
 497         mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
 498         mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
 499         mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
 500         mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
 501         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
 502         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
 503         mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
 504         mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
 505         mchip_set(MCHIP_VRJ_SOF1, 0x601);
 506         mchip_set(MCHIP_VRJ_SOF2, 0x1502);
 507         mchip_set(MCHIP_VRJ_SOF3, 0x1503);
 508         mchip_set(MCHIP_VRJ_SOF4, 0x1596);
 509         mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
 510
 511         mchip_load_tables();
 512 }
 513
 514 /* sets the DMA parameters into the chip */
 515 static void mchip_dma_setup(dma_addr_t dma_addr)
 516 {
 517         int i;
 518
 519         mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
 520         for (i = 0; i < 4; i++)
 521                 mchip_set(MCHIP_MM_FIR(i), 0);
 522         meye.mchip_fnum = 0;
 523 }
 524
 525 /* setup for DMA transfers - also zeros the framebuffer */
 526 static int mchip_dma_alloc(void)
 527 {
 528         if (!meye.mchip_dmahandle)
 529                 if (ptable_alloc())
 530                         return -1;
 531         return 0;
 532 }
 533
 534 /* frees the DMA buffer */
 535 static void mchip_dma_free(void)
 536 {
 537         if (meye.mchip_dmahandle) {
 538                 mchip_dma_setup(0);
 539                 ptable_free();
 540         }
 541 }
 542
 543 /* stop any existing HIC action and wait for any dma to complete then
 544    reset the dma engine */
 545 static void mchip_hic_stop(void)
 546 {
 547         int i, j;
 548
 549         meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
 550         if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
 551                 return;
 552         for (i = 0; i < 20; ++i) {
 553                 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
 554                 mchip_delay(MCHIP_HIC_CMD, 0);
 555                 for (j = 0; j < 100; ++j) {
 556                         if (mchip_delay(MCHIP_HIC_STATUS,
 557                                         MCHIP_HIC_STATUS_IDLE))
 558                                 return;
 559                         msleep(1);
 560                 }
 561                 printk(KERN_ERR "meye: need to reset HIC!\n");
 562
 563                 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
 564                 msleep(250);
 565         }
 566         printk(KERN_ERR "meye: resetting HIC hanged!\n");
 567 }
 568
 569 /****************************************************************************/
 570 /* MCHIP frame processing functions                                         */
 571 /****************************************************************************/
 572
 573 /* get the next ready frame from the dma engine */
 574 static u32 mchip_get_frame(void)
 575 {
 576         return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
 577 }
 578
 579 /* frees the current frame from the dma engine */
 580 static void mchip_free_frame(void)
 581 {
 582         mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
 583         meye.mchip_fnum++;
 584         meye.mchip_fnum %= 4;
 585 }
 586
 587 /* read one frame from the framebuffer assuming it was captured using
 588    a uncompressed transfer */
 589 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
 590 {
 591         int pt_id;
 592
 593         pt_id = (v >> 17) & 0x3FF;
 594
 595         ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
 596 }
 597
 598 /* read a compressed frame from the framebuffer */
 599 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
 600 {
 601         int pt_start, pt_end, trailer;
 602         int fsize;
 603         int i;
 604
 605         pt_start = (v >> 19) & 0xFF;
 606         pt_end = (v >> 11) & 0xFF;
 607         trailer = (v >> 1) & 0x3FF;
 608
 609         if (pt_end < pt_start)
 610                 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
 611                         pt_end * PAGE_SIZE + trailer * 4;
 612         else
 613                 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
 614
 615         if (fsize > size) {
 616                 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
 617                        fsize);
 618                 return -1;
 619         }
 620
 621         ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
 622
 623 #ifdef MEYE_JPEG_CORRECTION
 624
 625         /* Some mchip generated jpeg frames are incorrect. In most
 626          * (all ?) of those cases, the final EOI (0xff 0xd9) marker
 627          * is not present at the end of the frame.
 628          *
 629          * Since adding the final marker is not enough to restore
 630          * the jpeg integrity, we drop the frame.
 631          */
 632
 633         for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
 634
 635         if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
 636                 return -1;
 637
 638 #endif
 639
 640         return fsize;
 641 }
 642
 643 /* take a picture into SDRAM */
 644 static void mchip_take_picture(void)
 645 {
 646         int i;
 647
 648         mchip_hic_stop();
 649         mchip_subsample();
 650         mchip_dma_setup(meye.mchip_dmahandle);
 651
 652         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
 653         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 654
 655         mchip_delay(MCHIP_HIC_CMD, 0);
 656
 657         for (i = 0; i < 100; ++i) {
 658                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 659                         break;
 660                 msleep(1);
 661         }
 662 }
 663
 664 /* dma a previously taken picture into a buffer */
 665 static void mchip_get_picture(u8 *buf, int bufsize)
 666 {
 667         u32 v;
 668         int i;
 669
 670         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
 671         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 672
 673         mchip_delay(MCHIP_HIC_CMD, 0);
 674         for (i = 0; i < 100; ++i) {
 675                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 676                         break;
 677                 msleep(1);
 678         }
 679         for (i = 0; i < 4; ++i) {
 680                 v = mchip_get_frame();
 681                 if (v & MCHIP_MM_FIR_RDY) {
 682                         mchip_cont_read_frame(v, buf, bufsize);
 683                         break;
 684                 }
 685                 mchip_free_frame();
 686         }
 687 }
 688
 689 /* start continuous dma capture */
 690 static void mchip_continuous_start(void)
 691 {
 692         mchip_hic_stop();
 693         mchip_subsample();
 694         mchip_set_framerate();
 695         mchip_dma_setup(meye.mchip_dmahandle);
 696
 697         meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
 698
 699         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
 700         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 701
 702         mchip_delay(MCHIP_HIC_CMD, 0);
 703 }
 704
 705 /* compress one frame into a buffer */
 706 static int mchip_compress_frame(u8 *buf, int bufsize)
 707 {
 708         u32 v;
 709         int len = -1, i;
 710
 711         mchip_vrj_setup(0x3f);
 712         udelay(50);
 713
 714         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
 715         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 716
 717         mchip_delay(MCHIP_HIC_CMD, 0);
 718         for (i = 0; i < 100; ++i) {
 719                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 720                         break;
 721                 msleep(1);
 722         }
 723
 724         for (i = 0; i < 4; ++i) {
 725                 v = mchip_get_frame();
 726                 if (v & MCHIP_MM_FIR_RDY) {
 727                         len = mchip_comp_read_frame(v, buf, bufsize);
 728                         break;
 729                 }
 730                 mchip_free_frame();
 731         }
 732         return len;
 733 }
 734
 735 #if 0
 736 /* uncompress one image into a buffer */
 737 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
 738 {
 739         mchip_vrj_setup(0x3f);
 740         udelay(50);
 741
 742         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
 743         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 744
 745         mchip_delay(MCHIP_HIC_CMD, 0);
 746
 747         return mchip_comp_read_frame(buf, bufsize);
 748 }
 749 #endif
 750
 751 /* start continuous compressed capture */
 752 static void mchip_cont_compression_start(void)
 753 {
 754         mchip_hic_stop();
 755         mchip_vrj_setup(0x3f);
 756         mchip_subsample();
 757         mchip_set_framerate();
 758         mchip_dma_setup(meye.mchip_dmahandle);
 759
 760         meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
 761
 762         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
 763         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 764
 765         mchip_delay(MCHIP_HIC_CMD, 0);
 766 }
 767
 768 /****************************************************************************/
 769 /* Interrupt handling                                                       */
 770 /****************************************************************************/
 771
 772 static irqreturn_t meye_irq(int irq, void *dev_id)
 773 {
 774         u32 v;
 775         int reqnr;
 776         static int sequence;
 777
 778         v = mchip_read(MCHIP_MM_INTA);
 779
 780         if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
 781             meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
 782                 return IRQ_NONE;
 783
 784 again:
 785         v = mchip_get_frame();
 786         if (!(v & MCHIP_MM_FIR_RDY))
 787                 return IRQ_HANDLED;
 788
 789         if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
 790                 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
 791                               sizeof(int), &meye.grabq_lock) != sizeof(int)) {
 792                         mchip_free_frame();
 793                         return IRQ_HANDLED;
 794                 }
 795                 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
 796                                       mchip_hsize() * mchip_vsize() * 2);
 797                 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
 798                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 799                 meye.grab_buffer[reqnr].ts = ktime_get_ns();
 800                 meye.grab_buffer[reqnr].sequence = sequence++;
 801                 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
 802                                 sizeof(int), &meye.doneq_lock);
 803                 wake_up_interruptible(&meye.proc_list);
 804         } else {
 805                 int size;
 806                 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
 807                 if (size == -1) {
 808                         mchip_free_frame();
 809                         goto again;
 810                 }
 811                 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
 812                               sizeof(int), &meye.grabq_lock) != sizeof(int)) {
 813                         mchip_free_frame();
 814                         goto again;
 815                 }
 816                 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
 817                        size);
 818                 meye.grab_buffer[reqnr].size = size;
 819                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 820                 meye.grab_buffer[reqnr].ts = ktime_get_ns();
 821                 meye.grab_buffer[reqnr].sequence = sequence++;
 822                 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
 823                                 sizeof(int), &meye.doneq_lock);
 824                 wake_up_interruptible(&meye.proc_list);
 825         }
 826         mchip_free_frame();
 827         goto again;
 828 }
 829
 830 /****************************************************************************/
 831 /* video4linux integration                                                  */
 832 /****************************************************************************/
 833
 834 static int meye_open(struct file *file)
 835 {
 836         int i;
 837
 838         if (test_and_set_bit(0, &meye.in_use))
 839                 return -EBUSY;
 840
 841         mchip_hic_stop();
 842
 843         if (mchip_dma_alloc()) {
 844                 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
 845                 clear_bit(0, &meye.in_use);
 846                 return -ENOBUFS;
 847         }
 848
 849         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
 850                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
 851         kfifo_reset(&meye.grabq);
 852         kfifo_reset(&meye.doneq);
 853         return v4l2_fh_open(file);
 854 }
 855
 856 static int meye_release(struct file *file)
 857 {
 858         mchip_hic_stop();
 859         mchip_dma_free();
 860         clear_bit(0, &meye.in_use);
 861         return v4l2_fh_release(file);
 862 }
 863
 864 static int meyeioc_g_params(struct meye_params *p)
 865 {
 866         *p = meye.params;
 867         return 0;
 868 }
 869
 870 static int meyeioc_s_params(struct meye_params *jp)
 871 {
 872         if (jp->subsample > 1)
 873                 return -EINVAL;
 874
 875         if (jp->quality > 10)
 876                 return -EINVAL;
 877
 878         if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
 879                 return -EINVAL;
 880
 881         if (jp->framerate > 31)
 882                 return -EINVAL;
 883
 884         mutex_lock(&meye.lock);
 885
 886         if (meye.params.subsample != jp->subsample ||
 887             meye.params.quality != jp->quality)
 888                 mchip_hic_stop();       /* need restart */
 889
 890         meye.params = *jp;
 891         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
 892                               meye.params.sharpness);
 893         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
 894                               meye.params.agc);
 895         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
 896                               meye.params.picture);
 897         mutex_unlock(&meye.lock);
 898
 899         return 0;
 900 }
 901
 902 static int meyeioc_qbuf_capt(int *nb)
 903 {
 904         if (!meye.grab_fbuffer)
 905                 return -EINVAL;
 906
 907         if (*nb >= gbuffers)
 908                 return -EINVAL;
 909
 910         if (*nb < 0) {
 911                 /* stop capture */
 912                 mchip_hic_stop();
 913                 return 0;
 914         }
 915
 916         if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
 917                 return -EBUSY;
 918
 919         mutex_lock(&meye.lock);
 920
 921         if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
 922                 mchip_cont_compression_start();
 923
 924         meye.grab_buffer[*nb].state = MEYE_BUF_USING;
 925         kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
 926                          &meye.grabq_lock);
 927         mutex_unlock(&meye.lock);
 928
 929         return 0;
 930 }
 931
 932 static int meyeioc_sync(struct file *file, void *fh, int *i)
 933 {
 934         int unused;
 935
 936         if (*i < 0 || *i >= gbuffers)
 937                 return -EINVAL;
 938
 939         mutex_lock(&meye.lock);
 940         switch (meye.grab_buffer[*i].state) {
 941
 942         case MEYE_BUF_UNUSED:
 943                 mutex_unlock(&meye.lock);
 944                 return -EINVAL;
 945         case MEYE_BUF_USING:
 946                 if (file->f_flags & O_NONBLOCK) {
 947                         mutex_unlock(&meye.lock);
 948                         return -EAGAIN;
 949                 }
 950                 if (wait_event_interruptible(meye.proc_list,
 951                         (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
 952                         mutex_unlock(&meye.lock);
 953                         return -EINTR;
 954                 }
 955                 /* fall through */
 956         case MEYE_BUF_DONE:
 957                 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
 958                 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
 959                                 sizeof(int), &meye.doneq_lock) != sizeof(int))
 960                                         break;
 961         }
 962         *i = meye.grab_buffer[*i].size;
 963         mutex_unlock(&meye.lock);
 964         return 0;
 965 }
 966
 967 static int meyeioc_stillcapt(void)
 968 {
 969         if (!meye.grab_fbuffer)
 970                 return -EINVAL;
 971
 972         if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
 973                 return -EBUSY;
 974
 975         mutex_lock(&meye.lock);
 976         meye.grab_buffer[0].state = MEYE_BUF_USING;
 977         mchip_take_picture();
 978
 979         mchip_get_picture(meye.grab_fbuffer,
 980                         mchip_hsize() * mchip_vsize() * 2);
 981
 982         meye.grab_buffer[0].state = MEYE_BUF_DONE;
 983         mutex_unlock(&meye.lock);
 984
 985         return 0;
 986 }
 987
 988 static int meyeioc_stilljcapt(int *len)
 989 {
 990         if (!meye.grab_fbuffer)
 991                 return -EINVAL;
 992
 993         if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
 994                 return -EBUSY;
 995
 996         mutex_lock(&meye.lock);
 997         meye.grab_buffer[0].state = MEYE_BUF_USING;
 998         *len = -1;
 999
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         sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1016
1017         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
1018                             V4L2_CAP_STREAMING;
1019         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1020
1021         return 0;
1022 }
1023
1024 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1025 {
1026         if (i->index != 0)
1027                 return -EINVAL;
1028
1029         strscpy(i->name, "Camera", sizeof(i->name));
1030         i->type = V4L2_INPUT_TYPE_CAMERA;
1031
1032         return 0;
1033 }
1034
1035 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1036 {
1037         *i = 0;
1038         return 0;
1039 }
1040
1041 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1042 {
1043         if (i != 0)
1044                 return -EINVAL;
1045
1046         return 0;
1047 }
1048
1049 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1050 {
1051         mutex_lock(&meye.lock);
1052         switch (ctrl->id) {
1053         case V4L2_CID_BRIGHTNESS:
1054                 sony_pic_camera_command(
1055                         SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1056                 meye.brightness = ctrl->val << 10;
1057                 break;
1058         case V4L2_CID_HUE:
1059                 sony_pic_camera_command(
1060                         SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1061                 meye.hue = ctrl->val << 10;
1062                 break;
1063         case V4L2_CID_CONTRAST:
1064                 sony_pic_camera_command(
1065                         SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1066                 meye.contrast = ctrl->val << 10;
1067                 break;
1068         case V4L2_CID_SATURATION:
1069                 sony_pic_camera_command(
1070                         SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1071                 meye.colour = ctrl->val << 10;
1072                 break;
1073         case V4L2_CID_MEYE_AGC:
1074                 sony_pic_camera_command(
1075                         SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1076                 meye.params.agc = ctrl->val;
1077                 break;
1078         case V4L2_CID_SHARPNESS:
1079                 sony_pic_camera_command(
1080                         SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1081                 meye.params.sharpness = ctrl->val;
1082                 break;
1083         case V4L2_CID_MEYE_PICTURE:
1084                 sony_pic_camera_command(
1085                         SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1086                 meye.params.picture = ctrl->val;
1087                 break;
1088         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1089                 meye.params.quality = ctrl->val;
1090                 break;
1091         case V4L2_CID_MEYE_FRAMERATE:
1092                 meye.params.framerate = ctrl->val;
1093                 break;
1094         default:
1095                 mutex_unlock(&meye.lock);
1096                 return -EINVAL;
1097         }
1098         mutex_unlock(&meye.lock);
1099
1100         return 0;
1101 }
1102
1103 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1104                                 struct v4l2_fmtdesc *f)
1105 {
1106         if (f->index > 1)
1107                 return -EINVAL;
1108
1109         if (f->index == 0) {
1110                 /* standard YUV 422 capture */
1111                 f->flags = 0;
1112                 strscpy(f->description, "YUV422", sizeof(f->description));
1113                 f->pixelformat = V4L2_PIX_FMT_YUYV;
1114         } else {
1115                 /* compressed MJPEG capture */
1116                 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1117                 strscpy(f->description, "MJPEG", sizeof(f->description));
1118                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1119         }
1120
1121         return 0;
1122 }
1123
1124 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1125                                 struct v4l2_format *f)
1126 {
1127         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1128             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1129                 return -EINVAL;
1130
1131         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1132             f->fmt.pix.field != V4L2_FIELD_NONE)
1133                 return -EINVAL;
1134
1135         f->fmt.pix.field = V4L2_FIELD_NONE;
1136
1137         if (f->fmt.pix.width <= 320) {
1138                 f->fmt.pix.width = 320;
1139                 f->fmt.pix.height = 240;
1140         } else {
1141                 f->fmt.pix.width = 640;
1142                 f->fmt.pix.height = 480;
1143         }
1144
1145         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1146         f->fmt.pix.sizeimage = f->fmt.pix.height *
1147                                f->fmt.pix.bytesperline;
1148         f->fmt.pix.colorspace = 0;
1149
1150         return 0;
1151 }
1152
1153 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1154                                     struct v4l2_format *f)
1155 {
1156         switch (meye.mchip_mode) {
1157         case MCHIP_HIC_MODE_CONT_OUT:
1158         default:
1159                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1160                 break;
1161         case MCHIP_HIC_MODE_CONT_COMP:
1162                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1163                 break;
1164         }
1165
1166         f->fmt.pix.field = V4L2_FIELD_NONE;
1167         f->fmt.pix.width = mchip_hsize();
1168         f->fmt.pix.height = mchip_vsize();
1169         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1170         f->fmt.pix.sizeimage = f->fmt.pix.height *
1171                                f->fmt.pix.bytesperline;
1172
1173         return 0;
1174 }
1175
1176 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1177                                     struct v4l2_format *f)
1178 {
1179         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1180             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1181                 return -EINVAL;
1182
1183         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1184             f->fmt.pix.field != V4L2_FIELD_NONE)
1185                 return -EINVAL;
1186
1187         f->fmt.pix.field = V4L2_FIELD_NONE;
1188         mutex_lock(&meye.lock);
1189
1190         if (f->fmt.pix.width <= 320) {
1191                 f->fmt.pix.width = 320;
1192                 f->fmt.pix.height = 240;
1193                 meye.params.subsample = 1;
1194         } else {
1195                 f->fmt.pix.width = 640;
1196                 f->fmt.pix.height = 480;
1197                 meye.params.subsample = 0;
1198         }
1199
1200         switch (f->fmt.pix.pixelformat) {
1201         case V4L2_PIX_FMT_YUYV:
1202                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1203                 break;
1204         case V4L2_PIX_FMT_MJPEG:
1205                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1206                 break;
1207         }
1208
1209         mutex_unlock(&meye.lock);
1210         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1211         f->fmt.pix.sizeimage = f->fmt.pix.height *
1212                                f->fmt.pix.bytesperline;
1213         f->fmt.pix.colorspace = 0;
1214
1215         return 0;
1216 }
1217
1218 static int vidioc_reqbufs(struct file *file, void *fh,
1219                                 struct v4l2_requestbuffers *req)
1220 {
1221         int i;
1222
1223         if (req->memory != V4L2_MEMORY_MMAP)
1224                 return -EINVAL;
1225
1226         if (meye.grab_fbuffer && req->count == gbuffers) {
1227                 /* already allocated, no modifications */
1228                 return 0;
1229         }
1230
1231         mutex_lock(&meye.lock);
1232         if (meye.grab_fbuffer) {
1233                 for (i = 0; i < gbuffers; i++)
1234                         if (meye.vma_use_count[i]) {
1235                                 mutex_unlock(&meye.lock);
1236                                 return -EINVAL;
1237                         }
1238                 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1239                 meye.grab_fbuffer = NULL;
1240         }
1241
1242         gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1243         req->count = gbuffers;
1244         meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1245
1246         if (!meye.grab_fbuffer) {
1247                 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1248                 mutex_unlock(&meye.lock);
1249                 return -ENOMEM;
1250         }
1251
1252         for (i = 0; i < gbuffers; i++)
1253                 meye.vma_use_count[i] = 0;
1254
1255         mutex_unlock(&meye.lock);
1256
1257         return 0;
1258 }
1259
1260 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1261 {
1262         unsigned int index = buf->index;
1263
1264         if (index >= gbuffers)
1265                 return -EINVAL;
1266
1267         buf->bytesused = meye.grab_buffer[index].size;
1268         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1269
1270         if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1271                 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1272
1273         if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1274                 buf->flags |= V4L2_BUF_FLAG_DONE;
1275
1276         buf->field = V4L2_FIELD_NONE;
1277         buf->timestamp = ns_to_timeval(meye.grab_buffer[index].ts);
1278         buf->sequence = meye.grab_buffer[index].sequence;
1279         buf->memory = V4L2_MEMORY_MMAP;
1280         buf->m.offset = index * gbufsize;
1281         buf->length = gbufsize;
1282
1283         return 0;
1284 }
1285
1286 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1287 {
1288         if (buf->memory != V4L2_MEMORY_MMAP)
1289                 return -EINVAL;
1290
1291         if (buf->index >= gbuffers)
1292                 return -EINVAL;
1293
1294         if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1295                 return -EINVAL;
1296
1297         mutex_lock(&meye.lock);
1298         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1299         buf->flags &= ~V4L2_BUF_FLAG_DONE;
1300         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1301         kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1302                         sizeof(int), &meye.grabq_lock);
1303         mutex_unlock(&meye.lock);
1304
1305         return 0;
1306 }
1307
1308 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1309 {
1310         int reqnr;
1311
1312         if (buf->memory != V4L2_MEMORY_MMAP)
1313                 return -EINVAL;
1314
1315         mutex_lock(&meye.lock);
1316
1317         if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1318                 mutex_unlock(&meye.lock);
1319                 return -EAGAIN;
1320         }
1321
1322         if (wait_event_interruptible(meye.proc_list,
1323                                      kfifo_len(&meye.doneq) != 0) < 0) {
1324                 mutex_unlock(&meye.lock);
1325                 return -EINTR;
1326         }
1327
1328         if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1329                        sizeof(int), &meye.doneq_lock)) {
1330                 mutex_unlock(&meye.lock);
1331                 return -EBUSY;
1332         }
1333
1334         if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1335                 mutex_unlock(&meye.lock);
1336                 return -EINVAL;
1337         }
1338
1339         buf->index = reqnr;
1340         buf->bytesused = meye.grab_buffer[reqnr].size;
1341         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1342         buf->field = V4L2_FIELD_NONE;
1343         buf->timestamp = ns_to_timeval(meye.grab_buffer[reqnr].ts);
1344         buf->sequence = meye.grab_buffer[reqnr].sequence;
1345         buf->memory = V4L2_MEMORY_MMAP;
1346         buf->m.offset = reqnr * gbufsize;
1347         buf->length = gbufsize;
1348         meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1349         mutex_unlock(&meye.lock);
1350
1351         return 0;
1352 }
1353
1354 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1355 {
1356         mutex_lock(&meye.lock);
1357
1358         switch (meye.mchip_mode) {
1359         case MCHIP_HIC_MODE_CONT_OUT:
1360                 mchip_continuous_start();
1361                 break;
1362         case MCHIP_HIC_MODE_CONT_COMP:
1363                 mchip_cont_compression_start();
1364                 break;
1365         default:
1366                 mutex_unlock(&meye.lock);
1367                 return -EINVAL;
1368         }
1369
1370         mutex_unlock(&meye.lock);
1371
1372         return 0;
1373 }
1374
1375 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1376 {
1377         mutex_lock(&meye.lock);
1378         mchip_hic_stop();
1379         kfifo_reset(&meye.grabq);
1380         kfifo_reset(&meye.doneq);
1381
1382         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1383                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1384
1385         mutex_unlock(&meye.lock);
1386         return 0;
1387 }
1388
1389 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1390                            unsigned int cmd, void *arg)
1391 {
1392         switch (cmd) {
1393         case MEYEIOC_G_PARAMS:
1394                 return meyeioc_g_params((struct meye_params *) arg);
1395
1396         case MEYEIOC_S_PARAMS:
1397                 return meyeioc_s_params((struct meye_params *) arg);
1398
1399         case MEYEIOC_QBUF_CAPT:
1400                 return meyeioc_qbuf_capt((int *) arg);
1401
1402         case MEYEIOC_SYNC:
1403                 return meyeioc_sync(file, fh, (int *) arg);
1404
1405         case MEYEIOC_STILLCAPT:
1406                 return meyeioc_stillcapt();
1407
1408         case MEYEIOC_STILLJCAPT:
1409                 return meyeioc_stilljcapt((int *) arg);
1410
1411         default:
1412                 return -ENOTTY;
1413         }
1414
1415 }
1416
1417 static __poll_t meye_poll(struct file *file, poll_table *wait)
1418 {
1419         __poll_t res = v4l2_ctrl_poll(file, wait);
1420
1421         mutex_lock(&meye.lock);
1422         poll_wait(file, &meye.proc_list, wait);
1423         if (kfifo_len(&meye.doneq))
1424                 res |= EPOLLIN | EPOLLRDNORM;
1425         mutex_unlock(&meye.lock);
1426         return res;
1427 }
1428
1429 static void meye_vm_open(struct vm_area_struct *vma)
1430 {
1431         long idx = (long)vma->vm_private_data;
1432         meye.vma_use_count[idx]++;
1433 }
1434
1435 static void meye_vm_close(struct vm_area_struct *vma)
1436 {
1437         long idx = (long)vma->vm_private_data;
1438         meye.vma_use_count[idx]--;
1439 }
1440
1441 static const struct vm_operations_struct meye_vm_ops = {
1442         .open           = meye_vm_open,
1443         .close          = meye_vm_close,
1444 };
1445
1446 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1447 {
1448         unsigned long start = vma->vm_start;
1449         unsigned long size = vma->vm_end - vma->vm_start;
1450         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1451         unsigned long page, pos;
1452
1453         mutex_lock(&meye.lock);
1454         if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
1455                 mutex_unlock(&meye.lock);
1456                 return -EINVAL;
1457         }
1458         if (!meye.grab_fbuffer) {
1459                 int i;
1460
1461                 /* lazy allocation */
1462                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1463                 if (!meye.grab_fbuffer) {
1464                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1465                         mutex_unlock(&meye.lock);
1466                         return -ENOMEM;
1467                 }
1468                 for (i = 0; i < gbuffers; i++)
1469                         meye.vma_use_count[i] = 0;
1470         }
1471         pos = (unsigned long)meye.grab_fbuffer + offset;
1472
1473         while (size > 0) {
1474                 page = vmalloc_to_pfn((void *)pos);
1475                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1476                         mutex_unlock(&meye.lock);
1477                         return -EAGAIN;
1478                 }
1479                 start += PAGE_SIZE;
1480                 pos += PAGE_SIZE;
1481                 if (size > PAGE_SIZE)
1482                         size -= PAGE_SIZE;
1483                 else
1484                         size = 0;
1485         }
1486
1487         vma->vm_ops = &meye_vm_ops;
1488         vma->vm_flags &= ~VM_IO;        /* not I/O memory */
1489         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1490         vma->vm_private_data = (void *) (offset / gbufsize);
1491         meye_vm_open(vma);
1492
1493         mutex_unlock(&meye.lock);
1494         return 0;
1495 }
1496
1497 static const struct v4l2_file_operations meye_fops = {
1498         .owner          = THIS_MODULE,
1499         .open           = meye_open,
1500         .release        = meye_release,
1501         .mmap           = meye_mmap,
1502         .unlocked_ioctl = video_ioctl2,
1503         .poll           = meye_poll,
1504 };
1505
1506 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1507         .vidioc_querycap        = vidioc_querycap,
1508         .vidioc_enum_input      = vidioc_enum_input,
1509         .vidioc_g_input         = vidioc_g_input,
1510         .vidioc_s_input         = vidioc_s_input,
1511         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1512         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1513         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1514         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1515         .vidioc_reqbufs         = vidioc_reqbufs,
1516         .vidioc_querybuf        = vidioc_querybuf,
1517         .vidioc_qbuf            = vidioc_qbuf,
1518         .vidioc_dqbuf           = vidioc_dqbuf,
1519         .vidioc_streamon        = vidioc_streamon,
1520         .vidioc_streamoff       = vidioc_streamoff,
1521         .vidioc_log_status      = v4l2_ctrl_log_status,
1522         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1523         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1524         .vidioc_default         = vidioc_default,
1525 };
1526
1527 static const struct video_device meye_template = {
1528         .name           = "meye",
1529         .fops           = &meye_fops,
1530         .ioctl_ops      = &meye_ioctl_ops,
1531         .release        = video_device_release_empty,
1532 };
1533
1534 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1535         .s_ctrl = meye_s_ctrl,
1536 };
1537
1538 #ifdef CONFIG_PM
1539 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1540 {
1541         pci_save_state(pdev);
1542         meye.pm_mchip_mode = meye.mchip_mode;
1543         mchip_hic_stop();
1544         mchip_set(MCHIP_MM_INTA, 0x0);
1545         return 0;
1546 }
1547
1548 static int meye_resume(struct pci_dev *pdev)
1549 {
1550         pci_restore_state(pdev);
1551         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1552
1553         mchip_delay(MCHIP_HIC_CMD, 0);
1554         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1555         msleep(1);
1556         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1557         msleep(1);
1558         mchip_set(MCHIP_MM_PCI_MODE, 5);
1559         msleep(1);
1560         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1561
1562         switch (meye.pm_mchip_mode) {
1563         case MCHIP_HIC_MODE_CONT_OUT:
1564                 mchip_continuous_start();
1565                 break;
1566         case MCHIP_HIC_MODE_CONT_COMP:
1567                 mchip_cont_compression_start();
1568                 break;
1569         }
1570         return 0;
1571 }
1572 #endif
1573
1574 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1575 {
1576         static const struct v4l2_ctrl_config ctrl_agc = {
1577                 .id = V4L2_CID_MEYE_AGC,
1578                 .type = V4L2_CTRL_TYPE_INTEGER,
1579                 .ops = &meye_ctrl_ops,
1580                 .name = "AGC",
1581                 .max = 63,
1582                 .step = 1,
1583                 .def = 48,
1584                 .flags = V4L2_CTRL_FLAG_SLIDER,
1585         };
1586         static const struct v4l2_ctrl_config ctrl_picture = {
1587                 .id = V4L2_CID_MEYE_PICTURE,
1588                 .type = V4L2_CTRL_TYPE_INTEGER,
1589                 .ops = &meye_ctrl_ops,
1590                 .name = "Picture",
1591                 .max = 63,
1592                 .step = 1,
1593         };
1594         static const struct v4l2_ctrl_config ctrl_framerate = {
1595                 .id = V4L2_CID_MEYE_FRAMERATE,
1596                 .type = V4L2_CTRL_TYPE_INTEGER,
1597                 .ops = &meye_ctrl_ops,
1598                 .name = "Framerate",
1599                 .max = 31,
1600                 .step = 1,
1601         };
1602         struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1603         int ret = -EBUSY;
1604         unsigned long mchip_adr;
1605
1606         if (meye.mchip_dev != NULL) {
1607                 printk(KERN_ERR "meye: only one device allowed!\n");
1608                 return ret;
1609         }
1610
1611         ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1612         if (ret < 0) {
1613                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1614                 return ret;
1615         }
1616         ret = -ENOMEM;
1617         meye.mchip_dev = pcidev;
1618
1619         meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
1620         if (!meye.grab_temp)
1621                 goto outvmalloc;
1622
1623         spin_lock_init(&meye.grabq_lock);
1624         if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1625                         GFP_KERNEL))
1626                 goto outkfifoalloc1;
1627
1628         spin_lock_init(&meye.doneq_lock);
1629         if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1630                         GFP_KERNEL))
1631                 goto outkfifoalloc2;
1632
1633         meye.vdev = meye_template;
1634         meye.vdev.v4l2_dev = &meye.v4l2_dev;
1635
1636         ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1637         if (ret) {
1638                 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1639                 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1640                 goto outsonypienable;
1641         }
1642
1643         ret = pci_enable_device(meye.mchip_dev);
1644         if (ret) {
1645                 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1646                 goto outenabledev;
1647         }
1648
1649         ret = -EIO;
1650         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1651         if (!mchip_adr) {
1652                 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1653                 goto outregions;
1654         }
1655         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1656                                 pci_resource_len(meye.mchip_dev, 0),
1657                                 "meye")) {
1658                 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1659                 goto outregions;
1660         }
1661         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1662         if (!meye.mchip_mmregs) {
1663                 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1664                 goto outremap;
1665         }
1666
1667         meye.mchip_irq = pcidev->irq;
1668         if (request_irq(meye.mchip_irq, meye_irq,
1669                         IRQF_SHARED, "meye", meye_irq)) {
1670                 v4l2_err(v4l2_dev, "request_irq failed\n");
1671                 goto outreqirq;
1672         }
1673
1674         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1675         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1676
1677         pci_set_master(meye.mchip_dev);
1678
1679         /* Ask the camera to perform a soft reset. */
1680         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1681
1682         mchip_delay(MCHIP_HIC_CMD, 0);
1683         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1684
1685         msleep(1);
1686         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1687
1688         msleep(1);
1689         mchip_set(MCHIP_MM_PCI_MODE, 5);
1690
1691         msleep(1);
1692         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1693
1694         mutex_init(&meye.lock);
1695         init_waitqueue_head(&meye.proc_list);
1696
1697         v4l2_ctrl_handler_init(&meye.hdl, 3);
1698         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1699                           V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1700         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1701                           V4L2_CID_HUE, 0, 63, 1, 32);
1702         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1703                           V4L2_CID_CONTRAST, 0, 63, 1, 32);
1704         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1705                           V4L2_CID_SATURATION, 0, 63, 1, 32);
1706         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1707         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1708                           V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1709         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1710         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1711                           V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1712         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1713         if (meye.hdl.error) {
1714                 v4l2_err(v4l2_dev, "couldn't register controls\n");
1715                 goto outvideoreg;
1716         }
1717
1718         v4l2_ctrl_handler_setup(&meye.hdl);
1719         meye.vdev.ctrl_handler = &meye.hdl;
1720
1721         if (video_register_device(&meye.vdev, VFL_TYPE_GRABBER,
1722                                   video_nr) < 0) {
1723                 v4l2_err(v4l2_dev, "video_register_device failed\n");
1724                 goto outvideoreg;
1725         }
1726
1727         v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1728                MEYE_DRIVER_VERSION);
1729         v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1730                meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1731
1732         return 0;
1733
1734 outvideoreg:
1735         v4l2_ctrl_handler_free(&meye.hdl);
1736         free_irq(meye.mchip_irq, meye_irq);
1737 outreqirq:
1738         iounmap(meye.mchip_mmregs);
1739 outremap:
1740         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1741                            pci_resource_len(meye.mchip_dev, 0));
1742 outregions:
1743         pci_disable_device(meye.mchip_dev);
1744 outenabledev:
1745         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1746 outsonypienable:
1747         kfifo_free(&meye.doneq);
1748 outkfifoalloc2:
1749         kfifo_free(&meye.grabq);
1750 outkfifoalloc1:
1751         vfree(meye.grab_temp);
1752 outvmalloc:
1753         return ret;
1754 }
1755
1756 static void meye_remove(struct pci_dev *pcidev)
1757 {
1758         video_unregister_device(&meye.vdev);
1759
1760         mchip_hic_stop();
1761
1762         mchip_dma_free();
1763
1764         /* disable interrupts */
1765         mchip_set(MCHIP_MM_INTA, 0x0);
1766
1767         free_irq(meye.mchip_irq, meye_irq);
1768
1769         iounmap(meye.mchip_mmregs);
1770
1771         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1772                            pci_resource_len(meye.mchip_dev, 0));
1773
1774         pci_disable_device(meye.mchip_dev);
1775
1776         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1777
1778         kfifo_free(&meye.doneq);
1779         kfifo_free(&meye.grabq);
1780
1781         vfree(meye.grab_temp);
1782
1783         if (meye.grab_fbuffer) {
1784                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1785                 meye.grab_fbuffer = NULL;
1786         }
1787
1788         printk(KERN_INFO "meye: removed\n");
1789 }
1790
1791 static const struct pci_device_id meye_pci_tbl[] = {
1792         { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1793         { }
1794 };
1795
1796 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1797
1798 static struct pci_driver meye_driver = {
1799         .name           = "meye",
1800         .id_table       = meye_pci_tbl,
1801         .probe          = meye_probe,
1802         .remove         = meye_remove,
1803 #ifdef CONFIG_PM
1804         .suspend        = meye_suspend,
1805         .resume         = meye_resume,
1806 #endif
1807 };
1808
1809 static int __init meye_init(void)
1810 {
1811         gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1812         if (gbufsize > MEYE_MAX_BUFSIZE)
1813                 gbufsize = MEYE_MAX_BUFSIZE;
1814         gbufsize = PAGE_ALIGN(gbufsize);
1815         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1816                          gbuffers,
1817                          gbufsize / 1024, gbuffers * gbufsize / 1024);
1818         return pci_register_driver(&meye_driver);
1819 }
1820
1821 static void __exit meye_exit(void)
1822 {
1823         pci_unregister_driver(&meye_driver);
1824 }
1825
1826 module_init(meye_init);
1827 module_exit(meye_exit);