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

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