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