drivers/media/video/meye.c

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