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 file *file)
 845 {
 846         int i;
 847
 848         if (test_and_set_bit(0, &meye.in_use))
 849                 return -EBUSY;
 850
 851         mchip_hic_stop();
 852
 853         if (mchip_dma_alloc()) {
 854                 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
 855                 clear_bit(0, &meye.in_use);
 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 file *file)
 867 {
 868         mchip_hic_stop();
 869         mchip_dma_free();
 870         clear_bit(0, &meye.in_use);
 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         strcpy(cap->driver, "meye");
1021         strcpy(cap->card, "meye");
1022         sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1023
1024         cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1025                        MEYE_DRIVER_MINORVERSION;
1026
1027         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1028                             V4L2_CAP_STREAMING;
1029
1030         return 0;
1031 }
1032
1033 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1034 {
1035         if (i->index != 0)
1036                 return -EINVAL;
1037
1038         strcpy(i->name, "Camera");
1039         i->type = V4L2_INPUT_TYPE_CAMERA;
1040
1041         return 0;
1042 }
1043
1044 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1045 {
1046         *i = 0;
1047         return 0;
1048 }
1049
1050 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1051 {
1052         if (i != 0)
1053                 return -EINVAL;
1054
1055         return 0;
1056 }
1057
1058 static int vidioc_queryctrl(struct file *file, void *fh,
1059                                 struct v4l2_queryctrl *c)
1060 {
1061         switch (c->id) {
1062
1063         case V4L2_CID_BRIGHTNESS:
1064                 c->type = V4L2_CTRL_TYPE_INTEGER;
1065                 strcpy(c->name, "Brightness");
1066                 c->minimum = 0;
1067                 c->maximum = 63;
1068                 c->step = 1;
1069                 c->default_value = 32;
1070                 c->flags = 0;
1071                 break;
1072         case V4L2_CID_HUE:
1073                 c->type = V4L2_CTRL_TYPE_INTEGER;
1074                 strcpy(c->name, "Hue");
1075                 c->minimum = 0;
1076                 c->maximum = 63;
1077                 c->step = 1;
1078                 c->default_value = 32;
1079                 c->flags = 0;
1080                 break;
1081         case V4L2_CID_CONTRAST:
1082                 c->type = V4L2_CTRL_TYPE_INTEGER;
1083                 strcpy(c->name, "Contrast");
1084                 c->minimum = 0;
1085                 c->maximum = 63;
1086                 c->step = 1;
1087                 c->default_value = 32;
1088                 c->flags = 0;
1089                 break;
1090         case V4L2_CID_SATURATION:
1091                 c->type = V4L2_CTRL_TYPE_INTEGER;
1092                 strcpy(c->name, "Saturation");
1093                 c->minimum = 0;
1094                 c->maximum = 63;
1095                 c->step = 1;
1096                 c->default_value = 32;
1097                 c->flags = 0;
1098                 break;
1099         case V4L2_CID_AGC:
1100                 c->type = V4L2_CTRL_TYPE_INTEGER;
1101                 strcpy(c->name, "Agc");
1102                 c->minimum = 0;
1103                 c->maximum = 63;
1104                 c->step = 1;
1105                 c->default_value = 48;
1106                 c->flags = 0;
1107                 break;
1108         case V4L2_CID_MEYE_SHARPNESS:
1109         case V4L2_CID_SHARPNESS:
1110                 c->type = V4L2_CTRL_TYPE_INTEGER;
1111                 strcpy(c->name, "Sharpness");
1112                 c->minimum = 0;
1113                 c->maximum = 63;
1114                 c->step = 1;
1115                 c->default_value = 32;
1116
1117                 /* Continue to report legacy private SHARPNESS ctrl but
1118                  * say it is disabled in preference to ctrl in the spec
1119                  */
1120                 c->flags = (c->id == V4L2_CID_SHARPNESS) ? 0 :
1121                                                 V4L2_CTRL_FLAG_DISABLED;
1122                 break;
1123         case V4L2_CID_PICTURE:
1124                 c->type = V4L2_CTRL_TYPE_INTEGER;
1125                 strcpy(c->name, "Picture");
1126                 c->minimum = 0;
1127                 c->maximum = 63;
1128                 c->step = 1;
1129                 c->default_value = 0;
1130                 c->flags = 0;
1131                 break;
1132         case V4L2_CID_JPEGQUAL:
1133                 c->type = V4L2_CTRL_TYPE_INTEGER;
1134                 strcpy(c->name, "JPEG quality");
1135                 c->minimum = 0;
1136                 c->maximum = 10;
1137                 c->step = 1;
1138                 c->default_value = 8;
1139                 c->flags = 0;
1140                 break;
1141         case V4L2_CID_FRAMERATE:
1142                 c->type = V4L2_CTRL_TYPE_INTEGER;
1143                 strcpy(c->name, "Framerate");
1144                 c->minimum = 0;
1145                 c->maximum = 31;
1146                 c->step = 1;
1147                 c->default_value = 0;
1148                 c->flags = 0;
1149                 break;
1150         default:
1151                 return -EINVAL;
1152         }
1153
1154         return 0;
1155 }
1156
1157 static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1158 {
1159         mutex_lock(&meye.lock);
1160         switch (c->id) {
1161         case V4L2_CID_BRIGHTNESS:
1162                 sony_pic_camera_command(
1163                         SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1164                 meye.picture.brightness = c->value << 10;
1165                 break;
1166         case V4L2_CID_HUE:
1167                 sony_pic_camera_command(
1168                         SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1169                 meye.picture.hue = c->value << 10;
1170                 break;
1171         case V4L2_CID_CONTRAST:
1172                 sony_pic_camera_command(
1173                         SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1174                 meye.picture.contrast = c->value << 10;
1175                 break;
1176         case V4L2_CID_SATURATION:
1177                 sony_pic_camera_command(
1178                         SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1179                 meye.picture.colour = c->value << 10;
1180                 break;
1181         case V4L2_CID_AGC:
1182                 sony_pic_camera_command(
1183                         SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1184                 meye.params.agc = c->value;
1185                 break;
1186         case V4L2_CID_SHARPNESS:
1187         case V4L2_CID_MEYE_SHARPNESS:
1188                 sony_pic_camera_command(
1189                         SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1190                 meye.params.sharpness = c->value;
1191                 break;
1192         case V4L2_CID_PICTURE:
1193                 sony_pic_camera_command(
1194                         SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1195                 meye.params.picture = c->value;
1196                 break;
1197         case V4L2_CID_JPEGQUAL:
1198                 meye.params.quality = c->value;
1199                 break;
1200         case V4L2_CID_FRAMERATE:
1201                 meye.params.framerate = c->value;
1202                 break;
1203         default:
1204                 mutex_unlock(&meye.lock);
1205                 return -EINVAL;
1206         }
1207         mutex_unlock(&meye.lock);
1208
1209         return 0;
1210 }
1211
1212 static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *c)
1213 {
1214         mutex_lock(&meye.lock);
1215         switch (c->id) {
1216         case V4L2_CID_BRIGHTNESS:
1217                 c->value = meye.picture.brightness >> 10;
1218                 break;
1219         case V4L2_CID_HUE:
1220                 c->value = meye.picture.hue >> 10;
1221                 break;
1222         case V4L2_CID_CONTRAST:
1223                 c->value = meye.picture.contrast >> 10;
1224                 break;
1225         case V4L2_CID_SATURATION:
1226                 c->value = meye.picture.colour >> 10;
1227                 break;
1228         case V4L2_CID_AGC:
1229                 c->value = meye.params.agc;
1230                 break;
1231         case V4L2_CID_SHARPNESS:
1232         case V4L2_CID_MEYE_SHARPNESS:
1233                 c->value = meye.params.sharpness;
1234                 break;
1235         case V4L2_CID_PICTURE:
1236                 c->value = meye.params.picture;
1237                 break;
1238         case V4L2_CID_JPEGQUAL:
1239                 c->value = meye.params.quality;
1240                 break;
1241         case V4L2_CID_FRAMERATE:
1242                 c->value = meye.params.framerate;
1243                 break;
1244         default:
1245                 mutex_unlock(&meye.lock);
1246                 return -EINVAL;
1247         }
1248         mutex_unlock(&meye.lock);
1249
1250         return 0;
1251 }
1252
1253 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1254                                 struct v4l2_fmtdesc *f)
1255 {
1256         if (f->index > 1)
1257                 return -EINVAL;
1258
1259         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1260                 return -EINVAL;
1261
1262         if (f->index == 0) {
1263                 /* standard YUV 422 capture */
1264                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1265                 f->flags = 0;
1266                 strcpy(f->description, "YUV422");
1267                 f->pixelformat = V4L2_PIX_FMT_YUYV;
1268         } else {
1269                 /* compressed MJPEG capture */
1270                 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1271                 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1272                 strcpy(f->description, "MJPEG");
1273                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1274         }
1275
1276         return 0;
1277 }
1278
1279 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1280                                 struct v4l2_format *f)
1281 {
1282         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1283                 return -EINVAL;
1284
1285         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1286             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1287                 return -EINVAL;
1288
1289         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1290             f->fmt.pix.field != V4L2_FIELD_NONE)
1291                 return -EINVAL;
1292
1293         f->fmt.pix.field = V4L2_FIELD_NONE;
1294
1295         if (f->fmt.pix.width <= 320) {
1296                 f->fmt.pix.width = 320;
1297                 f->fmt.pix.height = 240;
1298         } else {
1299                 f->fmt.pix.width = 640;
1300                 f->fmt.pix.height = 480;
1301         }
1302
1303         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1304         f->fmt.pix.sizeimage = f->fmt.pix.height *
1305                                f->fmt.pix.bytesperline;
1306         f->fmt.pix.colorspace = 0;
1307         f->fmt.pix.priv = 0;
1308
1309         return 0;
1310 }
1311
1312 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1313                                     struct v4l2_format *f)
1314 {
1315         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1316                 return -EINVAL;
1317
1318         switch (meye.mchip_mode) {
1319         case MCHIP_HIC_MODE_CONT_OUT:
1320         default:
1321                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1322                 break;
1323         case MCHIP_HIC_MODE_CONT_COMP:
1324                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1325                 break;
1326         }
1327
1328         f->fmt.pix.field = V4L2_FIELD_NONE;
1329         f->fmt.pix.width = mchip_hsize();
1330         f->fmt.pix.height = mchip_vsize();
1331         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1332         f->fmt.pix.sizeimage = f->fmt.pix.height *
1333                                f->fmt.pix.bytesperline;
1334
1335         return 0;
1336 }
1337
1338 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1339                                     struct v4l2_format *f)
1340 {
1341         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1342                 return -EINVAL;
1343
1344         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1345             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1346                 return -EINVAL;
1347
1348         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1349             f->fmt.pix.field != V4L2_FIELD_NONE)
1350                 return -EINVAL;
1351
1352         f->fmt.pix.field = V4L2_FIELD_NONE;
1353         mutex_lock(&meye.lock);
1354
1355         if (f->fmt.pix.width <= 320) {
1356                 f->fmt.pix.width = 320;
1357                 f->fmt.pix.height = 240;
1358                 meye.params.subsample = 1;
1359         } else {
1360                 f->fmt.pix.width = 640;
1361                 f->fmt.pix.height = 480;
1362                 meye.params.subsample = 0;
1363         }
1364
1365         switch (f->fmt.pix.pixelformat) {
1366         case V4L2_PIX_FMT_YUYV:
1367                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1368                 break;
1369         case V4L2_PIX_FMT_MJPEG:
1370                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1371                 break;
1372         }
1373
1374         mutex_unlock(&meye.lock);
1375         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1376         f->fmt.pix.sizeimage = f->fmt.pix.height *
1377                                f->fmt.pix.bytesperline;
1378         f->fmt.pix.colorspace = 0;
1379         f->fmt.pix.priv = 0;
1380
1381         return 0;
1382 }
1383
1384 static int vidioc_reqbufs(struct file *file, void *fh,
1385                                 struct v4l2_requestbuffers *req)
1386 {
1387         int i;
1388
1389         if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1390                 return -EINVAL;
1391
1392         if (req->memory != V4L2_MEMORY_MMAP)
1393                 return -EINVAL;
1394
1395         if (meye.grab_fbuffer && req->count == gbuffers) {
1396                 /* already allocated, no modifications */
1397                 return 0;
1398         }
1399
1400         mutex_lock(&meye.lock);
1401         if (meye.grab_fbuffer) {
1402                 for (i = 0; i < gbuffers; i++)
1403                         if (meye.vma_use_count[i]) {
1404                                 mutex_unlock(&meye.lock);
1405                                 return -EINVAL;
1406                         }
1407                 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1408                 meye.grab_fbuffer = NULL;
1409         }
1410
1411         gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1412         req->count = gbuffers;
1413         meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1414
1415         if (!meye.grab_fbuffer) {
1416                 printk(KERN_ERR "meye: v4l framebuffer allocation"
1417                                 " failed\n");
1418                 mutex_unlock(&meye.lock);
1419                 return -ENOMEM;
1420         }
1421
1422         for (i = 0; i < gbuffers; i++)
1423                 meye.vma_use_count[i] = 0;
1424
1425         mutex_unlock(&meye.lock);
1426
1427         return 0;
1428 }
1429
1430 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1431 {
1432         int index = buf->index;
1433
1434         if (index < 0 || index >= gbuffers)
1435                 return -EINVAL;
1436
1437         buf->bytesused = meye.grab_buffer[index].size;
1438         buf->flags = V4L2_BUF_FLAG_MAPPED;
1439
1440         if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1441                 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1442
1443         if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1444                 buf->flags |= V4L2_BUF_FLAG_DONE;
1445
1446         buf->field = V4L2_FIELD_NONE;
1447         buf->timestamp = meye.grab_buffer[index].timestamp;
1448         buf->sequence = meye.grab_buffer[index].sequence;
1449         buf->memory = V4L2_MEMORY_MMAP;
1450         buf->m.offset = index * gbufsize;
1451         buf->length = gbufsize;
1452
1453         return 0;
1454 }
1455
1456 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1457 {
1458         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1459                 return -EINVAL;
1460
1461         if (buf->memory != V4L2_MEMORY_MMAP)
1462                 return -EINVAL;
1463
1464         if (buf->index < 0 || buf->index >= gbuffers)
1465                 return -EINVAL;
1466
1467         if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1468                 return -EINVAL;
1469
1470         mutex_lock(&meye.lock);
1471         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1472         buf->flags &= ~V4L2_BUF_FLAG_DONE;
1473         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1474         kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1475         mutex_unlock(&meye.lock);
1476
1477         return 0;
1478 }
1479
1480 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1481 {
1482         int reqnr;
1483
1484         if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1485                 return -EINVAL;
1486
1487         if (buf->memory != V4L2_MEMORY_MMAP)
1488                 return -EINVAL;
1489
1490         mutex_lock(&meye.lock);
1491
1492         if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1493                 mutex_unlock(&meye.lock);
1494                 return -EAGAIN;
1495         }
1496
1497         if (wait_event_interruptible(meye.proc_list,
1498                                      kfifo_len(meye.doneq) != 0) < 0) {
1499                 mutex_unlock(&meye.lock);
1500                 return -EINTR;
1501         }
1502
1503         if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1504                        sizeof(int))) {
1505                 mutex_unlock(&meye.lock);
1506                 return -EBUSY;
1507         }
1508
1509         if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1510                 mutex_unlock(&meye.lock);
1511                 return -EINVAL;
1512         }
1513
1514         buf->index = reqnr;
1515         buf->bytesused = meye.grab_buffer[reqnr].size;
1516         buf->flags = V4L2_BUF_FLAG_MAPPED;
1517         buf->field = V4L2_FIELD_NONE;
1518         buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1519         buf->sequence = meye.grab_buffer[reqnr].sequence;
1520         buf->memory = V4L2_MEMORY_MMAP;
1521         buf->m.offset = reqnr * gbufsize;
1522         buf->length = gbufsize;
1523         meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1524         mutex_unlock(&meye.lock);
1525
1526         return 0;
1527 }
1528
1529 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1530 {
1531         mutex_lock(&meye.lock);
1532
1533         switch (meye.mchip_mode) {
1534         case MCHIP_HIC_MODE_CONT_OUT:
1535                 mchip_continuous_start();
1536                 break;
1537         case MCHIP_HIC_MODE_CONT_COMP:
1538                 mchip_cont_compression_start();
1539                 break;
1540         default:
1541                 mutex_unlock(&meye.lock);
1542                 return -EINVAL;
1543         }
1544
1545         mutex_unlock(&meye.lock);
1546
1547         return 0;
1548 }
1549
1550 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1551 {
1552         mutex_lock(&meye.lock);
1553         mchip_hic_stop();
1554         kfifo_reset(meye.grabq);
1555         kfifo_reset(meye.doneq);
1556
1557         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1558                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1559
1560         mutex_unlock(&meye.lock);
1561         return 0;
1562 }
1563
1564 static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
1565 {
1566         switch (cmd) {
1567         case MEYEIOC_G_PARAMS:
1568                 return meyeioc_g_params((struct meye_params *) arg);
1569
1570         case MEYEIOC_S_PARAMS:
1571                 return meyeioc_s_params((struct meye_params *) arg);
1572
1573         case MEYEIOC_QBUF_CAPT:
1574                 return meyeioc_qbuf_capt((int *) arg);
1575
1576         case MEYEIOC_SYNC:
1577                 return meyeioc_sync(file, fh, (int *) arg);
1578
1579         case MEYEIOC_STILLCAPT:
1580                 return meyeioc_stillcapt();
1581
1582         case MEYEIOC_STILLJCAPT:
1583                 return meyeioc_stilljcapt((int *) arg);
1584
1585         default:
1586                 return -EINVAL;
1587         }
1588
1589 }
1590
1591 static unsigned int meye_poll(struct file *file, poll_table *wait)
1592 {
1593         unsigned int res = 0;
1594
1595         mutex_lock(&meye.lock);
1596         poll_wait(file, &meye.proc_list, wait);
1597         if (kfifo_len(meye.doneq))
1598                 res = POLLIN | POLLRDNORM;
1599         mutex_unlock(&meye.lock);
1600         return res;
1601 }
1602
1603 static void meye_vm_open(struct vm_area_struct *vma)
1604 {
1605         long idx = (long)vma->vm_private_data;
1606         meye.vma_use_count[idx]++;
1607 }
1608
1609 static void meye_vm_close(struct vm_area_struct *vma)
1610 {
1611         long idx = (long)vma->vm_private_data;
1612         meye.vma_use_count[idx]--;
1613 }
1614
1615 static struct vm_operations_struct meye_vm_ops = {
1616         .open           = meye_vm_open,
1617         .close          = meye_vm_close,
1618 };
1619
1620 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1621 {
1622         unsigned long start = vma->vm_start;
1623         unsigned long size = vma->vm_end - vma->vm_start;
1624         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1625         unsigned long page, pos;
1626
1627         mutex_lock(&meye.lock);
1628         if (size > gbuffers * gbufsize) {
1629                 mutex_unlock(&meye.lock);
1630                 return -EINVAL;
1631         }
1632         if (!meye.grab_fbuffer) {
1633                 int i;
1634
1635                 /* lazy allocation */
1636                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1637                 if (!meye.grab_fbuffer) {
1638                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1639                         mutex_unlock(&meye.lock);
1640                         return -ENOMEM;
1641                 }
1642                 for (i = 0; i < gbuffers; i++)
1643                         meye.vma_use_count[i] = 0;
1644         }
1645         pos = (unsigned long)meye.grab_fbuffer + offset;
1646
1647         while (size > 0) {
1648                 page = vmalloc_to_pfn((void *)pos);
1649                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1650                         mutex_unlock(&meye.lock);
1651                         return -EAGAIN;
1652                 }
1653                 start += PAGE_SIZE;
1654                 pos += PAGE_SIZE;
1655                 if (size > PAGE_SIZE)
1656                         size -= PAGE_SIZE;
1657                 else
1658                         size = 0;
1659         }
1660
1661         vma->vm_ops = &meye_vm_ops;
1662         vma->vm_flags &= ~VM_IO;        /* not I/O memory */
1663         vma->vm_flags |= VM_RESERVED;   /* avoid to swap out this VMA */
1664         vma->vm_private_data = (void *) (offset / gbufsize);
1665         meye_vm_open(vma);
1666
1667         mutex_unlock(&meye.lock);
1668         return 0;
1669 }
1670
1671 static const struct v4l2_file_operations meye_fops = {
1672         .owner          = THIS_MODULE,
1673         .open           = meye_open,
1674         .release        = meye_release,
1675         .mmap           = meye_mmap,
1676         .ioctl          = video_ioctl2,
1677         .poll           = meye_poll,
1678 };
1679
1680 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1681         .vidioc_querycap        = vidioc_querycap,
1682         .vidioc_enum_input      = vidioc_enum_input,
1683         .vidioc_g_input         = vidioc_g_input,
1684         .vidioc_s_input         = vidioc_s_input,
1685         .vidioc_queryctrl       = vidioc_queryctrl,
1686         .vidioc_s_ctrl          = vidioc_s_ctrl,
1687         .vidioc_g_ctrl          = vidioc_g_ctrl,
1688         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1689         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1690         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1691         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1692         .vidioc_reqbufs         = vidioc_reqbufs,
1693         .vidioc_querybuf        = vidioc_querybuf,
1694         .vidioc_qbuf            = vidioc_qbuf,
1695         .vidioc_dqbuf           = vidioc_dqbuf,
1696         .vidioc_streamon        = vidioc_streamon,
1697         .vidioc_streamoff       = vidioc_streamoff,
1698         .vidioc_default         = vidioc_default,
1699 };
1700
1701 static struct video_device meye_template = {
1702         .name           = "meye",
1703         .fops           = &meye_fops,
1704         .ioctl_ops      = &meye_ioctl_ops,
1705         .release        = video_device_release,
1706         .minor          = -1,
1707 };
1708
1709 #ifdef CONFIG_PM
1710 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1711 {
1712         pci_save_state(pdev);
1713         meye.pm_mchip_mode = meye.mchip_mode;
1714         mchip_hic_stop();
1715         mchip_set(MCHIP_MM_INTA, 0x0);
1716         return 0;
1717 }
1718
1719 static int meye_resume(struct pci_dev *pdev)
1720 {
1721         pci_restore_state(pdev);
1722         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1723
1724         mchip_delay(MCHIP_HIC_CMD, 0);
1725         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1726         msleep(1);
1727         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1728         msleep(1);
1729         mchip_set(MCHIP_MM_PCI_MODE, 5);
1730         msleep(1);
1731         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1732
1733         switch (meye.pm_mchip_mode) {
1734         case MCHIP_HIC_MODE_CONT_OUT:
1735                 mchip_continuous_start();
1736                 break;
1737         case MCHIP_HIC_MODE_CONT_COMP:
1738                 mchip_cont_compression_start();
1739                 break;
1740         }
1741         return 0;
1742 }
1743 #endif
1744
1745 static int __devinit meye_probe(struct pci_dev *pcidev,
1746                                 const struct pci_device_id *ent)
1747 {
1748         int ret = -EBUSY;
1749         unsigned long mchip_adr;
1750
1751         if (meye.mchip_dev != NULL) {
1752                 printk(KERN_ERR "meye: only one device allowed!\n");
1753                 goto outnotdev;
1754         }
1755
1756         ret = -ENOMEM;
1757         meye.mchip_dev = pcidev;
1758         meye.video_dev = video_device_alloc();
1759         if (!meye.video_dev) {
1760                 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1761                 goto outnotdev;
1762         }
1763
1764         meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1765         if (!meye.grab_temp) {
1766                 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1767                 goto outvmalloc;
1768         }
1769
1770         spin_lock_init(&meye.grabq_lock);
1771         meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1772                                  &meye.grabq_lock);
1773         if (IS_ERR(meye.grabq)) {
1774                 printk(KERN_ERR "meye: fifo allocation failed\n");
1775                 goto outkfifoalloc1;
1776         }
1777         spin_lock_init(&meye.doneq_lock);
1778         meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1779                                  &meye.doneq_lock);
1780         if (IS_ERR(meye.doneq)) {
1781                 printk(KERN_ERR "meye: fifo allocation failed\n");
1782                 goto outkfifoalloc2;
1783         }
1784
1785         memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1786         meye.video_dev->parent = &meye.mchip_dev->dev;
1787
1788         ret = -EIO;
1789         if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1790                 printk(KERN_ERR "meye: unable to power on the camera\n");
1791                 printk(KERN_ERR "meye: did you enable the camera in "
1792                                 "sonypi using the module options ?\n");
1793                 goto outsonypienable;
1794         }
1795
1796         if ((ret = pci_enable_device(meye.mchip_dev))) {
1797                 printk(KERN_ERR "meye: pci_enable_device failed\n");
1798                 goto outenabledev;
1799         }
1800
1801         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1802         if (!mchip_adr) {
1803                 printk(KERN_ERR "meye: mchip has no device base address\n");
1804                 goto outregions;
1805         }
1806         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1807                                 pci_resource_len(meye.mchip_dev, 0),
1808                                 "meye")) {
1809                 printk(KERN_ERR "meye: request_mem_region failed\n");
1810                 goto outregions;
1811         }
1812         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1813         if (!meye.mchip_mmregs) {
1814                 printk(KERN_ERR "meye: ioremap failed\n");
1815                 goto outremap;
1816         }
1817
1818         meye.mchip_irq = pcidev->irq;
1819         if (request_irq(meye.mchip_irq, meye_irq,
1820                         IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1821                 printk(KERN_ERR "meye: request_irq failed\n");
1822                 goto outreqirq;
1823         }
1824
1825         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1826         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1827
1828         pci_set_master(meye.mchip_dev);
1829
1830         /* Ask the camera to perform a soft reset. */
1831         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1832
1833         mchip_delay(MCHIP_HIC_CMD, 0);
1834         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1835
1836         msleep(1);
1837         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1838
1839         msleep(1);
1840         mchip_set(MCHIP_MM_PCI_MODE, 5);
1841
1842         msleep(1);
1843         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1844
1845         if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1846                                   video_nr) < 0) {
1847                 printk(KERN_ERR "meye: video_register_device failed\n");
1848                 goto outvideoreg;
1849         }
1850
1851         mutex_init(&meye.lock);
1852         init_waitqueue_head(&meye.proc_list);
1853         meye.picture.depth = 16;
1854         meye.picture.palette = VIDEO_PALETTE_YUV422;
1855         meye.picture.brightness = 32 << 10;
1856         meye.picture.hue = 32 << 10;
1857         meye.picture.colour = 32 << 10;
1858         meye.picture.contrast = 32 << 10;
1859         meye.picture.whiteness = 0;
1860         meye.params.subsample = 0;
1861         meye.params.quality = 8;
1862         meye.params.sharpness = 32;
1863         meye.params.agc = 48;
1864         meye.params.picture = 0;
1865         meye.params.framerate = 0;
1866
1867         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1868         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1869         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1870         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1871         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1872         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1873         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1874
1875         printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1876                MEYE_DRIVER_VERSION);
1877         printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1878                meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1879
1880         return 0;
1881
1882 outvideoreg:
1883         free_irq(meye.mchip_irq, meye_irq);
1884 outreqirq:
1885         iounmap(meye.mchip_mmregs);
1886 outremap:
1887         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1888                            pci_resource_len(meye.mchip_dev, 0));
1889 outregions:
1890         pci_disable_device(meye.mchip_dev);
1891 outenabledev:
1892         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1893 outsonypienable:
1894         kfifo_free(meye.doneq);
1895 outkfifoalloc2:
1896         kfifo_free(meye.grabq);
1897 outkfifoalloc1:
1898         vfree(meye.grab_temp);
1899 outvmalloc:
1900         video_device_release(meye.video_dev);
1901 outnotdev:
1902         return ret;
1903 }
1904
1905 static void __devexit meye_remove(struct pci_dev *pcidev)
1906 {
1907         video_unregister_device(meye.video_dev);
1908
1909         mchip_hic_stop();
1910
1911         mchip_dma_free();
1912
1913         /* disable interrupts */
1914         mchip_set(MCHIP_MM_INTA, 0x0);
1915
1916         free_irq(meye.mchip_irq, meye_irq);
1917
1918         iounmap(meye.mchip_mmregs);
1919
1920         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1921                            pci_resource_len(meye.mchip_dev, 0));
1922
1923         pci_disable_device(meye.mchip_dev);
1924
1925         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1926
1927         kfifo_free(meye.doneq);
1928         kfifo_free(meye.grabq);
1929
1930         vfree(meye.grab_temp);
1931
1932         if (meye.grab_fbuffer) {
1933                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1934                 meye.grab_fbuffer = NULL;
1935         }
1936
1937         printk(KERN_INFO "meye: removed\n");
1938 }
1939
1940 static struct pci_device_id meye_pci_tbl[] = {
1941         { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1942           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1943         { }
1944 };
1945
1946 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1947
1948 static struct pci_driver meye_driver = {
1949         .name           = "meye",
1950         .id_table       = meye_pci_tbl,
1951         .probe          = meye_probe,
1952         .remove         = __devexit_p(meye_remove),
1953 #ifdef CONFIG_PM
1954         .suspend        = meye_suspend,
1955         .resume         = meye_resume,
1956 #endif
1957 };
1958
1959 static int __init meye_init(void)
1960 {
1961         gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1962         if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1963                 gbufsize = MEYE_MAX_BUFSIZE;
1964         gbufsize = PAGE_ALIGN(gbufsize);
1965         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1966                          "for capture\n",
1967                          gbuffers,
1968                          gbufsize / 1024, gbuffers * gbufsize / 1024);
1969         return pci_register_driver(&meye_driver);
1970 }
1971
1972 static void __exit meye_exit(void)
1973 {
1974         pci_unregister_driver(&meye_driver);
1975 }
1976
1977 module_init(meye_init);
1978 module_exit(meye_exit);