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