drivers/media/pci/meye/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 #include <linux/module.h>
  26 #include <linux/pci.h>
  27 #include <linux/sched.h>
  28 #include <linux/init.h>
  29 #include <linux/gfp.h>
  30 #include <linux/videodev2.h>
  31 #include <media/v4l2-common.h>
  32 #include <media/v4l2-device.h>
  33 #include <media/v4l2-ioctl.h>
  34 #include <media/v4l2-fh.h>
  35 #include <media/v4l2-event.h>
  36 #include <linux/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 (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_BIT_MASK(32)))
 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         return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
 586 }
 587
 588 /* frees the current frame from the dma engine */
 589 static void mchip_free_frame(void)
 590 {
 591         mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
 592         meye.mchip_fnum++;
 593         meye.mchip_fnum %= 4;
 594 }
 595
 596 /* read one frame from the framebuffer assuming it was captured using
 597    a uncompressed transfer */
 598 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
 599 {
 600         int pt_id;
 601
 602         pt_id = (v >> 17) & 0x3FF;
 603
 604         ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
 605 }
 606
 607 /* read a compressed frame from the framebuffer */
 608 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
 609 {
 610         int pt_start, pt_end, trailer;
 611         int fsize;
 612         int i;
 613
 614         pt_start = (v >> 19) & 0xFF;
 615         pt_end = (v >> 11) & 0xFF;
 616         trailer = (v >> 1) & 0x3FF;
 617
 618         if (pt_end < pt_start)
 619                 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
 620                         pt_end * PAGE_SIZE + trailer * 4;
 621         else
 622                 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
 623
 624         if (fsize > size) {
 625                 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
 626                        fsize);
 627                 return -1;
 628         }
 629
 630         ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
 631
 632 #ifdef MEYE_JPEG_CORRECTION
 633
 634         /* Some mchip generated jpeg frames are incorrect. In most
 635          * (all ?) of those cases, the final EOI (0xff 0xd9) marker
 636          * is not present at the end of the frame.
 637          *
 638          * Since adding the final marker is not enough to restore
 639          * the jpeg integrity, we drop the frame.
 640          */
 641
 642         for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
 643
 644         if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
 645                 return -1;
 646
 647 #endif
 648
 649         return fsize;
 650 }
 651
 652 /* take a picture into SDRAM */
 653 static void mchip_take_picture(void)
 654 {
 655         int i;
 656
 657         mchip_hic_stop();
 658         mchip_subsample();
 659         mchip_dma_setup(meye.mchip_dmahandle);
 660
 661         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
 662         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 663
 664         mchip_delay(MCHIP_HIC_CMD, 0);
 665
 666         for (i = 0; i < 100; ++i) {
 667                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 668                         break;
 669                 msleep(1);
 670         }
 671 }
 672
 673 /* dma a previously taken picture into a buffer */
 674 static void mchip_get_picture(u8 *buf, int bufsize)
 675 {
 676         u32 v;
 677         int i;
 678
 679         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
 680         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 681
 682         mchip_delay(MCHIP_HIC_CMD, 0);
 683         for (i = 0; i < 100; ++i) {
 684                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 685                         break;
 686                 msleep(1);
 687         }
 688         for (i = 0; i < 4; ++i) {
 689                 v = mchip_get_frame();
 690                 if (v & MCHIP_MM_FIR_RDY) {
 691                         mchip_cont_read_frame(v, buf, bufsize);
 692                         break;
 693                 }
 694                 mchip_free_frame();
 695         }
 696 }
 697
 698 /* start continuous dma capture */
 699 static void mchip_continuous_start(void)
 700 {
 701         mchip_hic_stop();
 702         mchip_subsample();
 703         mchip_set_framerate();
 704         mchip_dma_setup(meye.mchip_dmahandle);
 705
 706         meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
 707
 708         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
 709         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 710
 711         mchip_delay(MCHIP_HIC_CMD, 0);
 712 }
 713
 714 /* compress one frame into a buffer */
 715 static int mchip_compress_frame(u8 *buf, int bufsize)
 716 {
 717         u32 v;
 718         int len = -1, i;
 719
 720         mchip_vrj_setup(0x3f);
 721         udelay(50);
 722
 723         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
 724         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 725
 726         mchip_delay(MCHIP_HIC_CMD, 0);
 727         for (i = 0; i < 100; ++i) {
 728                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 729                         break;
 730                 msleep(1);
 731         }
 732
 733         for (i = 0; i < 4; ++i) {
 734                 v = mchip_get_frame();
 735                 if (v & MCHIP_MM_FIR_RDY) {
 736                         len = mchip_comp_read_frame(v, buf, bufsize);
 737                         break;
 738                 }
 739                 mchip_free_frame();
 740         }
 741         return len;
 742 }
 743
 744 #if 0
 745 /* uncompress one image into a buffer */
 746 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
 747 {
 748         mchip_vrj_setup(0x3f);
 749         udelay(50);
 750
 751         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
 752         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 753
 754         mchip_delay(MCHIP_HIC_CMD, 0);
 755
 756         return mchip_comp_read_frame(buf, bufsize);
 757 }
 758 #endif
 759
 760 /* start continuous compressed capture */
 761 static void mchip_cont_compression_start(void)
 762 {
 763         mchip_hic_stop();
 764         mchip_vrj_setup(0x3f);
 765         mchip_subsample();
 766         mchip_set_framerate();
 767         mchip_dma_setup(meye.mchip_dmahandle);
 768
 769         meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
 770
 771         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
 772         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 773
 774         mchip_delay(MCHIP_HIC_CMD, 0);
 775 }
 776
 777 /****************************************************************************/
 778 /* Interrupt handling                                                       */
 779 /****************************************************************************/
 780
 781 static irqreturn_t meye_irq(int irq, void *dev_id)
 782 {
 783         u32 v;
 784         int reqnr;
 785         static int sequence;
 786
 787         v = mchip_read(MCHIP_MM_INTA);
 788
 789         if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
 790             meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
 791                 return IRQ_NONE;
 792
 793 again:
 794         v = mchip_get_frame();
 795         if (!(v & MCHIP_MM_FIR_RDY))
 796                 return IRQ_HANDLED;
 797
 798         if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
 799                 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
 800                               sizeof(int), &meye.grabq_lock) != sizeof(int)) {
 801                         mchip_free_frame();
 802                         return IRQ_HANDLED;
 803                 }
 804                 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
 805                                       mchip_hsize() * mchip_vsize() * 2);
 806                 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
 807                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 808                 v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
 809                 meye.grab_buffer[reqnr].sequence = sequence++;
 810                 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
 811                                 sizeof(int), &meye.doneq_lock);
 812                 wake_up_interruptible(&meye.proc_list);
 813         } else {
 814                 int size;
 815                 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
 816                 if (size == -1) {
 817                         mchip_free_frame();
 818                         goto again;
 819                 }
 820                 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
 821                               sizeof(int), &meye.grabq_lock) != sizeof(int)) {
 822                         mchip_free_frame();
 823                         goto again;
 824                 }
 825                 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
 826                        size);
 827                 meye.grab_buffer[reqnr].size = size;
 828                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 829                 v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
 830                 meye.grab_buffer[reqnr].sequence = sequence++;
 831                 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
 832                                 sizeof(int), &meye.doneq_lock);
 833                 wake_up_interruptible(&meye.proc_list);
 834         }
 835         mchip_free_frame();
 836         goto again;
 837 }
 838
 839 /****************************************************************************/
 840 /* video4linux integration                                                  */
 841 /****************************************************************************/
 842
 843 static int meye_open(struct file *file)
 844 {
 845         int i;
 846
 847         if (test_and_set_bit(0, &meye.in_use))
 848                 return -EBUSY;
 849
 850         mchip_hic_stop();
 851
 852         if (mchip_dma_alloc()) {
 853                 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
 854                 clear_bit(0, &meye.in_use);
 855                 return -ENOBUFS;
 856         }
 857
 858         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
 859                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
 860         kfifo_reset(&meye.grabq);
 861         kfifo_reset(&meye.doneq);
 862         return v4l2_fh_open(file);
 863 }
 864
 865 static int meye_release(struct file *file)
 866 {
 867         mchip_hic_stop();
 868         mchip_dma_free();
 869         clear_bit(0, &meye.in_use);
 870         return v4l2_fh_release(file);
 871 }
 872
 873 static int meyeioc_g_params(struct meye_params *p)
 874 {
 875         *p = meye.params;
 876         return 0;
 877 }
 878
 879 static int meyeioc_s_params(struct meye_params *jp)
 880 {
 881         if (jp->subsample > 1)
 882                 return -EINVAL;
 883
 884         if (jp->quality > 10)
 885                 return -EINVAL;
 886
 887         if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
 888                 return -EINVAL;
 889
 890         if (jp->framerate > 31)
 891                 return -EINVAL;
 892
 893         mutex_lock(&meye.lock);
 894
 895         if (meye.params.subsample != jp->subsample ||
 896             meye.params.quality != jp->quality)
 897                 mchip_hic_stop();       /* need restart */
 898
 899         meye.params = *jp;
 900         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
 901                               meye.params.sharpness);
 902         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
 903                               meye.params.agc);
 904         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
 905                               meye.params.picture);
 906         mutex_unlock(&meye.lock);
 907
 908         return 0;
 909 }
 910
 911 static int meyeioc_qbuf_capt(int *nb)
 912 {
 913         if (!meye.grab_fbuffer)
 914                 return -EINVAL;
 915
 916         if (*nb >= gbuffers)
 917                 return -EINVAL;
 918
 919         if (*nb < 0) {
 920                 /* stop capture */
 921                 mchip_hic_stop();
 922                 return 0;
 923         }
 924
 925         if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
 926                 return -EBUSY;
 927
 928         mutex_lock(&meye.lock);
 929
 930         if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
 931                 mchip_cont_compression_start();
 932
 933         meye.grab_buffer[*nb].state = MEYE_BUF_USING;
 934         kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
 935                          &meye.grabq_lock);
 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                 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
 968                                 sizeof(int), &meye.doneq_lock) != sizeof(int))
 969                                         break;
 970         }
 971         *i = meye.grab_buffer[*i].size;
 972         mutex_unlock(&meye.lock);
 973         return 0;
 974 }
 975
 976 static int meyeioc_stillcapt(void)
 977 {
 978         if (!meye.grab_fbuffer)
 979                 return -EINVAL;
 980
 981         if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
 982                 return -EBUSY;
 983
 984         mutex_lock(&meye.lock);
 985         meye.grab_buffer[0].state = MEYE_BUF_USING;
 986         mchip_take_picture();
 987
 988         mchip_get_picture(meye.grab_fbuffer,
 989                         mchip_hsize() * mchip_vsize() * 2);
 990
 991         meye.grab_buffer[0].state = MEYE_BUF_DONE;
 992         mutex_unlock(&meye.lock);
 993
 994         return 0;
 995 }
 996
 997 static int meyeioc_stilljcapt(int *len)
 998 {
 999         if (!meye.grab_fbuffer)
1000                 return -EINVAL;
1001
1002         if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1003                 return -EBUSY;
1004
1005         mutex_lock(&meye.lock);
1006         meye.grab_buffer[0].state = MEYE_BUF_USING;
1007         *len = -1;
1008
1009         while (*len == -1) {
1010                 mchip_take_picture();
1011                 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1012         }
1013
1014         meye.grab_buffer[0].state = MEYE_BUF_DONE;
1015         mutex_unlock(&meye.lock);
1016         return 0;
1017 }
1018
1019 static int vidioc_querycap(struct file *file, void *fh,
1020                                 struct v4l2_capability *cap)
1021 {
1022         strcpy(cap->driver, "meye");
1023         strcpy(cap->card, "meye");
1024         sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1025
1026         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
1027                             V4L2_CAP_STREAMING;
1028         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1029
1030         return 0;
1031 }
1032
1033 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1034 {
1035         if (i->index != 0)
1036                 return -EINVAL;
1037
1038         strcpy(i->name, "Camera");
1039         i->type = V4L2_INPUT_TYPE_CAMERA;
1040
1041         return 0;
1042 }
1043
1044 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1045 {
1046         *i = 0;
1047         return 0;
1048 }
1049
1050 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1051 {
1052         if (i != 0)
1053                 return -EINVAL;
1054
1055         return 0;
1056 }
1057
1058 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1059 {
1060         mutex_lock(&meye.lock);
1061         switch (ctrl->id) {
1062         case V4L2_CID_BRIGHTNESS:
1063                 sony_pic_camera_command(
1064                         SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1065                 meye.brightness = ctrl->val << 10;
1066                 break;
1067         case V4L2_CID_HUE:
1068                 sony_pic_camera_command(
1069                         SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1070                 meye.hue = ctrl->val << 10;
1071                 break;
1072         case V4L2_CID_CONTRAST:
1073                 sony_pic_camera_command(
1074                         SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1075                 meye.contrast = ctrl->val << 10;
1076                 break;
1077         case V4L2_CID_SATURATION:
1078                 sony_pic_camera_command(
1079                         SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1080                 meye.colour = ctrl->val << 10;
1081                 break;
1082         case V4L2_CID_MEYE_AGC:
1083                 sony_pic_camera_command(
1084                         SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1085                 meye.params.agc = ctrl->val;
1086                 break;
1087         case V4L2_CID_SHARPNESS:
1088                 sony_pic_camera_command(
1089                         SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1090                 meye.params.sharpness = ctrl->val;
1091                 break;
1092         case V4L2_CID_MEYE_PICTURE:
1093                 sony_pic_camera_command(
1094                         SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1095                 meye.params.picture = ctrl->val;
1096                 break;
1097         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1098                 meye.params.quality = ctrl->val;
1099                 break;
1100         case V4L2_CID_MEYE_FRAMERATE:
1101                 meye.params.framerate = ctrl->val;
1102                 break;
1103         default:
1104                 mutex_unlock(&meye.lock);
1105                 return -EINVAL;
1106         }
1107         mutex_unlock(&meye.lock);
1108
1109         return 0;
1110 }
1111
1112 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1113                                 struct v4l2_fmtdesc *f)
1114 {
1115         if (f->index > 1)
1116                 return -EINVAL;
1117
1118         if (f->index == 0) {
1119                 /* standard YUV 422 capture */
1120                 f->flags = 0;
1121                 strcpy(f->description, "YUV422");
1122                 f->pixelformat = V4L2_PIX_FMT_YUYV;
1123         } else {
1124                 /* compressed MJPEG capture */
1125                 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1126                 strcpy(f->description, "MJPEG");
1127                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1128         }
1129
1130         return 0;
1131 }
1132
1133 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1134                                 struct v4l2_format *f)
1135 {
1136         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1137             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1138                 return -EINVAL;
1139
1140         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1141             f->fmt.pix.field != V4L2_FIELD_NONE)
1142                 return -EINVAL;
1143
1144         f->fmt.pix.field = V4L2_FIELD_NONE;
1145
1146         if (f->fmt.pix.width <= 320) {
1147                 f->fmt.pix.width = 320;
1148                 f->fmt.pix.height = 240;
1149         } else {
1150                 f->fmt.pix.width = 640;
1151                 f->fmt.pix.height = 480;
1152         }
1153
1154         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1155         f->fmt.pix.sizeimage = f->fmt.pix.height *
1156                                f->fmt.pix.bytesperline;
1157         f->fmt.pix.colorspace = 0;
1158
1159         return 0;
1160 }
1161
1162 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1163                                     struct v4l2_format *f)
1164 {
1165         switch (meye.mchip_mode) {
1166         case MCHIP_HIC_MODE_CONT_OUT:
1167         default:
1168                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1169                 break;
1170         case MCHIP_HIC_MODE_CONT_COMP:
1171                 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1172                 break;
1173         }
1174
1175         f->fmt.pix.field = V4L2_FIELD_NONE;
1176         f->fmt.pix.width = mchip_hsize();
1177         f->fmt.pix.height = mchip_vsize();
1178         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1179         f->fmt.pix.sizeimage = f->fmt.pix.height *
1180                                f->fmt.pix.bytesperline;
1181
1182         return 0;
1183 }
1184
1185 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1186                                     struct v4l2_format *f)
1187 {
1188         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1189             f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1190                 return -EINVAL;
1191
1192         if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1193             f->fmt.pix.field != V4L2_FIELD_NONE)
1194                 return -EINVAL;
1195
1196         f->fmt.pix.field = V4L2_FIELD_NONE;
1197         mutex_lock(&meye.lock);
1198
1199         if (f->fmt.pix.width <= 320) {
1200                 f->fmt.pix.width = 320;
1201                 f->fmt.pix.height = 240;
1202                 meye.params.subsample = 1;
1203         } else {
1204                 f->fmt.pix.width = 640;
1205                 f->fmt.pix.height = 480;
1206                 meye.params.subsample = 0;
1207         }
1208
1209         switch (f->fmt.pix.pixelformat) {
1210         case V4L2_PIX_FMT_YUYV:
1211                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1212                 break;
1213         case V4L2_PIX_FMT_MJPEG:
1214                 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1215                 break;
1216         }
1217
1218         mutex_unlock(&meye.lock);
1219         f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1220         f->fmt.pix.sizeimage = f->fmt.pix.height *
1221                                f->fmt.pix.bytesperline;
1222         f->fmt.pix.colorspace = 0;
1223
1224         return 0;
1225 }
1226
1227 static int vidioc_reqbufs(struct file *file, void *fh,
1228                                 struct v4l2_requestbuffers *req)
1229 {
1230         int i;
1231
1232         if (req->memory != V4L2_MEMORY_MMAP)
1233                 return -EINVAL;
1234
1235         if (meye.grab_fbuffer && req->count == gbuffers) {
1236                 /* already allocated, no modifications */
1237                 return 0;
1238         }
1239
1240         mutex_lock(&meye.lock);
1241         if (meye.grab_fbuffer) {
1242                 for (i = 0; i < gbuffers; i++)
1243                         if (meye.vma_use_count[i]) {
1244                                 mutex_unlock(&meye.lock);
1245                                 return -EINVAL;
1246                         }
1247                 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1248                 meye.grab_fbuffer = NULL;
1249         }
1250
1251         gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1252         req->count = gbuffers;
1253         meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1254
1255         if (!meye.grab_fbuffer) {
1256                 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1257                 mutex_unlock(&meye.lock);
1258                 return -ENOMEM;
1259         }
1260
1261         for (i = 0; i < gbuffers; i++)
1262                 meye.vma_use_count[i] = 0;
1263
1264         mutex_unlock(&meye.lock);
1265
1266         return 0;
1267 }
1268
1269 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1270 {
1271         unsigned int index = buf->index;
1272
1273         if (index >= gbuffers)
1274                 return -EINVAL;
1275
1276         buf->bytesused = meye.grab_buffer[index].size;
1277         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1278
1279         if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1280                 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1281
1282         if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1283                 buf->flags |= V4L2_BUF_FLAG_DONE;
1284
1285         buf->field = V4L2_FIELD_NONE;
1286         buf->timestamp = meye.grab_buffer[index].timestamp;
1287         buf->sequence = meye.grab_buffer[index].sequence;
1288         buf->memory = V4L2_MEMORY_MMAP;
1289         buf->m.offset = index * gbufsize;
1290         buf->length = gbufsize;
1291
1292         return 0;
1293 }
1294
1295 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1296 {
1297         if (buf->memory != V4L2_MEMORY_MMAP)
1298                 return -EINVAL;
1299
1300         if (buf->index >= gbuffers)
1301                 return -EINVAL;
1302
1303         if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1304                 return -EINVAL;
1305
1306         mutex_lock(&meye.lock);
1307         buf->flags |= V4L2_BUF_FLAG_QUEUED;
1308         buf->flags &= ~V4L2_BUF_FLAG_DONE;
1309         meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1310         kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1311                         sizeof(int), &meye.grabq_lock);
1312         mutex_unlock(&meye.lock);
1313
1314         return 0;
1315 }
1316
1317 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1318 {
1319         int reqnr;
1320
1321         if (buf->memory != V4L2_MEMORY_MMAP)
1322                 return -EINVAL;
1323
1324         mutex_lock(&meye.lock);
1325
1326         if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1327                 mutex_unlock(&meye.lock);
1328                 return -EAGAIN;
1329         }
1330
1331         if (wait_event_interruptible(meye.proc_list,
1332                                      kfifo_len(&meye.doneq) != 0) < 0) {
1333                 mutex_unlock(&meye.lock);
1334                 return -EINTR;
1335         }
1336
1337         if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1338                        sizeof(int), &meye.doneq_lock)) {
1339                 mutex_unlock(&meye.lock);
1340                 return -EBUSY;
1341         }
1342
1343         if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1344                 mutex_unlock(&meye.lock);
1345                 return -EINVAL;
1346         }
1347
1348         buf->index = reqnr;
1349         buf->bytesused = meye.grab_buffer[reqnr].size;
1350         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1351         buf->field = V4L2_FIELD_NONE;
1352         buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1353         buf->sequence = meye.grab_buffer[reqnr].sequence;
1354         buf->memory = V4L2_MEMORY_MMAP;
1355         buf->m.offset = reqnr * gbufsize;
1356         buf->length = gbufsize;
1357         meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1358         mutex_unlock(&meye.lock);
1359
1360         return 0;
1361 }
1362
1363 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1364 {
1365         mutex_lock(&meye.lock);
1366
1367         switch (meye.mchip_mode) {
1368         case MCHIP_HIC_MODE_CONT_OUT:
1369                 mchip_continuous_start();
1370                 break;
1371         case MCHIP_HIC_MODE_CONT_COMP:
1372                 mchip_cont_compression_start();
1373                 break;
1374         default:
1375                 mutex_unlock(&meye.lock);
1376                 return -EINVAL;
1377         }
1378
1379         mutex_unlock(&meye.lock);
1380
1381         return 0;
1382 }
1383
1384 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1385 {
1386         mutex_lock(&meye.lock);
1387         mchip_hic_stop();
1388         kfifo_reset(&meye.grabq);
1389         kfifo_reset(&meye.doneq);
1390
1391         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1392                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1393
1394         mutex_unlock(&meye.lock);
1395         return 0;
1396 }
1397
1398 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1399                            unsigned int cmd, void *arg)
1400 {
1401         switch (cmd) {
1402         case MEYEIOC_G_PARAMS:
1403                 return meyeioc_g_params((struct meye_params *) arg);
1404
1405         case MEYEIOC_S_PARAMS:
1406                 return meyeioc_s_params((struct meye_params *) arg);
1407
1408         case MEYEIOC_QBUF_CAPT:
1409                 return meyeioc_qbuf_capt((int *) arg);
1410
1411         case MEYEIOC_SYNC:
1412                 return meyeioc_sync(file, fh, (int *) arg);
1413
1414         case MEYEIOC_STILLCAPT:
1415                 return meyeioc_stillcapt();
1416
1417         case MEYEIOC_STILLJCAPT:
1418                 return meyeioc_stilljcapt((int *) arg);
1419
1420         default:
1421                 return -ENOTTY;
1422         }
1423
1424 }
1425
1426 static __poll_t meye_poll(struct file *file, poll_table *wait)
1427 {
1428         __poll_t res = v4l2_ctrl_poll(file, wait);
1429
1430         mutex_lock(&meye.lock);
1431         poll_wait(file, &meye.proc_list, wait);
1432         if (kfifo_len(&meye.doneq))
1433                 res |= POLLIN | POLLRDNORM;
1434         mutex_unlock(&meye.lock);
1435         return res;
1436 }
1437
1438 static void meye_vm_open(struct vm_area_struct *vma)
1439 {
1440         long idx = (long)vma->vm_private_data;
1441         meye.vma_use_count[idx]++;
1442 }
1443
1444 static void meye_vm_close(struct vm_area_struct *vma)
1445 {
1446         long idx = (long)vma->vm_private_data;
1447         meye.vma_use_count[idx]--;
1448 }
1449
1450 static const struct vm_operations_struct meye_vm_ops = {
1451         .open           = meye_vm_open,
1452         .close          = meye_vm_close,
1453 };
1454
1455 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1456 {
1457         unsigned long start = vma->vm_start;
1458         unsigned long size = vma->vm_end - vma->vm_start;
1459         unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1460         unsigned long page, pos;
1461
1462         mutex_lock(&meye.lock);
1463         if (size > gbuffers * gbufsize) {
1464                 mutex_unlock(&meye.lock);
1465                 return -EINVAL;
1466         }
1467         if (!meye.grab_fbuffer) {
1468                 int i;
1469
1470                 /* lazy allocation */
1471                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1472                 if (!meye.grab_fbuffer) {
1473                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1474                         mutex_unlock(&meye.lock);
1475                         return -ENOMEM;
1476                 }
1477                 for (i = 0; i < gbuffers; i++)
1478                         meye.vma_use_count[i] = 0;
1479         }
1480         pos = (unsigned long)meye.grab_fbuffer + offset;
1481
1482         while (size > 0) {
1483                 page = vmalloc_to_pfn((void *)pos);
1484                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1485                         mutex_unlock(&meye.lock);
1486                         return -EAGAIN;
1487                 }
1488                 start += PAGE_SIZE;
1489                 pos += PAGE_SIZE;
1490                 if (size > PAGE_SIZE)
1491                         size -= PAGE_SIZE;
1492                 else
1493                         size = 0;
1494         }
1495
1496         vma->vm_ops = &meye_vm_ops;
1497         vma->vm_flags &= ~VM_IO;        /* not I/O memory */
1498         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1499         vma->vm_private_data = (void *) (offset / gbufsize);
1500         meye_vm_open(vma);
1501
1502         mutex_unlock(&meye.lock);
1503         return 0;
1504 }
1505
1506 static const struct v4l2_file_operations meye_fops = {
1507         .owner          = THIS_MODULE,
1508         .open           = meye_open,
1509         .release        = meye_release,
1510         .mmap           = meye_mmap,
1511         .unlocked_ioctl = video_ioctl2,
1512         .poll           = meye_poll,
1513 };
1514
1515 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1516         .vidioc_querycap        = vidioc_querycap,
1517         .vidioc_enum_input      = vidioc_enum_input,
1518         .vidioc_g_input         = vidioc_g_input,
1519         .vidioc_s_input         = vidioc_s_input,
1520         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1521         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1522         .vidioc_g_fmt_vid_cap   = vidioc_g_fmt_vid_cap,
1523         .vidioc_s_fmt_vid_cap   = vidioc_s_fmt_vid_cap,
1524         .vidioc_reqbufs         = vidioc_reqbufs,
1525         .vidioc_querybuf        = vidioc_querybuf,
1526         .vidioc_qbuf            = vidioc_qbuf,
1527         .vidioc_dqbuf           = vidioc_dqbuf,
1528         .vidioc_streamon        = vidioc_streamon,
1529         .vidioc_streamoff       = vidioc_streamoff,
1530         .vidioc_log_status      = v4l2_ctrl_log_status,
1531         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1532         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1533         .vidioc_default         = vidioc_default,
1534 };
1535
1536 static const struct video_device meye_template = {
1537         .name           = "meye",
1538         .fops           = &meye_fops,
1539         .ioctl_ops      = &meye_ioctl_ops,
1540         .release        = video_device_release_empty,
1541 };
1542
1543 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1544         .s_ctrl = meye_s_ctrl,
1545 };
1546
1547 #ifdef CONFIG_PM
1548 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1549 {
1550         pci_save_state(pdev);
1551         meye.pm_mchip_mode = meye.mchip_mode;
1552         mchip_hic_stop();
1553         mchip_set(MCHIP_MM_INTA, 0x0);
1554         return 0;
1555 }
1556
1557 static int meye_resume(struct pci_dev *pdev)
1558 {
1559         pci_restore_state(pdev);
1560         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1561
1562         mchip_delay(MCHIP_HIC_CMD, 0);
1563         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1564         msleep(1);
1565         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1566         msleep(1);
1567         mchip_set(MCHIP_MM_PCI_MODE, 5);
1568         msleep(1);
1569         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1570
1571         switch (meye.pm_mchip_mode) {
1572         case MCHIP_HIC_MODE_CONT_OUT:
1573                 mchip_continuous_start();
1574                 break;
1575         case MCHIP_HIC_MODE_CONT_COMP:
1576                 mchip_cont_compression_start();
1577                 break;
1578         }
1579         return 0;
1580 }
1581 #endif
1582
1583 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1584 {
1585         static const struct v4l2_ctrl_config ctrl_agc = {
1586                 .id = V4L2_CID_MEYE_AGC,
1587                 .type = V4L2_CTRL_TYPE_INTEGER,
1588                 .ops = &meye_ctrl_ops,
1589                 .name = "AGC",
1590                 .max = 63,
1591                 .step = 1,
1592                 .def = 48,
1593                 .flags = V4L2_CTRL_FLAG_SLIDER,
1594         };
1595         static const struct v4l2_ctrl_config ctrl_picture = {
1596                 .id = V4L2_CID_MEYE_PICTURE,
1597                 .type = V4L2_CTRL_TYPE_INTEGER,
1598                 .ops = &meye_ctrl_ops,
1599                 .name = "Picture",
1600                 .max = 63,
1601                 .step = 1,
1602         };
1603         static const struct v4l2_ctrl_config ctrl_framerate = {
1604                 .id = V4L2_CID_MEYE_FRAMERATE,
1605                 .type = V4L2_CTRL_TYPE_INTEGER,
1606                 .ops = &meye_ctrl_ops,
1607                 .name = "Framerate",
1608                 .max = 31,
1609                 .step = 1,
1610         };
1611         struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1612         int ret = -EBUSY;
1613         unsigned long mchip_adr;
1614
1615         if (meye.mchip_dev != NULL) {
1616                 printk(KERN_ERR "meye: only one device allowed!\n");
1617                 return ret;
1618         }
1619
1620         ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1621         if (ret < 0) {
1622                 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1623                 return ret;
1624         }
1625         ret = -ENOMEM;
1626         meye.mchip_dev = pcidev;
1627
1628         meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1629         if (!meye.grab_temp)
1630                 goto outvmalloc;
1631
1632         spin_lock_init(&meye.grabq_lock);
1633         if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1634                         GFP_KERNEL))
1635                 goto outkfifoalloc1;
1636
1637         spin_lock_init(&meye.doneq_lock);
1638         if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1639                         GFP_KERNEL))
1640                 goto outkfifoalloc2;
1641
1642         meye.vdev = meye_template;
1643         meye.vdev.v4l2_dev = &meye.v4l2_dev;
1644
1645         ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1646         if (ret) {
1647                 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1648                 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1649                 goto outsonypienable;
1650         }
1651
1652         ret = pci_enable_device(meye.mchip_dev);
1653         if (ret) {
1654                 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1655                 goto outenabledev;
1656         }
1657
1658         ret = -EIO;
1659         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1660         if (!mchip_adr) {
1661                 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1662                 goto outregions;
1663         }
1664         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1665                                 pci_resource_len(meye.mchip_dev, 0),
1666                                 "meye")) {
1667                 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1668                 goto outregions;
1669         }
1670         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1671         if (!meye.mchip_mmregs) {
1672                 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1673                 goto outremap;
1674         }
1675
1676         meye.mchip_irq = pcidev->irq;
1677         if (request_irq(meye.mchip_irq, meye_irq,
1678                         IRQF_SHARED, "meye", meye_irq)) {
1679                 v4l2_err(v4l2_dev, "request_irq failed\n");
1680                 goto outreqirq;
1681         }
1682
1683         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1684         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1685
1686         pci_set_master(meye.mchip_dev);
1687
1688         /* Ask the camera to perform a soft reset. */
1689         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1690
1691         mchip_delay(MCHIP_HIC_CMD, 0);
1692         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1693
1694         msleep(1);
1695         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1696
1697         msleep(1);
1698         mchip_set(MCHIP_MM_PCI_MODE, 5);
1699
1700         msleep(1);
1701         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1702
1703         mutex_init(&meye.lock);
1704         init_waitqueue_head(&meye.proc_list);
1705
1706         v4l2_ctrl_handler_init(&meye.hdl, 3);
1707         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1708                           V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1709         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1710                           V4L2_CID_HUE, 0, 63, 1, 32);
1711         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1712                           V4L2_CID_CONTRAST, 0, 63, 1, 32);
1713         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1714                           V4L2_CID_SATURATION, 0, 63, 1, 32);
1715         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1716         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1717                           V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1718         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1719         v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1720                           V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1721         v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1722         if (meye.hdl.error) {
1723                 v4l2_err(v4l2_dev, "couldn't register controls\n");
1724                 goto outvideoreg;
1725         }
1726
1727         v4l2_ctrl_handler_setup(&meye.hdl);
1728         meye.vdev.ctrl_handler = &meye.hdl;
1729
1730         if (video_register_device(&meye.vdev, VFL_TYPE_GRABBER,
1731                                   video_nr) < 0) {
1732                 v4l2_err(v4l2_dev, "video_register_device failed\n");
1733                 goto outvideoreg;
1734         }
1735
1736         v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1737                MEYE_DRIVER_VERSION);
1738         v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1739                meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1740
1741         return 0;
1742
1743 outvideoreg:
1744         v4l2_ctrl_handler_free(&meye.hdl);
1745         free_irq(meye.mchip_irq, meye_irq);
1746 outreqirq:
1747         iounmap(meye.mchip_mmregs);
1748 outremap:
1749         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1750                            pci_resource_len(meye.mchip_dev, 0));
1751 outregions:
1752         pci_disable_device(meye.mchip_dev);
1753 outenabledev:
1754         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1755 outsonypienable:
1756         kfifo_free(&meye.doneq);
1757 outkfifoalloc2:
1758         kfifo_free(&meye.grabq);
1759 outkfifoalloc1:
1760         vfree(meye.grab_temp);
1761 outvmalloc:
1762         return ret;
1763 }
1764
1765 static void meye_remove(struct pci_dev *pcidev)
1766 {
1767         video_unregister_device(&meye.vdev);
1768
1769         mchip_hic_stop();
1770
1771         mchip_dma_free();
1772
1773         /* disable interrupts */
1774         mchip_set(MCHIP_MM_INTA, 0x0);
1775
1776         free_irq(meye.mchip_irq, meye_irq);
1777
1778         iounmap(meye.mchip_mmregs);
1779
1780         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1781                            pci_resource_len(meye.mchip_dev, 0));
1782
1783         pci_disable_device(meye.mchip_dev);
1784
1785         sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1786
1787         kfifo_free(&meye.doneq);
1788         kfifo_free(&meye.grabq);
1789
1790         vfree(meye.grab_temp);
1791
1792         if (meye.grab_fbuffer) {
1793                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1794                 meye.grab_fbuffer = NULL;
1795         }
1796
1797         printk(KERN_INFO "meye: removed\n");
1798 }
1799
1800 static const struct pci_device_id meye_pci_tbl[] = {
1801         { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1802         { }
1803 };
1804
1805 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1806
1807 static struct pci_driver meye_driver = {
1808         .name           = "meye",
1809         .id_table       = meye_pci_tbl,
1810         .probe          = meye_probe,
1811         .remove         = meye_remove,
1812 #ifdef CONFIG_PM
1813         .suspend        = meye_suspend,
1814         .resume         = meye_resume,
1815 #endif
1816 };
1817
1818 static int __init meye_init(void)
1819 {
1820         gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1821         if (gbufsize > MEYE_MAX_BUFSIZE)
1822                 gbufsize = MEYE_MAX_BUFSIZE;
1823         gbufsize = PAGE_ALIGN(gbufsize);
1824         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1825                          gbuffers,
1826                          gbufsize / 1024, gbuffers * gbufsize / 1024);
1827         return pci_register_driver(&meye_driver);
1828 }
1829
1830 static void __exit meye_exit(void)
1831 {
1832         pci_unregister_driver(&meye_driver);
1833 }
1834
1835 module_init(meye_init);
1836 module_exit(meye_exit);