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