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