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