drivers/media/video/meye.c

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