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         return 0;
1017 }
1018
1019 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1020 {
1021         if (i->index != 0)
1022                 return -EINVAL;
1023
1024         strscpy(i->name, "Camera", sizeof(i->name));
1025         i->type = V4L2_INPUT_TYPE_CAMERA;
1026
1027         return 0;
1028 }
1029
1030 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1031 {
1032         *i = 0;
1033         return 0;
1034 }
1035
1036 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1037 {
1038         if (i != 0)
1039                 return -EINVAL;
1040
1041         return 0;
1042 }
1043
1044 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1045 {
1046         mutex_lock(&meye.lock);
1047         switch (ctrl->id) {
1048         case V4L2_CID_BRIGHTNESS:
1049                 sony_pic_camera_command(
1050                         SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1051                 meye.brightness = ctrl->val << 10;
1052                 break;
1053         case V4L2_CID_HUE:
1054                 sony_pic_camera_command(
1055                         SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1056                 meye.hue = ctrl->val << 10;
1057                 break;
1058         case V4L2_CID_CONTRAST:
1059                 sony_pic_camera_command(
1060                         SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1061                 meye.contrast = ctrl->val << 10;
1062                 break;
1063         case V4L2_CID_SATURATION:
1064                 sony_pic_camera_command(
1065                         SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1066                 meye.colour = ctrl->val << 10;
1067                 break;
1068         case V4L2_CID_MEYE_AGC:
1069                 sony_pic_camera_command(
1070                         SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1071                 meye.params.agc = ctrl->val;
1072                 break;
1073         case V4L2_CID_SHARPNESS:
1074                 sony_pic_camera_command(
1075                         SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1076                 meye.params.sharpness = ctrl->val;
1077                 break;
1078         case V4L2_CID_MEYE_PICTURE:
1079                 sony_pic_camera_command(
1080                         SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1081                 meye.params.picture = ctrl->val;
1082                 break;
1083         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1084                 meye.params.quality = ctrl->val;
1085                 break;
1086         case V4L2_CID_MEYE_FRAMERATE:
1087                 meye.params.framerate = ctrl->val;
1088                 break;
1089         default:
1090                 mutex_unlock(&meye.lock);
1091                 return -EINVAL;
1092         }
1093         mutex_unlock(&meye.lock);
1094
1095         return 0;
1096 }
1097
1098 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1099                                 struct v4l2_fmtdesc *f)
1100 {
1101         if (f->index > 1)
1102                 return -EINVAL;
1103
1104         if (f->index == 0) {
1105                 /* standard YUV 422 capture */
1106                 f->flags = 0;
1107                 strscpy(f->description, "YUV422", sizeof(f->description));
1108                 f->pixelformat = V4L2_PIX_FMT_YUYV;
1109         } else {
1110                 /* compressed MJPEG capture */
1111                 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1112                 strscpy(f->description, "MJPEG", sizeof(f->description));
1113                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1114         }
1115
1116         return 0;
1117 }
1118
1119 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1120                                 struct v4l2_format *f)
1121 {
1122         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1123             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1124                 return -EINVAL;
1125
1126         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1127             f->fmt.pix.field != V4L2_FIELD_NONE)
1128                 return -EINVAL;
1129
1130         f->fmt.pix.field = V4L2_FIELD_NONE;
1131
1132         if (f->fmt.pix.width <= 320) {
1133                 f->fmt.pix.width = 320;
1134                 f->fmt.pix.height = 240;
1135         } else {
1136                 f->fmt.pix.width = 640;
1137                 f->fmt.pix.height = 480;
1138         }
1139
1140         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1141         f->fmt.pix.sizeimage = f->fmt.pix.height *
1142                                f->fmt.pix.bytesperline;
1143         f->fmt.pix.colorspace = 0;
1144
1145         return 0;
1146 }
1147
1148 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1149                                     struct v4l2_format *f)
1150 {
1151         switch (meye.mchip_mode) {
1152         case MCHIP_HIC_MODE_CONT_OUT:
1153         default:
1154                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1155                 break;
1156         case MCHIP_HIC_MODE_CONT_COMP:
1157                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1158                 break;
1159         }
1160
1161         f->fmt.pix.field = V4L2_FIELD_NONE;
1162         f->fmt.pix.width = mchip_hsize();
1163         f->fmt.pix.height = mchip_vsize();
1164         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1165         f->fmt.pix.sizeimage = f->fmt.pix.height *
1166                                f->fmt.pix.bytesperline;
1167
1168         return 0;
1169 }
1170
1171 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1172                                     struct v4l2_format *f)
1173 {
1174         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1175             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1176                 return -EINVAL;
1177
1178         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1179             f->fmt.pix.field != V4L2_FIELD_NONE)
1180                 return -EINVAL;
1181
1182         f->fmt.pix.field = V4L2_FIELD_NONE;
1183         mutex_lock(&meye.lock);
1184
1185         if (f->fmt.pix.width <= 320) {
1186                 f->fmt.pix.width = 320;
1187                 f->fmt.pix.height = 240;
1188                 meye.params.subsample = 1;
1189         } else {
1190                 f->fmt.pix.width = 640;
1191                 f->fmt.pix.height = 480;
1192                 meye.params.subsample = 0;
1193         }
1194
1195         switch (f->fmt.pix.pixelformat) {
1196         case V4L2_PIX_FMT_YUYV:
1197                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1198                 break;
1199         case V4L2_PIX_FMT_MJPEG:
1200                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1201                 break;
1202         }
1203
1204         mutex_unlock(&meye.lock);
1205         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1206         f->fmt.pix.sizeimage = f->fmt.pix.height *
1207                                f->fmt.pix.bytesperline;
1208         f->fmt.pix.colorspace = 0;
1209
1210         return 0;
1211 }
1212
1213 static int vidioc_reqbufs(struct file *file, void *fh,
1214                                 struct v4l2_requestbuffers *req)
1215 {
1216         int i;
1217
1218         if (req->memory != V4L2_MEMORY_MMAP)
1219                 return -EINVAL;
1220
1221         if (meye.grab_fbuffer && req->count == gbuffers) {
1222                 /* already allocated, no modifications */
1223                 return 0;
1224         }
1225
1226         mutex_lock(&meye.lock);
1227         if (meye.grab_fbuffer) {
1228                 for (i = 0; i < gbuffers; i++)
1229                         if (meye.vma_use_count[i]) {
1230                                 mutex_unlock(&meye.lock);
1231                                 return -EINVAL;
1232                         }
1233                 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1234                 meye.grab_fbuffer = NULL;
1235         }
1236
1237         gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1238         req->count = gbuffers;
1239         meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1240
1241         if (!meye.grab_fbuffer) {
1242                 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1243                 mutex_unlock(&meye.lock);
1244                 return -ENOMEM;
1245         }
1246
1247         for (i = 0; i < gbuffers; i++)
1248                 meye.vma_use_count[i] = 0;
1249
1250         mutex_unlock(&meye.lock);
1251
1252         return 0;
1253 }
1254
1255 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1256 {
1257         unsigned int index = buf->index;
1258
1259         if (index >= gbuffers)
1260                 return -EINVAL;
1261
1262         buf->bytesused = meye.grab_buffer[index].size;
1263         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1264
1265         if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1266                 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1267
1268         if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1269                 buf->flags |= V4L2_BUF_FLAG_DONE;
1270
1271         buf->field = V4L2_FIELD_NONE;
1272         buf->timestamp = ns_to_timeval(meye.grab_buffer[index].ts);
1273         buf->sequence = meye.grab_buffer[index].sequence;
1274         buf->memory = V4L2_MEMORY_MMAP;
1275         buf->m.offset = index * gbufsize;
1276         buf->length = gbufsize;
1277
1278         return 0;
1279 }
1280
1281 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1282 {
1283         if (buf->memory != V4L2_MEMORY_MMAP)
1284                 return -EINVAL;
1285
1286         if (buf->index >= gbuffers)
1287                 return -EINVAL;
1288
1289         if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1290                 return -EINVAL;
1291
1292         mutex_lock(&meye.lock);
1293         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1294         buf->flags &= ~V4L2_BUF_FLAG_DONE;
1295         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1296         kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1297                         sizeof(int), &meye.grabq_lock);
1298         mutex_unlock(&meye.lock);
1299
1300         return 0;
1301 }
1302
1303 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1304 {
1305         int reqnr;
1306
1307         if (buf->memory != V4L2_MEMORY_MMAP)
1308                 return -EINVAL;
1309
1310         mutex_lock(&meye.lock);
1311
1312         if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1313                 mutex_unlock(&meye.lock);
1314                 return -EAGAIN;
1315         }
1316
1317         if (wait_event_interruptible(meye.proc_list,
1318                                      kfifo_len(&meye.doneq) != 0) < 0) {
1319                 mutex_unlock(&meye.lock);
1320                 return -EINTR;
1321         }
1322
1323         if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1324                        sizeof(int), &meye.doneq_lock)) {
1325                 mutex_unlock(&meye.lock);
1326                 return -EBUSY;
1327         }
1328
1329         if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1330                 mutex_unlock(&meye.lock);
1331                 return -EINVAL;
1332         }
1333
1334         buf->index = reqnr;
1335         buf->bytesused = meye.grab_buffer[reqnr].size;
1336         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1337         buf->field = V4L2_FIELD_NONE;
1338         buf->timestamp = ns_to_timeval(meye.grab_buffer[reqnr].ts);
1339         buf->sequence = meye.grab_buffer[reqnr].sequence;
1340         buf->memory = V4L2_MEMORY_MMAP;
1341         buf->m.offset = reqnr * gbufsize;
1342         buf->length = gbufsize;
1343         meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1344         mutex_unlock(&meye.lock);
1345
1346         return 0;
1347 }
1348
1349 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1350 {
1351         mutex_lock(&meye.lock);
1352
1353         switch (meye.mchip_mode) {
1354         case MCHIP_HIC_MODE_CONT_OUT:
1355                 mchip_continuous_start();
1356                 break;
1357         case MCHIP_HIC_MODE_CONT_COMP:
1358                 mchip_cont_compression_start();
1359                 break;
1360         default:
1361                 mutex_unlock(&meye.lock);
1362                 return -EINVAL;
1363         }
1364
1365         mutex_unlock(&meye.lock);
1366
1367         return 0;
1368 }
1369
1370 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1371 {
1372         mutex_lock(&meye.lock);
1373         mchip_hic_stop();
1374         kfifo_reset(&meye.grabq);
1375         kfifo_reset(&meye.doneq);
1376
1377         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1378                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1379
1380         mutex_unlock(&meye.lock);
1381         return 0;
1382 }
1383
1384 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1385                            unsigned int cmd, void *arg)
1386 {
1387         switch (cmd) {
1388         case MEYEIOC_G_PARAMS:
1389                 return meyeioc_g_params((struct meye_params *) arg);
1390
1391         case MEYEIOC_S_PARAMS:
1392                 return meyeioc_s_params((struct meye_params *) arg);
1393
1394         case MEYEIOC_QBUF_CAPT:
1395                 return meyeioc_qbuf_capt((int *) arg);
1396
1397         case MEYEIOC_SYNC:
1398                 return meyeioc_sync(file, fh, (int *) arg);
1399
1400         case MEYEIOC_STILLCAPT:
1401                 return meyeioc_stillcapt();
1402
1403         case MEYEIOC_STILLJCAPT:
1404                 return meyeioc_stilljcapt((int *) arg);
1405
1406         default:
1407                 return -ENOTTY;
1408         }
1409
1410 }
1411
1412 static __poll_t meye_poll(struct file *file, poll_table *wait)
1413 {
1414         __poll_t res = v4l2_ctrl_poll(file, wait);
1415
1416         mutex_lock(&meye.lock);
1417         poll_wait(file, &meye.proc_list, wait);
1418         if (kfifo_len(&meye.doneq))
1419                 res |= EPOLLIN | EPOLLRDNORM;
1420         mutex_unlock(&meye.lock);
1421         return res;
1422 }
1423
1424 static void meye_vm_open(struct vm_area_struct *vma)
1425 {
1426         long idx = (long)vma->vm_private_data;
1427         meye.vma_use_count[idx]++;
1428 }
1429
1430 static void meye_vm_close(struct vm_area_struct *vma)
1431 {
1432         long idx = (long)vma->vm_private_data;
1433         meye.vma_use_count[idx]--;
1434 }
1435
1436 static const struct vm_operations_struct meye_vm_ops = {
1437         .open           = meye_vm_open,
1438         .close          = meye_vm_close,
1439 };
1440
1441 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1442 {
1443         unsigned long start = vma->vm_start;
1444         unsigned long size = vma->vm_end - vma->vm_start;
1445         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1446         unsigned long page, pos;
1447
1448         mutex_lock(&meye.lock);
1449         if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
1450                 mutex_unlock(&meye.lock);
1451                 return -EINVAL;
1452         }
1453         if (!meye.grab_fbuffer) {
1454                 int i;
1455
1456                 /* lazy allocation */
1457                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1458                 if (!meye.grab_fbuffer) {
1459                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1460                         mutex_unlock(&meye.lock);
1461                         return -ENOMEM;
1462                 }
1463                 for (i = 0; i < gbuffers; i++)
1464                         meye.vma_use_count[i] = 0;
1465         }
1466         pos = (unsigned long)meye.grab_fbuffer + offset;
1467
1468         while (size > 0) {
1469                 page = vmalloc_to_pfn((void *)pos);
1470                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1471                         mutex_unlock(&meye.lock);
1472                         return -EAGAIN;
1473                 }
1474                 start += PAGE_SIZE;
1475                 pos += PAGE_SIZE;
1476                 if (size > PAGE_SIZE)
1477                         size -= PAGE_SIZE;
1478                 else
1479                         size = 0;
1480         }
1481
1482         vma->vm_ops = &meye_vm_ops;
1483         vma->vm_flags &= ~VM_IO;        /* not I/O memory */
1484         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1485         vma->vm_private_data = (void *) (offset / gbufsize);
1486         meye_vm_open(vma);
1487
1488         mutex_unlock(&meye.lock);
1489         return 0;
1490 }
1491
1492 static const struct v4l2_file_operations meye_fops = {
1493         .owner          = THIS_MODULE,
1494         .open           = meye_open,
1495         .release        = meye_release,
1496         .mmap           = meye_mmap,
1497         .unlocked_ioctl = video_ioctl2,
1498         .poll           = meye_poll,
1499 };
1500
1501 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1502         .vidioc_querycap        = vidioc_querycap,
1503         .vidioc_enum_input      = vidioc_enum_input,
1504         .vidioc_g_input         = vidioc_g_input,
1505         .vidioc_s_input         = vidioc_s_input,
1506         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1507         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1508         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1509         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1510         .vidioc_reqbufs         = vidioc_reqbufs,
1511         .vidioc_querybuf        = vidioc_querybuf,
1512         .vidioc_qbuf            = vidioc_qbuf,
1513         .vidioc_dqbuf           = vidioc_dqbuf,
1514         .vidioc_streamon        = vidioc_streamon,
1515         .vidioc_streamoff       = vidioc_streamoff,
1516         .vidioc_log_status      = v4l2_ctrl_log_status,
1517         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1518         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1519         .vidioc_default         = vidioc_default,
1520 };
1521
1522 static const struct video_device meye_template = {
1523         .name           = "meye",
1524         .fops           = &meye_fops,
1525         .ioctl_ops      = &meye_ioctl_ops,
1526         .release        = video_device_release_empty,
1527         .device_caps    = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
1528 };
1529
1530 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1531         .s_ctrl = meye_s_ctrl,
1532 };
1533
1534 #ifdef CONFIG_PM
1535 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1536 {
1537         pci_save_state(pdev);
1538         meye.pm_mchip_mode = meye.mchip_mode;
1539         mchip_hic_stop();
1540         mchip_set(MCHIP_MM_INTA, 0x0);
1541         return 0;
1542 }
1543
1544 static int meye_resume(struct pci_dev *pdev)
1545 {
1546         pci_restore_state(pdev);
1547         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1548
1549         mchip_delay(MCHIP_HIC_CMD, 0);
1550         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1551         msleep(1);
1552         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1553         msleep(1);
1554         mchip_set(MCHIP_MM_PCI_MODE, 5);
1555         msleep(1);
1556         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1557
1558         switch (meye.pm_mchip_mode) {
1559         case MCHIP_HIC_MODE_CONT_OUT:
1560                 mchip_continuous_start();
1561                 break;
1562         case MCHIP_HIC_MODE_CONT_COMP:
1563                 mchip_cont_compression_start();
1564                 break;
1565         }
1566         return 0;
1567 }
1568 #endif
1569
1570 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1571 {
1572         static const struct v4l2_ctrl_config ctrl_agc = {
1573                 .id = V4L2_CID_MEYE_AGC,
1574                 .type = V4L2_CTRL_TYPE_INTEGER,
1575                 .ops = &meye_ctrl_ops,
1576                 .name = "AGC",
1577                 .max = 63,
1578                 .step = 1,
1579                 .def = 48,
1580                 .flags = V4L2_CTRL_FLAG_SLIDER,
1581         };
1582         static const struct v4l2_ctrl_config ctrl_picture = {
1583                 .id = V4L2_CID_MEYE_PICTURE,
1584                 .type = V4L2_CTRL_TYPE_INTEGER,
1585                 .ops = &meye_ctrl_ops,
1586                 .name = "Picture",
1587                 .max = 63,
1588                 .step = 1,
1589         };
1590         static const struct v4l2_ctrl_config ctrl_framerate = {
1591                 .id = V4L2_CID_MEYE_FRAMERATE,
1592                 .type = V4L2_CTRL_TYPE_INTEGER,
1593                 .ops = &meye_ctrl_ops,
1594                 .name = "Framerate",
1595                 .max = 31,
1596                 .step = 1,
1597         };
1598         struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1599         int ret = -EBUSY;
1600         unsigned long mchip_adr;
1601
1602         if (meye.mchip_dev != NULL) {
1603                 printk(KERN_ERR "meye: only one device allowed!\n");
1604                 return ret;
1605         }
1606
1607         ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1608         if (ret < 0) {
1609                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1610                 return ret;
1611         }
1612         ret = -ENOMEM;
1613         meye.mchip_dev = pcidev;
1614
1615         meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
1616         if (!meye.grab_temp)
1617                 goto outvmalloc;
1618
1619         spin_lock_init(&meye.grabq_lock);
1620         if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1621                         GFP_KERNEL))
1622                 goto outkfifoalloc1;
1623
1624         spin_lock_init(&meye.doneq_lock);
1625         if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1626                         GFP_KERNEL))
1627                 goto outkfifoalloc2;
1628
1629         meye.vdev = meye_template;
1630         meye.vdev.v4l2_dev = &meye.v4l2_dev;
1631
1632         ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1633         if (ret) {
1634                 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1635                 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1636                 goto outsonypienable;
1637         }
1638
1639         ret = pci_enable_device(meye.mchip_dev);
1640         if (ret) {
1641                 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1642                 goto outenabledev;
1643         }
1644
1645         ret = -EIO;
1646         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1647         if (!mchip_adr) {
1648                 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1649                 goto outregions;
1650         }
1651         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1652                                 pci_resource_len(meye.mchip_dev, 0),
1653                                 "meye")) {
1654                 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1655                 goto outregions;
1656         }
1657         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1658         if (!meye.mchip_mmregs) {
1659                 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1660                 goto outremap;
1661         }
1662
1663         meye.mchip_irq = pcidev->irq;
1664         if (request_irq(meye.mchip_irq, meye_irq,
1665                         IRQF_SHARED, "meye", meye_irq)) {
1666                 v4l2_err(v4l2_dev, "request_irq failed\n");
1667                 goto outreqirq;
1668         }
1669
1670         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1671         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1672
1673         pci_set_master(meye.mchip_dev);
1674
1675         /* Ask the camera to perform a soft reset. */
1676         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1677
1678         mchip_delay(MCHIP_HIC_CMD, 0);
1679         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1680
1681         msleep(1);
1682         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1683
1684         msleep(1);
1685         mchip_set(MCHIP_MM_PCI_MODE, 5);
1686
1687         msleep(1);
1688         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1689
1690         mutex_init(&meye.lock);
1691         init_waitqueue_head(&meye.proc_list);
1692
1693         v4l2_ctrl_handler_init(&meye.hdl, 3);
1694         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1695                           V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1696         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1697                           V4L2_CID_HUE, 0, 63, 1, 32);
1698         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1699                           V4L2_CID_CONTRAST, 0, 63, 1, 32);
1700         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1701                           V4L2_CID_SATURATION, 0, 63, 1, 32);
1702         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1703         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1704                           V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1705         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1706         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1707                           V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1708         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1709         if (meye.hdl.error) {
1710                 v4l2_err(v4l2_dev, "couldn't register controls\n");
1711                 goto outvideoreg;
1712         }
1713
1714         v4l2_ctrl_handler_setup(&meye.hdl);
1715         meye.vdev.ctrl_handler = &meye.hdl;
1716
1717         if (video_register_device(&meye.vdev, VFL_TYPE_GRABBER,
1718                                   video_nr) < 0) {
1719                 v4l2_err(v4l2_dev, "video_register_device failed\n");
1720                 goto outvideoreg;
1721         }
1722
1723         v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1724                MEYE_DRIVER_VERSION);
1725         v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1726                meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1727
1728         return 0;
1729
1730 outvideoreg:
1731         v4l2_ctrl_handler_free(&meye.hdl);
1732         free_irq(meye.mchip_irq, meye_irq);
1733 outreqirq:
1734         iounmap(meye.mchip_mmregs);
1735 outremap:
1736         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1737                            pci_resource_len(meye.mchip_dev, 0));
1738 outregions:
1739         pci_disable_device(meye.mchip_dev);
1740 outenabledev:
1741         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1742 outsonypienable:
1743         kfifo_free(&meye.doneq);
1744 outkfifoalloc2:
1745         kfifo_free(&meye.grabq);
1746 outkfifoalloc1:
1747         vfree(meye.grab_temp);
1748 outvmalloc:
1749         return ret;
1750 }
1751
1752 static void meye_remove(struct pci_dev *pcidev)
1753 {
1754         video_unregister_device(&meye.vdev);
1755
1756         mchip_hic_stop();
1757
1758         mchip_dma_free();
1759
1760         /* disable interrupts */
1761         mchip_set(MCHIP_MM_INTA, 0x0);
1762
1763         free_irq(meye.mchip_irq, meye_irq);
1764
1765         iounmap(meye.mchip_mmregs);
1766
1767         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1768                            pci_resource_len(meye.mchip_dev, 0));
1769
1770         pci_disable_device(meye.mchip_dev);
1771
1772         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1773
1774         kfifo_free(&meye.doneq);
1775         kfifo_free(&meye.grabq);
1776
1777         vfree(meye.grab_temp);
1778
1779         if (meye.grab_fbuffer) {
1780                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1781                 meye.grab_fbuffer = NULL;
1782         }
1783
1784         printk(KERN_INFO "meye: removed\n");
1785 }
1786
1787 static const struct pci_device_id meye_pci_tbl[] = {
1788         { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1789         { }
1790 };
1791
1792 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1793
1794 static struct pci_driver meye_driver = {
1795         .name           = "meye",
1796         .id_table       = meye_pci_tbl,
1797         .probe          = meye_probe,
1798         .remove         = meye_remove,
1799 #ifdef CONFIG_PM
1800         .suspend        = meye_suspend,
1801         .resume         = meye_resume,
1802 #endif
1803 };
1804
1805 static int __init meye_init(void)
1806 {
1807         gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1808         if (gbufsize > MEYE_MAX_BUFSIZE)
1809                 gbufsize = MEYE_MAX_BUFSIZE;
1810         gbufsize = PAGE_ALIGN(gbufsize);
1811         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1812                          gbuffers,
1813                          gbufsize / 1024, gbuffers * gbufsize / 1024);
1814         return pci_register_driver(&meye_driver);
1815 }
1816
1817 static void __exit meye_exit(void)
1818 {
1819         pci_unregister_driver(&meye_driver);
1820 }
1821
1822 module_init(meye_init);
1823 module_exit(meye_exit);