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