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                 fallthrough;
 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         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);