drivers/media/pci/meye/meye.c

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