drivers/media/video/meye.c

   1 /*
   2  * Motion Eye video4linux driver for Sony Vaio PictureBook
   3  *
   4  * Copyright (C) 2001-2003 Stelian Pop <stelian@popies.net>
   5  *
   6  * Copyright (C) 2001-2002 Alcôve <www.alcove.com>
   7  *
   8  * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
   9  *
  10  * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
  11  *
  12  * Some parts borrowed from various video4linux drivers, especially
  13  * bttv-driver.c and zoran.c, see original files for credits.
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28  */
  29 #include <linux/config.h>
  30 #include <linux/module.h>
  31 #include <linux/pci.h>
  32 #include <linux/sched.h>
  33 #include <linux/init.h>
  34 #include <linux/videodev.h>
  35 #include <asm/uaccess.h>
  36 #include <asm/io.h>
  37 #include <linux/delay.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/vmalloc.h>
  40
  41 #include "meye.h"
  42 #include "linux/meye.h"
  43
  44 /* driver structure - only one possible */
  45 static struct meye meye;
  46 /* number of grab buffers */
  47 static unsigned int gbuffers = 2;
  48 /* size of a grab buffer */
  49 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
  50 /* /dev/videoX registration number */
  51 static int video_nr = -1;
  52
  53 /****************************************************************************/
  54 /* Queue routines                                                           */
  55 /****************************************************************************/
  56
  57 /* Inits the queue */
  58 static inline void meye_initq(struct meye_queue *queue) {
  59         queue->head = queue->tail = 0;
  60         queue->len = 0;
  61         queue->s_lock = (spinlock_t)SPIN_LOCK_UNLOCKED;
  62         init_waitqueue_head(&queue->proc_list);
  63 }
  64
  65 /* Pulls an element from the queue */
  66 static inline int meye_pullq(struct meye_queue *queue) {
  67         int result;
  68         unsigned long flags;
  69
  70         spin_lock_irqsave(&queue->s_lock, flags);
  71         if (!queue->len) {
  72                 spin_unlock_irqrestore(&queue->s_lock, flags);
  73                 return -1;
  74         }
  75         result = queue->buf[queue->head];
  76         queue->head++;
  77         queue->head &= (MEYE_QUEUE_SIZE - 1);
  78         queue->len--;
  79         spin_unlock_irqrestore(&queue->s_lock, flags);
  80         return result;
  81 }
  82
  83 /* Pushes an element into the queue */
  84 static inline void meye_pushq(struct meye_queue *queue, int element) {
  85         unsigned long flags;
  86
  87         spin_lock_irqsave(&queue->s_lock, flags);
  88         if (queue->len == MEYE_QUEUE_SIZE) {
  89                 /* remove the first element */
  90                 queue->head++;
  91                 queue->head &= (MEYE_QUEUE_SIZE - 1);
  92                 queue->len--;
  93         }
  94         queue->buf[queue->tail] = element;
  95         queue->tail++;
  96         queue->tail &= (MEYE_QUEUE_SIZE - 1);
  97         queue->len++;
  98
  99         spin_unlock_irqrestore(&queue->s_lock, flags);
 100 }
 101
 102 /* Tests if the queue is empty */
 103 static inline int meye_emptyq(struct meye_queue *queue, int *elem) {
 104         int result;
 105         unsigned long flags;
 106
 107         spin_lock_irqsave(&queue->s_lock, flags);
 108         result = (queue->len == 0);
 109         if (!result && elem)
 110                 *elem = queue->buf[queue->head];
 111         spin_unlock_irqrestore(&queue->s_lock, flags);
 112         return result;
 113 }
 114
 115 /****************************************************************************/
 116 /* Memory allocation routines (stolen from bttv-driver.c)                   */
 117 /****************************************************************************/
 118
 119 /* Here we want the physical address of the memory.
 120  * This is used when initializing the contents of the area.
 121  */
 122 static inline unsigned long kvirt_to_pa(unsigned long adr) {
 123         unsigned long kva, ret;
 124
 125         kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
 126         kva |= adr & (PAGE_SIZE-1); /* restore the offset */
 127         ret = __pa(kva);
 128         return ret;
 129 }
 130
 131 static void *rvmalloc(unsigned long size) {
 132         void *mem;
 133         unsigned long adr;
 134
 135         size = PAGE_ALIGN(size);
 136         mem = vmalloc_32(size);
 137         if (mem) {
 138                 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 139                 adr = (unsigned long)mem;
 140                 while (size > 0) {
 141                         SetPageReserved(vmalloc_to_page((void *)adr));
 142                         adr += PAGE_SIZE;
 143                         size -= PAGE_SIZE;
 144                 }
 145         }
 146         return mem;
 147 }
 148
 149 static void rvfree(void * mem, unsigned long size) {
 150         unsigned long adr;
 151
 152         if (mem) {
 153                 adr = (unsigned long) mem;
 154                 while ((long) size > 0) {
 155                         ClearPageReserved(vmalloc_to_page((void *)adr));
 156                         adr += PAGE_SIZE;
 157                         size -= PAGE_SIZE;
 158                 }
 159                 vfree(mem);
 160         }
 161 }
 162
 163 /*
 164  * return a page table pointing to N pages of locked memory
 165  *
 166  * NOTE: The meye device expects dma_addr_t size to be 32 bits
 167  * (the toc must be exactly 1024 entries each of them being 4 bytes
 168  * in size, the whole result being 4096 bytes). We're using here
 169  * dma_addr_t for correctness but the compilation of this driver is
 170  * disabled for HIGHMEM64G=y, where sizeof(dma_addr_t) != 4
 171  */
 172 static int ptable_alloc(void) {
 173         dma_addr_t *pt;
 174         int i;
 175
 176         memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 177
 178         meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
 179                                                    PAGE_SIZE,
 180                                                    &meye.mchip_dmahandle,
 181                                                    GFP_KERNEL);
 182         if (!meye.mchip_ptable_toc) {
 183                 meye.mchip_dmahandle = 0;
 184                 return -1;
 185         }
 186
 187         pt = meye.mchip_ptable_toc;
 188         for (i = 0; i < MCHIP_NB_PAGES; i++) {
 189                 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
 190                                                           PAGE_SIZE,
 191                                                           pt,
 192                                                           GFP_KERNEL);
 193                 if (!meye.mchip_ptable[i]) {
 194                         int j;
 195                         pt = meye.mchip_ptable_toc;
 196                         for (j = 0; j < i; ++j) {
 197                                 dma_free_coherent(&meye.mchip_dev->dev,
 198                                                   PAGE_SIZE,
 199                                                   meye.mchip_ptable[j], *pt);
 200                                 pt++;
 201                         }
 202                         dma_free_coherent(&meye.mchip_dev->dev,
 203                                           PAGE_SIZE,
 204                                           meye.mchip_ptable_toc,
 205                                           meye.mchip_dmahandle);
 206                         meye.mchip_ptable_toc = 0;
 207                         meye.mchip_dmahandle = 0;
 208                         return -1;
 209                 }
 210                 pt++;
 211         }
 212         return 0;
 213 }
 214
 215 static void ptable_free(void) {
 216         dma_addr_t *pt;
 217         int i;
 218
 219         pt = meye.mchip_ptable_toc;
 220         for (i = 0; i < MCHIP_NB_PAGES; i++) {
 221                 if (meye.mchip_ptable[i])
 222                         dma_free_coherent(&meye.mchip_dev->dev,
 223                                           PAGE_SIZE,
 224                                           meye.mchip_ptable[i], *pt);
 225                 pt++;
 226         }
 227
 228         if (meye.mchip_ptable_toc)
 229                 dma_free_coherent(&meye.mchip_dev->dev,
 230                                   PAGE_SIZE,
 231                                   meye.mchip_ptable_toc,
 232                                   meye.mchip_dmahandle);
 233
 234         memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
 235         meye.mchip_ptable_toc = 0;
 236         meye.mchip_dmahandle = 0;
 237 }
 238
 239 /* copy data from ptable into buf */
 240 static void ptable_copy(u8 *buf, int start, int size, int pt_pages) {
 241         int i;
 242
 243         for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
 244                 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
 245                 if (start >= pt_pages)
 246                         start = 0;
 247         }
 248         memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
 249 }
 250
 251
 252 /****************************************************************************/
 253 /* JPEG tables at different qualities to load into the VRJ chip             */
 254 /****************************************************************************/
 255
 256 /* return a set of quantisation tables based on a quality from 1 to 10 */
 257 static u16 *jpeg_quantisation_tables(int *size, int quality) {
 258         static u16 tables0[] = {
 259                 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 260                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 261                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 262                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 263                 0xffff, 0xffff, 0xffff,
 264                 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 265                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 266                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 267                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 268                 0xffff, 0xffff, 0xffff,
 269         };
 270         static u16 tables1[] = {
 271                 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
 272                 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
 273                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 274                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 275                 0xffff, 0xffff, 0xffff,
 276                 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
 277                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 278                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 279                 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
 280                 0xffff, 0xffff, 0xffff,
 281         };
 282         static u16 tables2[] = {
 283                 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
 284                 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
 285                 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
 286                 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
 287                 0xe6ff, 0xfffd, 0xfff8,
 288                 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
 289                 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 290                 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 291                 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
 292                 0xf8f8, 0xf8f8, 0xfff8,
 293         };
 294         static u16 tables3[] = {
 295                 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
 296                 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
 297                 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
 298                 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
 299                 0x99c7, 0xaba8, 0xffa4,
 300                 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
 301                 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 302                 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 303                 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
 304                 0xa4a4, 0xa4a4, 0xffa4,
 305         };
 306         static u16 tables4[] = {
 307                 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
 308                 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
 309                 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
 310                 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
 311                 0x7396, 0x817e, 0xff7c,
 312                 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
 313                 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 314                 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 315                 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
 316                 0x7c7c, 0x7c7c, 0xff7c,
 317         };
 318         static u16 tables5[] = {
 319                 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
 320                 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
 321                 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
 322                 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
 323                 0x5c78, 0x6765, 0xff63,
 324                 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
 325                 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 326                 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 327                 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
 328                 0x6363, 0x6363, 0xff63,
 329         };
 330         static u16 tables6[] = {
 331                 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
 332                 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
 333                 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
 334                 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
 335                 0x4a60, 0x5251, 0xff4f,
 336                 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
 337                 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 338                 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 339                 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
 340                 0x4f4f, 0x4f4f, 0xff4f,
 341         };
 342         static u16 tables7[] = {
 343                 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
 344                 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
 345                 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
 346                 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
 347                 0x3748, 0x3e3d, 0xff3b,
 348                 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
 349                 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 350                 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 351                 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
 352                 0x3b3b, 0x3b3b, 0xff3b,
 353         };
 354         static u16 tables8[] = {
 355                 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
 356                 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
 357                 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
 358                 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
 359                 0x2530, 0x2928, 0xff28,
 360                 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
 361                 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 362                 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 363                 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
 364                 0x2828, 0x2828, 0xff28,
 365         };
 366         static u16 tables9[] = {
 367                 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
 368                 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
 369                 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
 370                 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
 371                 0x1218, 0x1514, 0xff14,
 372                 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
 373                 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 374                 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 375                 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
 376                 0x1414, 0x1414, 0xff14,
 377         };
 378         static u16 tables10[] = {
 379                 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 380                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 381                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 382                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 383                 0x0101, 0x0101, 0xff01,
 384                 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 385                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 386                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 387                 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 388                 0x0101, 0x0101, 0xff01,
 389         };
 390
 391         switch (quality) {
 392         case 0:
 393                 *size = sizeof(tables0);
 394                 return tables0;
 395         case 1:
 396                 *size = sizeof(tables1);
 397                 return tables1;
 398         case 2:
 399                 *size = sizeof(tables2);
 400                 return tables2;
 401         case 3:
 402                 *size = sizeof(tables3);
 403                 return tables3;
 404         case 4:
 405                 *size = sizeof(tables4);
 406                 return tables4;
 407         case 5:
 408                 *size = sizeof(tables5);
 409                 return tables5;
 410         case 6:
 411                 *size = sizeof(tables6);
 412                 return tables6;
 413         case 7:
 414                 *size = sizeof(tables7);
 415                 return tables7;
 416         case 8:
 417                 *size = sizeof(tables8);
 418                 return tables8;
 419         case 9:
 420                 *size = sizeof(tables9);
 421                 return tables9;
 422         case 10:
 423                 *size = sizeof(tables10);
 424                 return tables10;
 425         default:
 426                 printk(KERN_WARNING "meye: invalid quality level %d - using 8\n", quality);
 427                 *size = sizeof(tables8);
 428                 return tables8;
 429         }
 430         return NULL;
 431 }
 432
 433 /* return a generic set of huffman tables */
 434 static u16 *jpeg_huffman_tables(int *size) {
 435         static u16 tables[] = {
 436                 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
 437                 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
 438                 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
 439                 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
 440                 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
 441                 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
 442                 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
 443                 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
 444                 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
 445                 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
 446                 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
 447                 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
 448                 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
 449                 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
 450                 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
 451                 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
 452                 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
 453                 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
 454                 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
 455                 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
 456                 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
 457                 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
 458                 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
 459                 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
 460                 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
 461                 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
 462                 0xFF0B,
 463                 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
 464                 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
 465                 0xFF0B
 466         };
 467
 468         *size = sizeof(tables);
 469         return tables;
 470 }
 471
 472 /****************************************************************************/
 473 /* MCHIP low-level functions                                                */
 474 /****************************************************************************/
 475
 476 /* waits for the specified miliseconds */
 477 static inline void wait_ms(unsigned int ms) {
 478         if (!in_interrupt()) {
 479                 set_current_state(TASK_UNINTERRUPTIBLE);
 480                 schedule_timeout(1 + ms * HZ / 1000);
 481         }
 482         else
 483                 mdelay(ms);
 484 }
 485
 486 /* returns the horizontal capture size */
 487 static inline int mchip_hsize(void) {
 488         return meye.params.subsample ? 320 : 640;
 489 }
 490
 491 /* returns the vertical capture size */
 492 static inline int mchip_vsize(void) {
 493         return meye.params.subsample ? 240 : 480;
 494 }
 495
 496 /* waits for a register to be available */
 497 static void mchip_sync(int reg) {
 498         u32 status;
 499         int i;
 500
 501         if (reg == MCHIP_MM_FIFO_DATA) {
 502                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 503                         status = readl(meye.mchip_mmregs + MCHIP_MM_FIFO_STATUS);
 504                         if (!(status & MCHIP_MM_FIFO_WAIT)) {
 505                                 printk(KERN_WARNING "meye: fifo not ready\n");
 506                                 return;
 507                         }
 508                         if (status & MCHIP_MM_FIFO_READY)
 509                                 return;
 510                         udelay(1);
 511                 }
 512         }
 513         else if (reg > 0x80) {
 514                 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
 515                                          : MCHIP_HIC_STATUS_VRJ_RDY;
 516                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 517                         status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
 518                         if (status & mask)
 519                                 return;
 520                         udelay(1);
 521                 }
 522         }
 523         else
 524                 return;
 525         printk(KERN_WARNING "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n", reg, status);
 526 }
 527
 528 /* sets a value into the register */
 529 static inline void mchip_set(int reg, u32 v) {
 530         mchip_sync(reg);
 531         writel(v, meye.mchip_mmregs + reg);
 532 }
 533
 534 /* get the register value */
 535 static inline u32 mchip_read(int reg) {
 536         mchip_sync(reg);
 537         return readl(meye.mchip_mmregs + reg);
 538 }
 539
 540 /* wait for a register to become a particular value */
 541 static inline int mchip_delay(u32 reg, u32 v) {
 542         int n = 10;
 543         while (--n && mchip_read(reg) != v)
 544                 udelay(1);
 545         return n;
 546 }
 547
 548 /* setup subsampling */
 549 static void mchip_subsample(void) {
 550         mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
 551         mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
 552         mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
 553         mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
 554         mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
 555         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
 556 }
 557
 558 /* set the framerate into the mchip */
 559 static void mchip_set_framerate(void) {
 560         mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
 561 }
 562
 563 /* load some huffman and quantisation tables into the VRJ chip ready
 564    for JPEG compression */
 565 static void mchip_load_tables(void) {
 566         int i;
 567         int size;
 568         u16 *tables;
 569
 570         tables = jpeg_huffman_tables(&size);
 571         for (i = 0; i < size / 2; i++)
 572                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 573
 574         tables = jpeg_quantisation_tables(&size, meye.params.quality);
 575         for (i = 0; i < size / 2; i++)
 576                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 577 }
 578
 579 /* setup the VRJ parameters in the chip */
 580 static void mchip_vrj_setup(u8 mode) {
 581
 582         mchip_set(MCHIP_VRJ_BUS_MODE, 5);
 583         mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
 584         mchip_set(MCHIP_VRJ_PDAT_USE, 1);
 585         mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
 586         mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
 587         mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
 588         mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
 589         mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
 590         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
 591         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
 592         mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
 593         mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
 594         mchip_set(MCHIP_VRJ_SOF1, 0x601);
 595         mchip_set(MCHIP_VRJ_SOF2, 0x1502);
 596         mchip_set(MCHIP_VRJ_SOF3, 0x1503);
 597         mchip_set(MCHIP_VRJ_SOF4, 0x1596);
 598         mchip_set(MCHIP_VRJ_SOS,  0x0ed0);
 599
 600         mchip_load_tables();
 601 }
 602
 603 /* sets the DMA parameters into the chip */
 604 static void mchip_dma_setup(u32 dma_addr) {
 605         int i;
 606
 607         mchip_set(MCHIP_MM_PT_ADDR, dma_addr);
 608         for (i = 0; i < 4; i++)
 609                 mchip_set(MCHIP_MM_FIR(i), 0);
 610         meye.mchip_fnum = 0;
 611 }
 612
 613 /* setup for DMA transfers - also zeros the framebuffer */
 614 static int mchip_dma_alloc(void) {
 615         if (!meye.mchip_dmahandle)
 616                 if (ptable_alloc())
 617                         return -1;
 618         return 0;
 619 }
 620
 621 /* frees the DMA buffer */
 622 static void mchip_dma_free(void) {
 623         if (meye.mchip_dmahandle) {
 624                 mchip_dma_setup(0);
 625                 ptable_free();
 626         }
 627 }
 628
 629 /* stop any existing HIC action and wait for any dma to complete then
 630    reset the dma engine */
 631 static void mchip_hic_stop(void) {
 632         int i, j;
 633
 634         meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
 635         if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
 636                 return;
 637         for (i = 0; i < 20; ++i) {
 638                 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
 639                 mchip_delay(MCHIP_HIC_CMD, 0);
 640                 for (j = 0; j < 100; ++j) {
 641                         if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 642                                 return;
 643                         wait_ms(1);
 644                 }
 645                 printk(KERN_ERR "meye: need to reset HIC!\n");
 646
 647                 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
 648                 wait_ms(250);
 649         }
 650         printk(KERN_ERR "meye: resetting HIC hanged!\n");
 651 }
 652
 653 /****************************************************************************/
 654 /* MCHIP frame processing functions                                         */
 655 /****************************************************************************/
 656
 657 /* get the next ready frame from the dma engine */
 658 static u32 mchip_get_frame(void) {
 659         u32 v;
 660
 661         v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
 662         return v;
 663 }
 664
 665 /* frees the current frame from the dma engine */
 666 static void mchip_free_frame(void) {
 667         mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
 668         meye.mchip_fnum++;
 669         meye.mchip_fnum %= 4;
 670 }
 671
 672 /* read one frame from the framebuffer assuming it was captured using
 673    a uncompressed transfer */
 674 static void mchip_cont_read_frame(u32 v, u8 *buf, int size) {
 675         int pt_id;
 676
 677         pt_id = (v >> 17) & 0x3FF;
 678
 679         ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
 680
 681 }
 682
 683 /* read a compressed frame from the framebuffer */
 684 static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
 685         int pt_start, pt_end, trailer;
 686         int fsize;
 687         int i;
 688
 689         pt_start = (v >> 19) & 0xFF;
 690         pt_end = (v >> 11) & 0xFF;
 691         trailer = (v >> 1) & 0x3FF;
 692
 693         if (pt_end < pt_start)
 694                 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
 695                         pt_end * PAGE_SIZE + trailer * 4;
 696         else
 697                 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
 698
 699         if (fsize > size) {
 700                 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
 701                        fsize);
 702                 return -1;
 703         }
 704
 705         ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
 706
 707
 708 #ifdef MEYE_JPEG_CORRECTION
 709
 710         /* Some mchip generated jpeg frames are incorrect. In most
 711          * (all ?) of those cases, the final EOI (0xff 0xd9) marker
 712          * is not present at the end of the frame.
 713          *
 714          * Since adding the final marker is not enough to restore
 715          * the jpeg integrity, we drop the frame.
 716          */
 717
 718         for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
 719
 720         if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
 721                 return -1;
 722
 723 #endif
 724
 725         return fsize;
 726 }
 727
 728 /* take a picture into SDRAM */
 729 static void mchip_take_picture(void) {
 730         int i;
 731
 732         mchip_hic_stop();
 733         mchip_subsample();
 734         mchip_dma_setup(meye.mchip_dmahandle);
 735
 736         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
 737         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 738
 739         mchip_delay(MCHIP_HIC_CMD, 0);
 740
 741         for (i = 0; i < 100; ++i) {
 742                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 743                         break;
 744                 wait_ms(1);
 745         }
 746 }
 747
 748 /* dma a previously taken picture into a buffer */
 749 static void mchip_get_picture(u8 *buf, int bufsize) {
 750         u32 v;
 751         int i;
 752
 753         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
 754         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 755
 756         mchip_delay(MCHIP_HIC_CMD, 0);
 757         for (i = 0; i < 100; ++i) {
 758                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 759                         break;
 760                 wait_ms(1);
 761         }
 762         for (i = 0; i < 4 ; ++i) {
 763                 v = mchip_get_frame();
 764                 if (v & MCHIP_MM_FIR_RDY) {
 765                         mchip_cont_read_frame(v, buf, bufsize);
 766                         break;
 767                 }
 768                 mchip_free_frame();
 769         }
 770 }
 771
 772 /* start continuous dma capture */
 773 static void mchip_continuous_start(void) {
 774         mchip_hic_stop();
 775         mchip_subsample();
 776         mchip_set_framerate();
 777         mchip_dma_setup(meye.mchip_dmahandle);
 778
 779         meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
 780
 781         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
 782         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 783
 784         mchip_delay(MCHIP_HIC_CMD, 0);
 785 }
 786
 787 /* compress one frame into a buffer */
 788 static int mchip_compress_frame(u8 *buf, int bufsize) {
 789         u32 v;
 790         int len = -1, i;
 791
 792         mchip_vrj_setup(0x3f);
 793         udelay(50);
 794
 795         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
 796         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 797
 798         mchip_delay(MCHIP_HIC_CMD, 0);
 799         for (i = 0; i < 100; ++i) {
 800                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 801                         break;
 802                 wait_ms(1);
 803         }
 804
 805         for (i = 0; i < 4 ; ++i) {
 806                 v = mchip_get_frame();
 807                 if (v & MCHIP_MM_FIR_RDY) {
 808                         len = mchip_comp_read_frame(v, buf, bufsize);
 809                         break;
 810                 }
 811                 mchip_free_frame();
 812         }
 813         return len;
 814 }
 815
 816 #if 0
 817 /* uncompress one image into a buffer */
 818 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) {
 819         mchip_vrj_setup(0x3f);
 820         udelay(50);
 821
 822         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
 823         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 824
 825         mchip_delay(MCHIP_HIC_CMD, 0);
 826
 827         return mchip_comp_read_frame(buf, bufsize);
 828 }
 829 #endif
 830
 831 /* start continuous compressed capture */
 832 static void mchip_cont_compression_start(void) {
 833         mchip_hic_stop();
 834         mchip_vrj_setup(0x3f);
 835         mchip_subsample();
 836         mchip_set_framerate();
 837         mchip_dma_setup(meye.mchip_dmahandle);
 838
 839         meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
 840
 841         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
 842         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 843
 844         mchip_delay(MCHIP_HIC_CMD, 0);
 845 }
 846
 847 /****************************************************************************/
 848 /* Interrupt handling                                                       */
 849 /****************************************************************************/
 850
 851 static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs) {
 852         u32 v;
 853         int reqnr;
 854         v = mchip_read(MCHIP_MM_INTA);
 855
 856         while (1) {
 857                 v = mchip_get_frame();
 858                 if (!(v & MCHIP_MM_FIR_RDY))
 859                         return IRQ_NONE;
 860                 switch (meye.mchip_mode) {
 861
 862                 case MCHIP_HIC_MODE_CONT_OUT:
 863                         if (!meye_emptyq(&meye.grabq, NULL)) {
 864                                 int nr = meye_pullq(&meye.grabq);
 865                                 mchip_cont_read_frame(
 866                                         v,
 867                                         meye.grab_fbuffer + gbufsize * nr,
 868                                         mchip_hsize() * mchip_vsize() * 2);
 869                                 meye.grab_buffer[nr].state = MEYE_BUF_DONE;
 870                                 wake_up_interruptible(&meye.grabq.proc_list);
 871                         }
 872                         break;
 873
 874                 case MCHIP_HIC_MODE_CONT_COMP:
 875                         if (!meye_emptyq(&meye.grabq, &reqnr)) {
 876                                 int size;
 877                                 size = mchip_comp_read_frame(
 878                                         v,
 879                                         meye.grab_fbuffer + gbufsize * reqnr,
 880                                         gbufsize);
 881                                 if (size == -1)
 882                                         break;
 883                                 reqnr = meye_pullq(&meye.grabq);
 884                                 meye.grab_buffer[reqnr].size = size;
 885                                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 886                                 wake_up_interruptible(&meye.grabq.proc_list);
 887                         }
 888                         break;
 889
 890                 default:
 891                         /* do not free frame, since it can be a snap */
 892                         return IRQ_NONE;
 893                 } /* switch */
 894
 895                 mchip_free_frame();
 896         }
 897         return IRQ_HANDLED;
 898 }
 899
 900 /****************************************************************************/
 901 /* video4linux integration                                                  */
 902 /****************************************************************************/
 903
 904 static int meye_open(struct inode *inode, struct file *file) {
 905         int i, err;
 906
 907         err = video_exclusive_open(inode,file);
 908         if (err < 0)
 909                 return err;
 910
 911         if (mchip_dma_alloc()) {
 912                 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
 913                 video_exclusive_release(inode,file);
 914                 return -ENOBUFS;
 915         }
 916         mchip_hic_stop();
 917         meye_initq(&meye.grabq);
 918         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
 919                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
 920         return 0;
 921 }
 922
 923 static int meye_release(struct inode *inode, struct file *file) {
 924         mchip_hic_stop();
 925         mchip_dma_free();
 926         video_exclusive_release(inode,file);
 927         return 0;
 928 }
 929
 930 static int meye_do_ioctl(struct inode *inode, struct file *file,
 931                          unsigned int cmd, void *arg) {
 932
 933         switch (cmd) {
 934
 935         case VIDIOCGCAP: {
 936                 struct video_capability *b = arg;
 937                 strcpy(b->name,meye.video_dev->name);
 938                 b->type = VID_TYPE_CAPTURE;
 939                 b->channels = 1;
 940                 b->audios = 0;
 941                 b->maxwidth = 640;
 942                 b->maxheight = 480;
 943                 b->minwidth = 320;
 944                 b->minheight = 240;
 945                 break;
 946         }
 947
 948         case VIDIOCGCHAN: {
 949                 struct video_channel *v = arg;
 950                 v->flags = 0;
 951                 v->tuners = 0;
 952                 v->type = VIDEO_TYPE_CAMERA;
 953                 if (v->channel != 0)
 954                         return -EINVAL;
 955                 strcpy(v->name,"Camera");
 956                 break;
 957         }
 958
 959         case VIDIOCSCHAN: {
 960                 struct video_channel *v = arg;
 961                 if (v->channel != 0)
 962                         return -EINVAL;
 963                 break;
 964         }
 965
 966         case VIDIOCGPICT: {
 967                 struct video_picture *p = arg;
 968                 *p = meye.picture;
 969                 break;
 970         }
 971
 972         case VIDIOCSPICT: {
 973                 struct video_picture *p = arg;
 974                 if (p->depth != 2)
 975                         return -EINVAL;
 976                 if (p->palette != VIDEO_PALETTE_YUV422)
 977                         return -EINVAL;
 978                 down(&meye.lock);
 979                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
 980                                       p->brightness >> 10);
 981                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
 982                                       p->hue >> 10);
 983                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
 984                                       p->colour >> 10);
 985                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
 986                                       p->contrast >> 10);
 987                 meye.picture = *p;
 988                 up(&meye.lock);
 989                 break;
 990         }
 991
 992         case VIDIOCSYNC: {
 993                 int *i = arg;
 994
 995                 if (*i < 0 || *i >= gbuffers)
 996                         return -EINVAL;
 997
 998                 switch (meye.grab_buffer[*i].state) {
 999
1000                 case MEYE_BUF_UNUSED:
1001                         return -EINVAL;
1002                 case MEYE_BUF_USING:
1003                         if (wait_event_interruptible(meye.grabq.proc_list,
1004                                                      (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
1005                                 return -EINTR;
1006                         /* fall through */
1007                 case MEYE_BUF_DONE:
1008                         meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1009                 }
1010                 break;
1011         }
1012
1013         case VIDIOCMCAPTURE: {
1014                 struct video_mmap *vm = arg;
1015                 int restart = 0;
1016
1017                 if (vm->frame >= gbuffers || vm->frame < 0)
1018                         return -EINVAL;
1019                 if (vm->format != VIDEO_PALETTE_YUV422)
1020                         return -EINVAL;
1021                 if (vm->height * vm->width * 2 > gbufsize)
1022                         return -EINVAL;
1023                 if (!meye.grab_fbuffer)
1024                         return -EINVAL;
1025                 if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
1026                         return -EBUSY;
1027
1028                 down(&meye.lock);
1029                 if (vm->width == 640 && vm->height == 480) {
1030                         if (meye.params.subsample) {
1031                                 meye.params.subsample = 0;
1032                                 restart = 1;
1033                         }
1034                 }
1035                 else if (vm->width == 320 && vm->height == 240) {
1036                         if (!meye.params.subsample) {
1037                                 meye.params.subsample = 1;
1038                                 restart = 1;
1039                         }
1040                 }
1041                 else {
1042                         up(&meye.lock);
1043                         return -EINVAL;
1044                 }
1045
1046                 if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT)
1047                         mchip_continuous_start();
1048                 meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
1049                 meye_pushq(&meye.grabq, vm->frame);
1050                 up(&meye.lock);
1051                 break;
1052         }
1053
1054         case VIDIOCGMBUF: {
1055                 struct video_mbuf *vm = arg;
1056                 int i;
1057
1058                 memset(vm, 0 , sizeof(*vm));
1059                 vm->size = gbufsize * gbuffers;
1060                 vm->frames = gbuffers;
1061                 for (i = 0; i < gbuffers; i++)
1062                         vm->offsets[i] = i * gbufsize;
1063                 break;
1064         }
1065
1066         case MEYEIOC_G_PARAMS: {
1067                 struct meye_params *p = arg;
1068                 *p = meye.params;
1069                 break;
1070         }
1071
1072         case MEYEIOC_S_PARAMS: {
1073                 struct meye_params *jp = arg;
1074                 if (jp->subsample > 1)
1075                         return -EINVAL;
1076                 if (jp->quality > 10)
1077                         return -EINVAL;
1078                 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
1079                         return -EINVAL;
1080                 if (jp->framerate > 31)
1081                         return -EINVAL;
1082                 down(&meye.lock);
1083                 if (meye.params.subsample != jp->subsample ||
1084                     meye.params.quality != jp->quality)
1085                         mchip_hic_stop();       /* need restart */
1086                 meye.params = *jp;
1087                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS,
1088                                       meye.params.sharpness);
1089                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC,
1090                                       meye.params.agc);
1091                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE,
1092                                       meye.params.picture);
1093                 up(&meye.lock);
1094                 break;
1095         }
1096
1097         case MEYEIOC_QBUF_CAPT: {
1098                 int *nb = arg;
1099
1100                 if (!meye.grab_fbuffer)
1101                         return -EINVAL;
1102                 if (*nb >= gbuffers)
1103                         return -EINVAL;
1104                 if (*nb < 0) {
1105                         /* stop capture */
1106                         mchip_hic_stop();
1107                         return 0;
1108                 }
1109                 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
1110                         return -EBUSY;
1111                 down(&meye.lock);
1112                 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
1113                         mchip_cont_compression_start();
1114                 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
1115                 meye_pushq(&meye.grabq, *nb);
1116                 up(&meye.lock);
1117                 break;
1118         }
1119
1120         case MEYEIOC_SYNC: {
1121                 int *i = arg;
1122
1123                 if (*i < 0 || *i >= gbuffers)
1124                         return -EINVAL;
1125
1126                 switch (meye.grab_buffer[*i].state) {
1127
1128                 case MEYE_BUF_UNUSED:
1129                         return -EINVAL;
1130                 case MEYE_BUF_USING:
1131                         if (wait_event_interruptible(meye.grabq.proc_list,
1132                                                      (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
1133                                 return -EINTR;
1134                         /* fall through */
1135                 case MEYE_BUF_DONE:
1136                         meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1137                 }
1138                 *i = meye.grab_buffer[*i].size;
1139                 break;
1140         }
1141
1142         case MEYEIOC_STILLCAPT: {
1143
1144                 if (!meye.grab_fbuffer)
1145                         return -EINVAL;
1146                 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1147                         return -EBUSY;
1148                 down(&meye.lock);
1149                 meye.grab_buffer[0].state = MEYE_BUF_USING;
1150                 mchip_take_picture();
1151                 mchip_get_picture(
1152                         meye.grab_fbuffer,
1153                         mchip_hsize() * mchip_vsize() * 2);
1154                 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1155                 up(&meye.lock);
1156                 break;
1157         }
1158
1159         case MEYEIOC_STILLJCAPT: {
1160                 int *len = arg;
1161
1162                 if (!meye.grab_fbuffer)
1163                         return -EINVAL;
1164                 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1165                         return -EBUSY;
1166                 down(&meye.lock);
1167                 meye.grab_buffer[0].state = MEYE_BUF_USING;
1168                 *len = -1;
1169                 while (*len == -1) {
1170                         mchip_take_picture();
1171                         *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1172                 }
1173                 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1174                 up(&meye.lock);
1175                 break;
1176         }
1177
1178         default:
1179                 return -ENOIOCTLCMD;
1180
1181         } /* switch */
1182
1183         return 0;
1184 }
1185
1186 static int meye_ioctl(struct inode *inode, struct file *file,
1187                      unsigned int cmd, unsigned long arg)
1188 {
1189         return video_usercopy(inode, file, cmd, arg, meye_do_ioctl);
1190 }
1191
1192 static int meye_mmap(struct file *file, struct vm_area_struct *vma) {
1193         unsigned long start = vma->vm_start;
1194         unsigned long size  = vma->vm_end - vma->vm_start;
1195         unsigned long page, pos;
1196
1197         down(&meye.lock);
1198         if (size > gbuffers * gbufsize) {
1199                 up(&meye.lock);
1200                 return -EINVAL;
1201         }
1202         if (!meye.grab_fbuffer) {
1203                 /* lazy allocation */
1204                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1205                 if (!meye.grab_fbuffer) {
1206                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1207                         up(&meye.lock);
1208                         return -ENOMEM;
1209                 }
1210         }
1211         pos = (unsigned long)meye.grab_fbuffer;
1212
1213         while (size > 0) {
1214                 page = kvirt_to_pa(pos);
1215                 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1216                         up(&meye.lock);
1217                         return -EAGAIN;
1218                 }
1219                 start += PAGE_SIZE;
1220                 pos += PAGE_SIZE;
1221                 size -= PAGE_SIZE;
1222         }
1223         up(&meye.lock);
1224         return 0;
1225 }
1226
1227 static struct file_operations meye_fops = {
1228         .owner          = THIS_MODULE,
1229         .open           = meye_open,
1230         .release        = meye_release,
1231         .mmap           = meye_mmap,
1232         .ioctl          = meye_ioctl,
1233         .llseek         = no_llseek,
1234 };
1235
1236 static struct video_device meye_template = {
1237         .owner          = THIS_MODULE,
1238         .name           = "meye",
1239         .type           = VID_TYPE_CAPTURE,
1240         .hardware       = VID_HARDWARE_MEYE,
1241         .fops           = &meye_fops,
1242         .release        = video_device_release,
1243         .minor          = -1,
1244 };
1245
1246 #ifdef CONFIG_PM
1247 static int meye_suspend(struct pci_dev *pdev, u32 state)
1248 {
1249         pci_save_state(pdev, meye.pm_state);
1250         meye.pm_mchip_mode = meye.mchip_mode;
1251         mchip_hic_stop();
1252         mchip_set(MCHIP_MM_INTA, 0x0);
1253         return 0;
1254 }
1255
1256 static int meye_resume(struct pci_dev *pdev)
1257 {
1258         pci_restore_state(pdev, meye.pm_state);
1259         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1260
1261         mchip_delay(MCHIP_HIC_CMD, 0);
1262         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1263         wait_ms(1);
1264         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1265         wait_ms(1);
1266         mchip_set(MCHIP_MM_PCI_MODE, 5);
1267         wait_ms(1);
1268         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1269
1270         switch (meye.pm_mchip_mode) {
1271         case MCHIP_HIC_MODE_CONT_OUT:
1272                 mchip_continuous_start();
1273                 break;
1274         case MCHIP_HIC_MODE_CONT_COMP:
1275                 mchip_cont_compression_start();
1276                 break;
1277         }
1278         return 0;
1279 }
1280 #endif
1281
1282 static int __devinit meye_probe(struct pci_dev *pcidev,
1283                                 const struct pci_device_id *ent) {
1284         int ret;
1285         unsigned long mchip_adr;
1286         u8 revision;
1287
1288         if (meye.mchip_dev != NULL) {
1289                 printk(KERN_ERR "meye: only one device allowed!\n");
1290                 ret = -EBUSY;
1291                 goto out1;
1292         }
1293
1294         meye.mchip_dev = pcidev;
1295         meye.video_dev = video_device_alloc();
1296         if (!meye.video_dev) {
1297                 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1298                 ret = -EBUSY;
1299                 goto out1;
1300         }
1301         memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1302         meye.video_dev->dev = &meye.mchip_dev->dev;
1303
1304         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 1);
1305
1306         if ((ret = pci_enable_device(meye.mchip_dev))) {
1307                 printk(KERN_ERR "meye: pci_enable_device failed\n");
1308                 goto out2;
1309         }
1310
1311         meye.mchip_irq = pcidev->irq;
1312         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1313         if (!mchip_adr) {
1314                 printk(KERN_ERR "meye: mchip has no device base address\n");
1315                 ret = -EIO;
1316                 goto out3;
1317         }
1318         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1319                                 pci_resource_len(meye.mchip_dev, 0),
1320                                 "meye")) {
1321                 ret = -EIO;
1322                 printk(KERN_ERR "meye: request_mem_region failed\n");
1323                 goto out3;
1324         }
1325
1326         pci_read_config_byte(meye.mchip_dev, PCI_REVISION_ID, &revision);
1327
1328         pci_set_master(meye.mchip_dev);
1329
1330         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1331         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1332
1333         if ((ret = request_irq(meye.mchip_irq, meye_irq,
1334                                SA_INTERRUPT | SA_SHIRQ, "meye", meye_irq))) {
1335                 printk(KERN_ERR "meye: request_irq failed (ret=%d)\n", ret);
1336                 goto out4;
1337         }
1338
1339         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1340         if (!meye.mchip_mmregs) {
1341                 printk(KERN_ERR "meye: ioremap failed\n");
1342                 ret = -EIO;
1343                 goto out5;
1344         }
1345
1346         /* Ask the camera to perform a soft reset. */
1347         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1348
1349         mchip_delay(MCHIP_HIC_CMD, 0);
1350         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1351
1352         wait_ms(1);
1353         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1354
1355         wait_ms(1);
1356         mchip_set(MCHIP_MM_PCI_MODE, 5);
1357
1358         wait_ms(1);
1359         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1360
1361         if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER, video_nr) < 0) {
1362
1363                 printk(KERN_ERR "meye: video_register_device failed\n");
1364                 ret = -EIO;
1365                 goto out6;
1366         }
1367
1368         printk(KERN_INFO "meye: Motion Eye Camera Driver v%d.%d.\n",
1369                MEYE_DRIVER_MAJORVERSION,
1370                MEYE_DRIVER_MINORVERSION);
1371         printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1372                 revision, mchip_adr, meye.mchip_irq);
1373
1374         /* init all fields */
1375         init_MUTEX(&meye.lock);
1376
1377         meye.picture.depth = 2;
1378         meye.picture.palette = VIDEO_PALETTE_YUV422;
1379         meye.picture.brightness = 32 << 10;
1380         meye.picture.hue = 32 << 10;
1381         meye.picture.colour = 32 << 10;
1382         meye.picture.contrast = 32 << 10;
1383         meye.picture.whiteness = 0;
1384         meye.params.subsample = 0;
1385         meye.params.quality = 7;
1386         meye.params.sharpness = 32;
1387         meye.params.agc = 48;
1388         meye.params.picture = 0;
1389         meye.params.framerate = 0;
1390         sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS, 32);
1391         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE, 32);
1392         sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR, 32);
1393         sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST, 32);
1394         sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS, 32);
1395         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE, 0);
1396         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC, 48);
1397
1398         return 0;
1399 out6:
1400         iounmap(meye.mchip_mmregs);
1401 out5:
1402         free_irq(meye.mchip_irq, meye_irq);
1403 out4:
1404         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1405                            pci_resource_len(meye.mchip_dev, 0));
1406 out3:
1407         pci_disable_device(meye.mchip_dev);
1408 out2:
1409         video_device_release(meye.video_dev);
1410         meye.video_dev = NULL;
1411
1412         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1413 out1:
1414         return ret;
1415 }
1416
1417 static void __devexit meye_remove(struct pci_dev *pcidev) {
1418
1419         video_unregister_device(meye.video_dev);
1420
1421         mchip_hic_stop();
1422
1423         mchip_dma_free();
1424
1425         /* disable interrupts */
1426         mchip_set(MCHIP_MM_INTA, 0x0);
1427
1428         free_irq(meye.mchip_irq, meye_irq);
1429
1430         iounmap(meye.mchip_mmregs);
1431
1432         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1433                            pci_resource_len(meye.mchip_dev, 0));
1434
1435         pci_disable_device(meye.mchip_dev);
1436
1437         if (meye.grab_fbuffer)
1438                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1439
1440         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1441
1442         printk(KERN_INFO "meye: removed\n");
1443 }
1444
1445 static struct pci_device_id meye_pci_tbl[] = {
1446         { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1447           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1448         { }
1449 };
1450
1451 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1452
1453 static struct pci_driver meye_driver = {
1454         .name           = "meye",
1455         .id_table       = meye_pci_tbl,
1456         .probe          = meye_probe,
1457         .remove         = __devexit_p(meye_remove),
1458 #ifdef CONFIG_PM
1459         .suspend        = meye_suspend,
1460         .resume         = meye_resume,
1461 #endif
1462 };
1463
1464 static int __init meye_init_module(void) {
1465         if (gbuffers < 2)
1466                 gbuffers = 2;
1467         if (gbuffers > MEYE_MAX_BUFNBRS)
1468                 gbuffers = MEYE_MAX_BUFNBRS;
1469         if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1470                 gbufsize = MEYE_MAX_BUFSIZE;
1471         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1472                gbuffers, gbufsize/1024, gbuffers*gbufsize/1024);
1473         return pci_module_init(&meye_driver);
1474 }
1475
1476 static void __exit meye_cleanup_module(void) {
1477         pci_unregister_driver(&meye_driver);
1478 }
1479
1480 #ifndef MODULE
1481 static int __init meye_setup(char *str) {
1482         int ints[4];
1483
1484         str = get_options(str, ARRAY_SIZE(ints), ints);
1485         if (ints[0] <= 0)
1486                 goto out;
1487         gbuffers = ints[1];
1488         if (ints[0] == 1)
1489                 goto out;
1490         gbufsize = ints[2];
1491         if (ints[0] == 2)
1492                 goto out;
1493         video_nr = ints[3];
1494 out:
1495         return 1;
1496 }
1497
1498 __setup("meye=", meye_setup);
1499 #endif
1500
1501 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
1502 MODULE_DESCRIPTION("video4linux driver for the MotionEye camera");
1503 MODULE_LICENSE("GPL");
1504
1505 MODULE_PARM(gbuffers,"i");
1506 MODULE_PARM_DESC(gbuffers,"number of capture buffers, default is 2 (32 max)");
1507 MODULE_PARM(gbufsize,"i");
1508 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 614400");
1509 MODULE_PARM(video_nr,"i");
1510 MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
1511
1512 /* Module entry points */
1513 module_init(meye_init_module);
1514 module_exit(meye_cleanup_module);