drivers/media/video/meye.c

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