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