git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/meye.c

   1 /*
   2  * Motion Eye video4linux driver for Sony Vaio PictureBook
   3  *
   4  * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
   5  *
   6  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
   7  *
   8  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
   9  *
  10  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  11  *
  12  * Some parts borrowed from various video4linux drivers, especially
  13  * bttv-driver.c and zoran.c, see original files for credits.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  */
  29 #include <linux/module.h>
  30 #include <linux/pci.h>
  31 #include <linux/init.h>
  32 #include <linux/videodev.h>
  33 #include <media/v4l2-common.h>
  34 #include <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->index == 0) {
1260                 /* standard YUV 422 capture */
1261                 f->flags = 0;
1262                 strcpy(f->description, "YUV422");
1263                 f->pixelformat = V4L2_PIX_FMT_YUYV;
1264         } else {
1265                 /* compressed MJPEG capture */
1266                 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1267                 strcpy(f->description, "MJPEG");
1268                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1269         }
1270
1271         return 0;
1272 }
1273
1274 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1275                                 struct v4l2_format *f)
1276 {
1277         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1278             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1279                 return -EINVAL;
1280
1281         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1282             f->fmt.pix.field != V4L2_FIELD_NONE)
1283                 return -EINVAL;
1284
1285         f->fmt.pix.field = V4L2_FIELD_NONE;
1286
1287         if (f->fmt.pix.width <= 320) {
1288                 f->fmt.pix.width = 320;
1289                 f->fmt.pix.height = 240;
1290         } else {
1291                 f->fmt.pix.width = 640;
1292                 f->fmt.pix.height = 480;
1293         }
1294
1295         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1296         f->fmt.pix.sizeimage = f->fmt.pix.height *
1297                                f->fmt.pix.bytesperline;
1298         f->fmt.pix.colorspace = 0;
1299         f->fmt.pix.priv = 0;
1300
1301         return 0;
1302 }
1303
1304 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1305                                     struct v4l2_format *f)
1306 {
1307         switch (meye.mchip_mode) {
1308         case MCHIP_HIC_MODE_CONT_OUT:
1309         default:
1310                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1311                 break;
1312         case MCHIP_HIC_MODE_CONT_COMP:
1313                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1314                 break;
1315         }
1316
1317         f->fmt.pix.field = V4L2_FIELD_NONE;
1318         f->fmt.pix.width = mchip_hsize();
1319         f->fmt.pix.height = mchip_vsize();
1320         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1321         f->fmt.pix.sizeimage = f->fmt.pix.height *
1322                                f->fmt.pix.bytesperline;
1323
1324         return 0;
1325 }
1326
1327 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1328                                     struct v4l2_format *f)
1329 {
1330         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1331             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1332                 return -EINVAL;
1333
1334         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1335             f->fmt.pix.field != V4L2_FIELD_NONE)
1336                 return -EINVAL;
1337
1338         f->fmt.pix.field = V4L2_FIELD_NONE;
1339         mutex_lock(&meye.lock);
1340
1341         if (f->fmt.pix.width <= 320) {
1342                 f->fmt.pix.width = 320;
1343                 f->fmt.pix.height = 240;
1344                 meye.params.subsample = 1;
1345         } else {
1346                 f->fmt.pix.width = 640;
1347                 f->fmt.pix.height = 480;
1348                 meye.params.subsample = 0;
1349         }
1350
1351         switch (f->fmt.pix.pixelformat) {
1352         case V4L2_PIX_FMT_YUYV:
1353                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1354                 break;
1355         case V4L2_PIX_FMT_MJPEG:
1356                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1357                 break;
1358         }
1359
1360         mutex_unlock(&meye.lock);
1361         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1362         f->fmt.pix.sizeimage = f->fmt.pix.height *
1363                                f->fmt.pix.bytesperline;
1364         f->fmt.pix.colorspace = 0;
1365         f->fmt.pix.priv = 0;
1366
1367         return 0;
1368 }
1369
1370 static int vidioc_reqbufs(struct file *file, void *fh,
1371                                 struct v4l2_requestbuffers *req)
1372 {
1373         int i;
1374
1375         if (req->memory != V4L2_MEMORY_MMAP)
1376                 return -EINVAL;
1377
1378         if (meye.grab_fbuffer && req->count == gbuffers) {
1379                 /* already allocated, no modifications */
1380                 return 0;
1381         }
1382
1383         mutex_lock(&meye.lock);
1384         if (meye.grab_fbuffer) {
1385                 for (i = 0; i < gbuffers; i++)
1386                         if (meye.vma_use_count[i]) {
1387                                 mutex_unlock(&meye.lock);
1388                                 return -EINVAL;
1389                         }
1390                 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1391                 meye.grab_fbuffer = NULL;
1392         }
1393
1394         gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1395         req->count = gbuffers;
1396         meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1397
1398         if (!meye.grab_fbuffer) {
1399                 printk(KERN_ERR "meye: v4l framebuffer allocation"
1400                                 " failed\n");
1401                 mutex_unlock(&meye.lock);
1402                 return -ENOMEM;
1403         }
1404
1405         for (i = 0; i < gbuffers; i++)
1406                 meye.vma_use_count[i] = 0;
1407
1408         mutex_unlock(&meye.lock);
1409
1410         return 0;
1411 }
1412
1413 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1414 {
1415         unsigned int index = buf->index;
1416
1417         if (index >= gbuffers)
1418                 return -EINVAL;
1419
1420         buf->bytesused = meye.grab_buffer[index].size;
1421         buf->flags = V4L2_BUF_FLAG_MAPPED;
1422
1423         if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1424                 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1425
1426         if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1427                 buf->flags |= V4L2_BUF_FLAG_DONE;
1428
1429         buf->field = V4L2_FIELD_NONE;
1430         buf->timestamp = meye.grab_buffer[index].timestamp;
1431         buf->sequence = meye.grab_buffer[index].sequence;
1432         buf->memory = V4L2_MEMORY_MMAP;
1433         buf->m.offset = index * gbufsize;
1434         buf->length = gbufsize;
1435
1436         return 0;
1437 }
1438
1439 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1440 {
1441         if (buf->memory != V4L2_MEMORY_MMAP)
1442                 return -EINVAL;
1443
1444         if (buf->index >= gbuffers)
1445                 return -EINVAL;
1446
1447         if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1448                 return -EINVAL;
1449
1450         mutex_lock(&meye.lock);
1451         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1452         buf->flags &= ~V4L2_BUF_FLAG_DONE;
1453         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1454         kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1455         mutex_unlock(&meye.lock);
1456
1457         return 0;
1458 }
1459
1460 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1461 {
1462         int reqnr;
1463
1464         if (buf->memory != V4L2_MEMORY_MMAP)
1465                 return -EINVAL;
1466
1467         mutex_lock(&meye.lock);
1468
1469         if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1470                 mutex_unlock(&meye.lock);
1471                 return -EAGAIN;
1472         }
1473
1474         if (wait_event_interruptible(meye.proc_list,
1475                                      kfifo_len(meye.doneq) != 0) < 0) {
1476                 mutex_unlock(&meye.lock);
1477                 return -EINTR;
1478         }
1479
1480         if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1481                        sizeof(int))) {
1482                 mutex_unlock(&meye.lock);
1483                 return -EBUSY;
1484         }
1485
1486         if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1487                 mutex_unlock(&meye.lock);
1488                 return -EINVAL;
1489         }
1490
1491         buf->index = reqnr;
1492         buf->bytesused = meye.grab_buffer[reqnr].size;
1493         buf->flags = V4L2_BUF_FLAG_MAPPED;
1494         buf->field = V4L2_FIELD_NONE;
1495         buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1496         buf->sequence = meye.grab_buffer[reqnr].sequence;
1497         buf->memory = V4L2_MEMORY_MMAP;
1498         buf->m.offset = reqnr * gbufsize;
1499         buf->length = gbufsize;
1500         meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1501         mutex_unlock(&meye.lock);
1502
1503         return 0;
1504 }
1505
1506 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1507 {
1508         mutex_lock(&meye.lock);
1509
1510         switch (meye.mchip_mode) {
1511         case MCHIP_HIC_MODE_CONT_OUT:
1512                 mchip_continuous_start();
1513                 break;
1514         case MCHIP_HIC_MODE_CONT_COMP:
1515                 mchip_cont_compression_start();
1516                 break;
1517         default:
1518                 mutex_unlock(&meye.lock);
1519                 return -EINVAL;
1520         }
1521
1522         mutex_unlock(&meye.lock);
1523
1524         return 0;
1525 }
1526
1527 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1528 {
1529         mutex_lock(&meye.lock);
1530         mchip_hic_stop();
1531         kfifo_reset(meye.grabq);
1532         kfifo_reset(meye.doneq);
1533
1534         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1535                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1536
1537         mutex_unlock(&meye.lock);
1538         return 0;
1539 }
1540
1541 static long vidioc_default(struct file *file, void *fh, int cmd, void *arg)
1542 {
1543         switch (cmd) {
1544         case MEYEIOC_G_PARAMS:
1545                 return meyeioc_g_params((struct meye_params *) arg);
1546
1547         case MEYEIOC_S_PARAMS:
1548                 return meyeioc_s_params((struct meye_params *) arg);
1549
1550         case MEYEIOC_QBUF_CAPT:
1551                 return meyeioc_qbuf_capt((int *) arg);
1552
1553         case MEYEIOC_SYNC:
1554                 return meyeioc_sync(file, fh, (int *) arg);
1555
1556         case MEYEIOC_STILLCAPT:
1557                 return meyeioc_stillcapt();
1558
1559         case MEYEIOC_STILLJCAPT:
1560                 return meyeioc_stilljcapt((int *) arg);
1561
1562         default:
1563                 return -EINVAL;
1564         }
1565
1566 }
1567
1568 static unsigned int meye_poll(struct file *file, poll_table *wait)
1569 {
1570         unsigned int res = 0;
1571
1572         mutex_lock(&meye.lock);
1573         poll_wait(file, &meye.proc_list, wait);
1574         if (kfifo_len(meye.doneq))
1575                 res = POLLIN | POLLRDNORM;
1576         mutex_unlock(&meye.lock);
1577         return res;
1578 }
1579
1580 static void meye_vm_open(struct vm_area_struct *vma)
1581 {
1582         long idx = (long)vma->vm_private_data;
1583         meye.vma_use_count[idx]++;
1584 }
1585
1586 static void meye_vm_close(struct vm_area_struct *vma)
1587 {
1588         long idx = (long)vma->vm_private_data;
1589         meye.vma_use_count[idx]--;
1590 }
1591
1592 static struct vm_operations_struct meye_vm_ops = {
1593         .open           = meye_vm_open,
1594         .close          = meye_vm_close,
1595 };
1596
1597 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1598 {
1599         unsigned long start = vma->vm_start;
1600         unsigned long size = vma->vm_end - vma->vm_start;
1601         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1602         unsigned long page, pos;
1603
1604         mutex_lock(&meye.lock);
1605         if (size > gbuffers * gbufsize) {
1606                 mutex_unlock(&meye.lock);
1607                 return -EINVAL;
1608         }
1609         if (!meye.grab_fbuffer) {
1610                 int i;
1611
1612                 /* lazy allocation */
1613                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1614                 if (!meye.grab_fbuffer) {
1615                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1616                         mutex_unlock(&meye.lock);
1617                         return -ENOMEM;
1618                 }
1619                 for (i = 0; i < gbuffers; i++)
1620                         meye.vma_use_count[i] = 0;
1621         }
1622         pos = (unsigned long)meye.grab_fbuffer + offset;
1623
1624         while (size > 0) {
1625                 page = vmalloc_to_pfn((void *)pos);
1626                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1627                         mutex_unlock(&meye.lock);
1628                         return -EAGAIN;
1629                 }
1630                 start += PAGE_SIZE;
1631                 pos += PAGE_SIZE;
1632                 if (size > PAGE_SIZE)
1633                         size -= PAGE_SIZE;
1634                 else
1635                         size = 0;
1636         }
1637
1638         vma->vm_ops = &meye_vm_ops;
1639         vma->vm_flags &= ~VM_IO;        /* not I/O memory */
1640         vma->vm_flags |= VM_RESERVED;   /* avoid to swap out this VMA */
1641         vma->vm_private_data = (void *) (offset / gbufsize);
1642         meye_vm_open(vma);
1643
1644         mutex_unlock(&meye.lock);
1645         return 0;
1646 }
1647
1648 static const struct v4l2_file_operations meye_fops = {
1649         .owner          = THIS_MODULE,
1650         .open           = meye_open,
1651         .release        = meye_release,
1652         .mmap           = meye_mmap,
1653         .ioctl          = video_ioctl2,
1654         .poll           = meye_poll,
1655 };
1656
1657 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1658         .vidioc_querycap        = vidioc_querycap,
1659         .vidioc_enum_input      = vidioc_enum_input,
1660         .vidioc_g_input         = vidioc_g_input,
1661         .vidioc_s_input         = vidioc_s_input,
1662         .vidioc_queryctrl       = vidioc_queryctrl,
1663         .vidioc_s_ctrl          = vidioc_s_ctrl,
1664         .vidioc_g_ctrl          = vidioc_g_ctrl,
1665         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1666         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1667         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1668         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1669         .vidioc_reqbufs         = vidioc_reqbufs,
1670         .vidioc_querybuf        = vidioc_querybuf,
1671         .vidioc_qbuf            = vidioc_qbuf,
1672         .vidioc_dqbuf           = vidioc_dqbuf,
1673         .vidioc_streamon        = vidioc_streamon,
1674         .vidioc_streamoff       = vidioc_streamoff,
1675         .vidioc_default         = vidioc_default,
1676 };
1677
1678 static struct video_device meye_template = {
1679         .name           = "meye",
1680         .fops           = &meye_fops,
1681         .ioctl_ops      = &meye_ioctl_ops,
1682         .release        = video_device_release,
1683         .minor          = -1,
1684 };
1685
1686 #ifdef CONFIG_PM
1687 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1688 {
1689         pci_save_state(pdev);
1690         meye.pm_mchip_mode = meye.mchip_mode;
1691         mchip_hic_stop();
1692         mchip_set(MCHIP_MM_INTA, 0x0);
1693         return 0;
1694 }
1695
1696 static int meye_resume(struct pci_dev *pdev)
1697 {
1698         pci_restore_state(pdev);
1699         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1700
1701         mchip_delay(MCHIP_HIC_CMD, 0);
1702         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1703         msleep(1);
1704         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1705         msleep(1);
1706         mchip_set(MCHIP_MM_PCI_MODE, 5);
1707         msleep(1);
1708         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1709
1710         switch (meye.pm_mchip_mode) {
1711         case MCHIP_HIC_MODE_CONT_OUT:
1712                 mchip_continuous_start();
1713                 break;
1714         case MCHIP_HIC_MODE_CONT_COMP:
1715                 mchip_cont_compression_start();
1716                 break;
1717         }
1718         return 0;
1719 }
1720 #endif
1721
1722 static int __devinit meye_probe(struct pci_dev *pcidev,
1723                                 const struct pci_device_id *ent)
1724 {
1725         int ret = -EBUSY;
1726         unsigned long mchip_adr;
1727
1728         if (meye.mchip_dev != NULL) {
1729                 printk(KERN_ERR "meye: only one device allowed!\n");
1730                 goto outnotdev;
1731         }
1732
1733         ret = -ENOMEM;
1734         meye.mchip_dev = pcidev;
1735         meye.video_dev = video_device_alloc();
1736         if (!meye.video_dev) {
1737                 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1738                 goto outnotdev;
1739         }
1740
1741         meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1742         if (!meye.grab_temp) {
1743                 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1744                 goto outvmalloc;
1745         }
1746
1747         spin_lock_init(&meye.grabq_lock);
1748         meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1749                                  &meye.grabq_lock);
1750         if (IS_ERR(meye.grabq)) {
1751                 printk(KERN_ERR "meye: fifo allocation failed\n");
1752                 goto outkfifoalloc1;
1753         }
1754         spin_lock_init(&meye.doneq_lock);
1755         meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1756                                  &meye.doneq_lock);
1757         if (IS_ERR(meye.doneq)) {
1758                 printk(KERN_ERR "meye: fifo allocation failed\n");
1759                 goto outkfifoalloc2;
1760         }
1761
1762         memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1763         meye.video_dev->parent = &meye.mchip_dev->dev;
1764
1765         ret = -EIO;
1766         if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1767                 printk(KERN_ERR "meye: unable to power on the camera\n");
1768                 printk(KERN_ERR "meye: did you enable the camera in "
1769                                 "sonypi using the module options ?\n");
1770                 goto outsonypienable;
1771         }
1772
1773         if ((ret = pci_enable_device(meye.mchip_dev))) {
1774                 printk(KERN_ERR "meye: pci_enable_device failed\n");
1775                 goto outenabledev;
1776         }
1777
1778         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1779         if (!mchip_adr) {
1780                 printk(KERN_ERR "meye: mchip has no device base address\n");
1781                 goto outregions;
1782         }
1783         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1784                                 pci_resource_len(meye.mchip_dev, 0),
1785                                 "meye")) {
1786                 printk(KERN_ERR "meye: request_mem_region failed\n");
1787                 goto outregions;
1788         }
1789         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1790         if (!meye.mchip_mmregs) {
1791                 printk(KERN_ERR "meye: ioremap failed\n");
1792                 goto outremap;
1793         }
1794
1795         meye.mchip_irq = pcidev->irq;
1796         if (request_irq(meye.mchip_irq, meye_irq,
1797                         IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1798                 printk(KERN_ERR "meye: request_irq failed\n");
1799                 goto outreqirq;
1800         }
1801
1802         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1803         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1804
1805         pci_set_master(meye.mchip_dev);
1806
1807         /* Ask the camera to perform a soft reset. */
1808         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1809
1810         mchip_delay(MCHIP_HIC_CMD, 0);
1811         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1812
1813         msleep(1);
1814         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1815
1816         msleep(1);
1817         mchip_set(MCHIP_MM_PCI_MODE, 5);
1818
1819         msleep(1);
1820         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1821
1822         if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1823                                   video_nr) < 0) {
1824                 printk(KERN_ERR "meye: video_register_device failed\n");
1825                 goto outvideoreg;
1826         }
1827
1828         mutex_init(&meye.lock);
1829         init_waitqueue_head(&meye.proc_list);
1830         meye.picture.depth = 16;
1831         meye.picture.palette = VIDEO_PALETTE_YUV422;
1832         meye.picture.brightness = 32 << 10;
1833         meye.picture.hue = 32 << 10;
1834         meye.picture.colour = 32 << 10;
1835         meye.picture.contrast = 32 << 10;
1836         meye.picture.whiteness = 0;
1837         meye.params.subsample = 0;
1838         meye.params.quality = 8;
1839         meye.params.sharpness = 32;
1840         meye.params.agc = 48;
1841         meye.params.picture = 0;
1842         meye.params.framerate = 0;
1843
1844         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1845         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1846         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1847         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1848         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1849         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1850         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1851
1852         printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1853                MEYE_DRIVER_VERSION);
1854         printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1855                meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1856
1857         return 0;
1858
1859 outvideoreg:
1860         free_irq(meye.mchip_irq, meye_irq);
1861 outreqirq:
1862         iounmap(meye.mchip_mmregs);
1863 outremap:
1864         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1865                            pci_resource_len(meye.mchip_dev, 0));
1866 outregions:
1867         pci_disable_device(meye.mchip_dev);
1868 outenabledev:
1869         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1870 outsonypienable:
1871         kfifo_free(meye.doneq);
1872 outkfifoalloc2:
1873         kfifo_free(meye.grabq);
1874 outkfifoalloc1:
1875         vfree(meye.grab_temp);
1876 outvmalloc:
1877         video_device_release(meye.video_dev);
1878 outnotdev:
1879         return ret;
1880 }
1881
1882 static void __devexit meye_remove(struct pci_dev *pcidev)
1883 {
1884         video_unregister_device(meye.video_dev);
1885
1886         mchip_hic_stop();
1887
1888         mchip_dma_free();
1889
1890         /* disable interrupts */
1891         mchip_set(MCHIP_MM_INTA, 0x0);
1892
1893         free_irq(meye.mchip_irq, meye_irq);
1894
1895         iounmap(meye.mchip_mmregs);
1896
1897         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1898                            pci_resource_len(meye.mchip_dev, 0));
1899
1900         pci_disable_device(meye.mchip_dev);
1901
1902         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1903
1904         kfifo_free(meye.doneq);
1905         kfifo_free(meye.grabq);
1906
1907         vfree(meye.grab_temp);
1908
1909         if (meye.grab_fbuffer) {
1910                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1911                 meye.grab_fbuffer = NULL;
1912         }
1913
1914         printk(KERN_INFO "meye: removed\n");
1915 }
1916
1917 static struct pci_device_id meye_pci_tbl[] = {
1918         { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1919           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1920         { }
1921 };
1922
1923 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1924
1925 static struct pci_driver meye_driver = {
1926         .name           = "meye",
1927         .id_table       = meye_pci_tbl,
1928         .probe          = meye_probe,
1929         .remove         = __devexit_p(meye_remove),
1930 #ifdef CONFIG_PM
1931         .suspend        = meye_suspend,
1932         .resume         = meye_resume,
1933 #endif
1934 };
1935
1936 static int __init meye_init(void)
1937 {
1938         gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1939         if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1940                 gbufsize = MEYE_MAX_BUFSIZE;
1941         gbufsize = PAGE_ALIGN(gbufsize);
1942         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1943                          "for capture\n",
1944                          gbuffers,
1945                          gbufsize / 1024, gbuffers * gbufsize / 1024);
1946         return pci_register_driver(&meye_driver);
1947 }
1948
1949 static void __exit meye_exit(void)
1950 {
1951         pci_unregister_driver(&meye_driver);
1952 }
1953
1954 module_init(meye_init);
1955 module_exit(meye_exit);