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