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