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 = NULL;
 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 = NULL;
 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 /* returns the horizontal capture size */
 477 static inline int mchip_hsize(void) {
 478         return meye.params.subsample ? 320 : 640;
 479 }
 480
 481 /* returns the vertical capture size */
 482 static inline int mchip_vsize(void) {
 483         return meye.params.subsample ? 240 : 480;
 484 }
 485
 486 /* waits for a register to be available */
 487 static void mchip_sync(int reg) {
 488         u32 status;
 489         int i;
 490
 491         if (reg == MCHIP_MM_FIFO_DATA) {
 492                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 493                         status = readl(meye.mchip_mmregs + MCHIP_MM_FIFO_STATUS);
 494                         if (!(status & MCHIP_MM_FIFO_WAIT)) {
 495                                 printk(KERN_WARNING "meye: fifo not ready\n");
 496                                 return;
 497                         }
 498                         if (status & MCHIP_MM_FIFO_READY)
 499                                 return;
 500                         udelay(1);
 501                 }
 502         }
 503         else if (reg > 0x80) {
 504                 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
 505                                          : MCHIP_HIC_STATUS_VRJ_RDY;
 506                 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
 507                         status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
 508                         if (status & mask)
 509                                 return;
 510                         udelay(1);
 511                 }
 512         }
 513         else
 514                 return;
 515         printk(KERN_WARNING "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n", reg, status);
 516 }
 517
 518 /* sets a value into the register */
 519 static inline void mchip_set(int reg, u32 v) {
 520         mchip_sync(reg);
 521         writel(v, meye.mchip_mmregs + reg);
 522 }
 523
 524 /* get the register value */
 525 static inline u32 mchip_read(int reg) {
 526         mchip_sync(reg);
 527         return readl(meye.mchip_mmregs + reg);
 528 }
 529
 530 /* wait for a register to become a particular value */
 531 static inline int mchip_delay(u32 reg, u32 v) {
 532         int n = 10;
 533         while (--n && mchip_read(reg) != v)
 534                 udelay(1);
 535         return n;
 536 }
 537
 538 /* setup subsampling */
 539 static void mchip_subsample(void) {
 540         mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
 541         mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
 542         mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
 543         mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
 544         mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
 545         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
 546 }
 547
 548 /* set the framerate into the mchip */
 549 static void mchip_set_framerate(void) {
 550         mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
 551 }
 552
 553 /* load some huffman and quantisation tables into the VRJ chip ready
 554    for JPEG compression */
 555 static void mchip_load_tables(void) {
 556         int i;
 557         int size;
 558         u16 *tables;
 559
 560         tables = jpeg_huffman_tables(&size);
 561         for (i = 0; i < size / 2; i++)
 562                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 563
 564         tables = jpeg_quantisation_tables(&size, meye.params.quality);
 565         for (i = 0; i < size / 2; i++)
 566                 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
 567 }
 568
 569 /* setup the VRJ parameters in the chip */
 570 static void mchip_vrj_setup(u8 mode) {
 571
 572         mchip_set(MCHIP_VRJ_BUS_MODE, 5);
 573         mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
 574         mchip_set(MCHIP_VRJ_PDAT_USE, 1);
 575         mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
 576         mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
 577         mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
 578         mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
 579         mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
 580         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
 581         mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
 582         mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
 583         mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
 584         mchip_set(MCHIP_VRJ_SOF1, 0x601);
 585         mchip_set(MCHIP_VRJ_SOF2, 0x1502);
 586         mchip_set(MCHIP_VRJ_SOF3, 0x1503);
 587         mchip_set(MCHIP_VRJ_SOF4, 0x1596);
 588         mchip_set(MCHIP_VRJ_SOS,  0x0ed0);
 589
 590         mchip_load_tables();
 591 }
 592
 593 /* sets the DMA parameters into the chip */
 594 static void mchip_dma_setup(u32 dma_addr) {
 595         int i;
 596
 597         mchip_set(MCHIP_MM_PT_ADDR, dma_addr);
 598         for (i = 0; i < 4; i++)
 599                 mchip_set(MCHIP_MM_FIR(i), 0);
 600         meye.mchip_fnum = 0;
 601 }
 602
 603 /* setup for DMA transfers - also zeros the framebuffer */
 604 static int mchip_dma_alloc(void) {
 605         if (!meye.mchip_dmahandle)
 606                 if (ptable_alloc())
 607                         return -1;
 608         return 0;
 609 }
 610
 611 /* frees the DMA buffer */
 612 static void mchip_dma_free(void) {
 613         if (meye.mchip_dmahandle) {
 614                 mchip_dma_setup(0);
 615                 ptable_free();
 616         }
 617 }
 618
 619 /* stop any existing HIC action and wait for any dma to complete then
 620    reset the dma engine */
 621 static void mchip_hic_stop(void) {
 622         int i, j;
 623
 624         meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
 625         if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
 626                 return;
 627         for (i = 0; i < 20; ++i) {
 628                 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
 629                 mchip_delay(MCHIP_HIC_CMD, 0);
 630                 for (j = 0; j < 100; ++j) {
 631                         if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 632                                 return;
 633                         msleep(1);
 634                 }
 635                 printk(KERN_ERR "meye: need to reset HIC!\n");
 636
 637                 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
 638                 msleep(250);
 639         }
 640         printk(KERN_ERR "meye: resetting HIC hanged!\n");
 641 }
 642
 643 /****************************************************************************/
 644 /* MCHIP frame processing functions                                         */
 645 /****************************************************************************/
 646
 647 /* get the next ready frame from the dma engine */
 648 static u32 mchip_get_frame(void) {
 649         u32 v;
 650
 651         v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
 652         return v;
 653 }
 654
 655 /* frees the current frame from the dma engine */
 656 static void mchip_free_frame(void) {
 657         mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
 658         meye.mchip_fnum++;
 659         meye.mchip_fnum %= 4;
 660 }
 661
 662 /* read one frame from the framebuffer assuming it was captured using
 663    a uncompressed transfer */
 664 static void mchip_cont_read_frame(u32 v, u8 *buf, int size) {
 665         int pt_id;
 666
 667         pt_id = (v >> 17) & 0x3FF;
 668
 669         ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
 670
 671 }
 672
 673 /* read a compressed frame from the framebuffer */
 674 static int mchip_comp_read_frame(u32 v, u8 *buf, int size) {
 675         int pt_start, pt_end, trailer;
 676         int fsize;
 677         int i;
 678
 679         pt_start = (v >> 19) & 0xFF;
 680         pt_end = (v >> 11) & 0xFF;
 681         trailer = (v >> 1) & 0x3FF;
 682
 683         if (pt_end < pt_start)
 684                 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
 685                         pt_end * PAGE_SIZE + trailer * 4;
 686         else
 687                 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
 688
 689         if (fsize > size) {
 690                 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
 691                        fsize);
 692                 return -1;
 693         }
 694
 695         ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
 696
 697
 698 #ifdef MEYE_JPEG_CORRECTION
 699
 700         /* Some mchip generated jpeg frames are incorrect. In most
 701          * (all ?) of those cases, the final EOI (0xff 0xd9) marker
 702          * is not present at the end of the frame.
 703          *
 704          * Since adding the final marker is not enough to restore
 705          * the jpeg integrity, we drop the frame.
 706          */
 707
 708         for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
 709
 710         if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
 711                 return -1;
 712
 713 #endif
 714
 715         return fsize;
 716 }
 717
 718 /* take a picture into SDRAM */
 719 static void mchip_take_picture(void) {
 720         int i;
 721
 722         mchip_hic_stop();
 723         mchip_subsample();
 724         mchip_dma_setup(meye.mchip_dmahandle);
 725
 726         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
 727         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 728
 729         mchip_delay(MCHIP_HIC_CMD, 0);
 730
 731         for (i = 0; i < 100; ++i) {
 732                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 733                         break;
 734                 msleep(1);
 735         }
 736 }
 737
 738 /* dma a previously taken picture into a buffer */
 739 static void mchip_get_picture(u8 *buf, int bufsize) {
 740         u32 v;
 741         int i;
 742
 743         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
 744         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 745
 746         mchip_delay(MCHIP_HIC_CMD, 0);
 747         for (i = 0; i < 100; ++i) {
 748                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 749                         break;
 750                 msleep(1);
 751         }
 752         for (i = 0; i < 4 ; ++i) {
 753                 v = mchip_get_frame();
 754                 if (v & MCHIP_MM_FIR_RDY) {
 755                         mchip_cont_read_frame(v, buf, bufsize);
 756                         break;
 757                 }
 758                 mchip_free_frame();
 759         }
 760 }
 761
 762 /* start continuous dma capture */
 763 static void mchip_continuous_start(void) {
 764         mchip_hic_stop();
 765         mchip_subsample();
 766         mchip_set_framerate();
 767         mchip_dma_setup(meye.mchip_dmahandle);
 768
 769         meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
 770
 771         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
 772         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 773
 774         mchip_delay(MCHIP_HIC_CMD, 0);
 775 }
 776
 777 /* compress one frame into a buffer */
 778 static int mchip_compress_frame(u8 *buf, int bufsize) {
 779         u32 v;
 780         int len = -1, i;
 781
 782         mchip_vrj_setup(0x3f);
 783         udelay(50);
 784
 785         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
 786         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 787
 788         mchip_delay(MCHIP_HIC_CMD, 0);
 789         for (i = 0; i < 100; ++i) {
 790                 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
 791                         break;
 792                 msleep(1);
 793         }
 794
 795         for (i = 0; i < 4 ; ++i) {
 796                 v = mchip_get_frame();
 797                 if (v & MCHIP_MM_FIR_RDY) {
 798                         len = mchip_comp_read_frame(v, buf, bufsize);
 799                         break;
 800                 }
 801                 mchip_free_frame();
 802         }
 803         return len;
 804 }
 805
 806 #if 0
 807 /* uncompress one image into a buffer */
 808 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize) {
 809         mchip_vrj_setup(0x3f);
 810         udelay(50);
 811
 812         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
 813         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 814
 815         mchip_delay(MCHIP_HIC_CMD, 0);
 816
 817         return mchip_comp_read_frame(buf, bufsize);
 818 }
 819 #endif
 820
 821 /* start continuous compressed capture */
 822 static void mchip_cont_compression_start(void) {
 823         mchip_hic_stop();
 824         mchip_vrj_setup(0x3f);
 825         mchip_subsample();
 826         mchip_set_framerate();
 827         mchip_dma_setup(meye.mchip_dmahandle);
 828
 829         meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
 830
 831         mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
 832         mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
 833
 834         mchip_delay(MCHIP_HIC_CMD, 0);
 835 }
 836
 837 /****************************************************************************/
 838 /* Interrupt handling                                                       */
 839 /****************************************************************************/
 840
 841 static irqreturn_t meye_irq(int irq, void *dev_id, struct pt_regs *regs) {
 842         u32 v;
 843         int reqnr;
 844         v = mchip_read(MCHIP_MM_INTA);
 845
 846         while (1) {
 847                 v = mchip_get_frame();
 848                 if (!(v & MCHIP_MM_FIR_RDY))
 849                         return IRQ_NONE;
 850                 switch (meye.mchip_mode) {
 851
 852                 case MCHIP_HIC_MODE_CONT_OUT:
 853                         if (!meye_emptyq(&meye.grabq, NULL)) {
 854                                 int nr = meye_pullq(&meye.grabq);
 855                                 mchip_cont_read_frame(
 856                                         v,
 857                                         meye.grab_fbuffer + gbufsize * nr,
 858                                         mchip_hsize() * mchip_vsize() * 2);
 859                                 meye.grab_buffer[nr].state = MEYE_BUF_DONE;
 860                                 wake_up_interruptible(&meye.grabq.proc_list);
 861                         }
 862                         break;
 863
 864                 case MCHIP_HIC_MODE_CONT_COMP:
 865                         if (!meye_emptyq(&meye.grabq, &reqnr)) {
 866                                 int size;
 867                                 size = mchip_comp_read_frame(
 868                                         v,
 869                                         meye.grab_fbuffer + gbufsize * reqnr,
 870                                         gbufsize);
 871                                 if (size == -1)
 872                                         break;
 873                                 reqnr = meye_pullq(&meye.grabq);
 874                                 meye.grab_buffer[reqnr].size = size;
 875                                 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
 876                                 wake_up_interruptible(&meye.grabq.proc_list);
 877                         }
 878                         break;
 879
 880                 default:
 881                         /* do not free frame, since it can be a snap */
 882                         return IRQ_NONE;
 883                 } /* switch */
 884
 885                 mchip_free_frame();
 886         }
 887         return IRQ_HANDLED;
 888 }
 889
 890 /****************************************************************************/
 891 /* video4linux integration                                                  */
 892 /****************************************************************************/
 893
 894 static int meye_open(struct inode *inode, struct file *file) {
 895         int i, err;
 896
 897         err = video_exclusive_open(inode,file);
 898         if (err < 0)
 899                 return err;
 900
 901         if (mchip_dma_alloc()) {
 902                 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
 903                 video_exclusive_release(inode,file);
 904                 return -ENOBUFS;
 905         }
 906         mchip_hic_stop();
 907         meye_initq(&meye.grabq);
 908         for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
 909                 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
 910         return 0;
 911 }
 912
 913 static int meye_release(struct inode *inode, struct file *file) {
 914         mchip_hic_stop();
 915         mchip_dma_free();
 916         video_exclusive_release(inode,file);
 917         return 0;
 918 }
 919
 920 static int meye_do_ioctl(struct inode *inode, struct file *file,
 921                          unsigned int cmd, void *arg) {
 922
 923         switch (cmd) {
 924
 925         case VIDIOCGCAP: {
 926                 struct video_capability *b = arg;
 927                 strcpy(b->name,meye.video_dev->name);
 928                 b->type = VID_TYPE_CAPTURE;
 929                 b->channels = 1;
 930                 b->audios = 0;
 931                 b->maxwidth = 640;
 932                 b->maxheight = 480;
 933                 b->minwidth = 320;
 934                 b->minheight = 240;
 935                 break;
 936         }
 937
 938         case VIDIOCGCHAN: {
 939                 struct video_channel *v = arg;
 940                 v->flags = 0;
 941                 v->tuners = 0;
 942                 v->type = VIDEO_TYPE_CAMERA;
 943                 if (v->channel != 0)
 944                         return -EINVAL;
 945                 strcpy(v->name,"Camera");
 946                 break;
 947         }
 948
 949         case VIDIOCSCHAN: {
 950                 struct video_channel *v = arg;
 951                 if (v->channel != 0)
 952                         return -EINVAL;
 953                 break;
 954         }
 955
 956         case VIDIOCGPICT: {
 957                 struct video_picture *p = arg;
 958                 *p = meye.picture;
 959                 break;
 960         }
 961
 962         case VIDIOCSPICT: {
 963                 struct video_picture *p = arg;
 964                 if (p->depth != 2)
 965                         return -EINVAL;
 966                 if (p->palette != VIDEO_PALETTE_YUV422)
 967                         return -EINVAL;
 968                 down(&meye.lock);
 969                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
 970                                       p->brightness >> 10);
 971                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
 972                                       p->hue >> 10);
 973                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR,
 974                                       p->colour >> 10);
 975                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
 976                                       p->contrast >> 10);
 977                 meye.picture = *p;
 978                 up(&meye.lock);
 979                 break;
 980         }
 981
 982         case VIDIOCSYNC: {
 983                 int *i = arg;
 984
 985                 if (*i < 0 || *i >= gbuffers)
 986                         return -EINVAL;
 987
 988                 switch (meye.grab_buffer[*i].state) {
 989
 990                 case MEYE_BUF_UNUSED:
 991                         return -EINVAL;
 992                 case MEYE_BUF_USING:
 993                         if (wait_event_interruptible(meye.grabq.proc_list,
 994                                                      (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
 995                                 return -EINTR;
 996                         /* fall through */
 997                 case MEYE_BUF_DONE:
 998                         meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
 999                 }
1000                 break;
1001         }
1002
1003         case VIDIOCMCAPTURE: {
1004                 struct video_mmap *vm = arg;
1005                 int restart = 0;
1006
1007                 if (vm->frame >= gbuffers || vm->frame < 0)
1008                         return -EINVAL;
1009                 if (vm->format != VIDEO_PALETTE_YUV422)
1010                         return -EINVAL;
1011                 if (vm->height * vm->width * 2 > gbufsize)
1012                         return -EINVAL;
1013                 if (!meye.grab_fbuffer)
1014                         return -EINVAL;
1015                 if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
1016                         return -EBUSY;
1017
1018                 down(&meye.lock);
1019                 if (vm->width == 640 && vm->height == 480) {
1020                         if (meye.params.subsample) {
1021                                 meye.params.subsample = 0;
1022                                 restart = 1;
1023                         }
1024                 }
1025                 else if (vm->width == 320 && vm->height == 240) {
1026                         if (!meye.params.subsample) {
1027                                 meye.params.subsample = 1;
1028                                 restart = 1;
1029                         }
1030                 }
1031                 else {
1032                         up(&meye.lock);
1033                         return -EINVAL;
1034                 }
1035
1036                 if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT)
1037                         mchip_continuous_start();
1038                 meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
1039                 meye_pushq(&meye.grabq, vm->frame);
1040                 up(&meye.lock);
1041                 break;
1042         }
1043
1044         case VIDIOCGMBUF: {
1045                 struct video_mbuf *vm = arg;
1046                 int i;
1047
1048                 memset(vm, 0 , sizeof(*vm));
1049                 vm->size = gbufsize * gbuffers;
1050                 vm->frames = gbuffers;
1051                 for (i = 0; i < gbuffers; i++)
1052                         vm->offsets[i] = i * gbufsize;
1053                 break;
1054         }
1055
1056         case MEYEIOC_G_PARAMS: {
1057                 struct meye_params *p = arg;
1058                 *p = meye.params;
1059                 break;
1060         }
1061
1062         case MEYEIOC_S_PARAMS: {
1063                 struct meye_params *jp = arg;
1064                 if (jp->subsample > 1)
1065                         return -EINVAL;
1066                 if (jp->quality > 10)
1067                         return -EINVAL;
1068                 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
1069                         return -EINVAL;
1070                 if (jp->framerate > 31)
1071                         return -EINVAL;
1072                 down(&meye.lock);
1073                 if (meye.params.subsample != jp->subsample ||
1074                     meye.params.quality != jp->quality)
1075                         mchip_hic_stop();       /* need restart */
1076                 meye.params = *jp;
1077                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS,
1078                                       meye.params.sharpness);
1079                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC,
1080                                       meye.params.agc);
1081                 sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE,
1082                                       meye.params.picture);
1083                 up(&meye.lock);
1084                 break;
1085         }
1086
1087         case MEYEIOC_QBUF_CAPT: {
1088                 int *nb = arg;
1089
1090                 if (!meye.grab_fbuffer)
1091                         return -EINVAL;
1092                 if (*nb >= gbuffers)
1093                         return -EINVAL;
1094                 if (*nb < 0) {
1095                         /* stop capture */
1096                         mchip_hic_stop();
1097                         return 0;
1098                 }
1099                 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
1100                         return -EBUSY;
1101                 down(&meye.lock);
1102                 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
1103                         mchip_cont_compression_start();
1104                 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
1105                 meye_pushq(&meye.grabq, *nb);
1106                 up(&meye.lock);
1107                 break;
1108         }
1109
1110         case MEYEIOC_SYNC: {
1111                 int *i = arg;
1112
1113                 if (*i < 0 || *i >= gbuffers)
1114                         return -EINVAL;
1115
1116                 switch (meye.grab_buffer[*i].state) {
1117
1118                 case MEYE_BUF_UNUSED:
1119                         return -EINVAL;
1120                 case MEYE_BUF_USING:
1121                         if (wait_event_interruptible(meye.grabq.proc_list,
1122                                                      (meye.grab_buffer[*i].state != MEYE_BUF_USING)))
1123                                 return -EINTR;
1124                         /* fall through */
1125                 case MEYE_BUF_DONE:
1126                         meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1127                 }
1128                 *i = meye.grab_buffer[*i].size;
1129                 break;
1130         }
1131
1132         case MEYEIOC_STILLCAPT: {
1133
1134                 if (!meye.grab_fbuffer)
1135                         return -EINVAL;
1136                 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1137                         return -EBUSY;
1138                 down(&meye.lock);
1139                 meye.grab_buffer[0].state = MEYE_BUF_USING;
1140                 mchip_take_picture();
1141                 mchip_get_picture(
1142                         meye.grab_fbuffer,
1143                         mchip_hsize() * mchip_vsize() * 2);
1144                 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1145                 up(&meye.lock);
1146                 break;
1147         }
1148
1149         case MEYEIOC_STILLJCAPT: {
1150                 int *len = arg;
1151
1152                 if (!meye.grab_fbuffer)
1153                         return -EINVAL;
1154                 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1155                         return -EBUSY;
1156                 down(&meye.lock);
1157                 meye.grab_buffer[0].state = MEYE_BUF_USING;
1158                 *len = -1;
1159                 while (*len == -1) {
1160                         mchip_take_picture();
1161                         *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1162                 }
1163                 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1164                 up(&meye.lock);
1165                 break;
1166         }
1167
1168         default:
1169                 return -ENOIOCTLCMD;
1170
1171         } /* switch */
1172
1173         return 0;
1174 }
1175
1176 static int meye_ioctl(struct inode *inode, struct file *file,
1177                      unsigned int cmd, unsigned long arg)
1178 {
1179         return video_usercopy(inode, file, cmd, arg, meye_do_ioctl);
1180 }
1181
1182 static int meye_mmap(struct file *file, struct vm_area_struct *vma) {
1183         unsigned long start = vma->vm_start;
1184         unsigned long size  = vma->vm_end - vma->vm_start;
1185         unsigned long page, pos;
1186
1187         down(&meye.lock);
1188         if (size > gbuffers * gbufsize) {
1189                 up(&meye.lock);
1190                 return -EINVAL;
1191         }
1192         if (!meye.grab_fbuffer) {
1193                 /* lazy allocation */
1194                 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1195                 if (!meye.grab_fbuffer) {
1196                         printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1197                         up(&meye.lock);
1198                         return -ENOMEM;
1199                 }
1200         }
1201         pos = (unsigned long)meye.grab_fbuffer;
1202
1203         while (size > 0) {
1204                 page = kvirt_to_pa(pos);
1205                 if (remap_page_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1206                         up(&meye.lock);
1207                         return -EAGAIN;
1208                 }
1209                 start += PAGE_SIZE;
1210                 pos += PAGE_SIZE;
1211                 size -= PAGE_SIZE;
1212         }
1213         up(&meye.lock);
1214         return 0;
1215 }
1216
1217 static struct file_operations meye_fops = {
1218         .owner          = THIS_MODULE,
1219         .open           = meye_open,
1220         .release        = meye_release,
1221         .mmap           = meye_mmap,
1222         .ioctl          = meye_ioctl,
1223         .llseek         = no_llseek,
1224 };
1225
1226 static struct video_device meye_template = {
1227         .owner          = THIS_MODULE,
1228         .name           = "meye",
1229         .type           = VID_TYPE_CAPTURE,
1230         .hardware       = VID_HARDWARE_MEYE,
1231         .fops           = &meye_fops,
1232         .release        = video_device_release,
1233         .minor          = -1,
1234 };
1235
1236 #ifdef CONFIG_PM
1237 static int meye_suspend(struct pci_dev *pdev, u32 state)
1238 {
1239         pci_save_state(pdev, meye.pm_state);
1240         meye.pm_mchip_mode = meye.mchip_mode;
1241         mchip_hic_stop();
1242         mchip_set(MCHIP_MM_INTA, 0x0);
1243         return 0;
1244 }
1245
1246 static int meye_resume(struct pci_dev *pdev)
1247 {
1248         pci_restore_state(pdev, meye.pm_state);
1249         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1250
1251         mchip_delay(MCHIP_HIC_CMD, 0);
1252         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1253         msleep(1);
1254         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1255         msleep(1);
1256         mchip_set(MCHIP_MM_PCI_MODE, 5);
1257         msleep(1);
1258         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1259
1260         switch (meye.pm_mchip_mode) {
1261         case MCHIP_HIC_MODE_CONT_OUT:
1262                 mchip_continuous_start();
1263                 break;
1264         case MCHIP_HIC_MODE_CONT_COMP:
1265                 mchip_cont_compression_start();
1266                 break;
1267         }
1268         return 0;
1269 }
1270 #endif
1271
1272 static int __devinit meye_probe(struct pci_dev *pcidev,
1273                                 const struct pci_device_id *ent) {
1274         int ret;
1275         unsigned long mchip_adr;
1276         u8 revision;
1277
1278         if (meye.mchip_dev != NULL) {
1279                 printk(KERN_ERR "meye: only one device allowed!\n");
1280                 ret = -EBUSY;
1281                 goto out1;
1282         }
1283
1284         meye.mchip_dev = pcidev;
1285         meye.video_dev = video_device_alloc();
1286         if (!meye.video_dev) {
1287                 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1288                 ret = -EBUSY;
1289                 goto out1;
1290         }
1291         memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1292         meye.video_dev->dev = &meye.mchip_dev->dev;
1293
1294         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 1);
1295
1296         if ((ret = pci_enable_device(meye.mchip_dev))) {
1297                 printk(KERN_ERR "meye: pci_enable_device failed\n");
1298                 goto out2;
1299         }
1300
1301         meye.mchip_irq = pcidev->irq;
1302         mchip_adr = pci_resource_start(meye.mchip_dev,0);
1303         if (!mchip_adr) {
1304                 printk(KERN_ERR "meye: mchip has no device base address\n");
1305                 ret = -EIO;
1306                 goto out3;
1307         }
1308         if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1309                                 pci_resource_len(meye.mchip_dev, 0),
1310                                 "meye")) {
1311                 ret = -EIO;
1312                 printk(KERN_ERR "meye: request_mem_region failed\n");
1313                 goto out3;
1314         }
1315
1316         pci_read_config_byte(meye.mchip_dev, PCI_REVISION_ID, &revision);
1317
1318         pci_set_master(meye.mchip_dev);
1319
1320         pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1321         pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1322
1323         if ((ret = request_irq(meye.mchip_irq, meye_irq,
1324                                SA_INTERRUPT | SA_SHIRQ, "meye", meye_irq))) {
1325                 printk(KERN_ERR "meye: request_irq failed (ret=%d)\n", ret);
1326                 goto out4;
1327         }
1328
1329         meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1330         if (!meye.mchip_mmregs) {
1331                 printk(KERN_ERR "meye: ioremap failed\n");
1332                 ret = -EIO;
1333                 goto out5;
1334         }
1335
1336         /* Ask the camera to perform a soft reset. */
1337         pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1338
1339         mchip_delay(MCHIP_HIC_CMD, 0);
1340         mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1341
1342         msleep(1);
1343         mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1344
1345         msleep(1);
1346         mchip_set(MCHIP_MM_PCI_MODE, 5);
1347
1348         msleep(1);
1349         mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1350
1351         if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER, video_nr) < 0) {
1352
1353                 printk(KERN_ERR "meye: video_register_device failed\n");
1354                 ret = -EIO;
1355                 goto out6;
1356         }
1357
1358         printk(KERN_INFO "meye: Motion Eye Camera Driver v%d.%d.\n",
1359                MEYE_DRIVER_MAJORVERSION,
1360                MEYE_DRIVER_MINORVERSION);
1361         printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1362                 revision, mchip_adr, meye.mchip_irq);
1363
1364         /* init all fields */
1365         init_MUTEX(&meye.lock);
1366
1367         meye.picture.depth = 2;
1368         meye.picture.palette = VIDEO_PALETTE_YUV422;
1369         meye.picture.brightness = 32 << 10;
1370         meye.picture.hue = 32 << 10;
1371         meye.picture.colour = 32 << 10;
1372         meye.picture.contrast = 32 << 10;
1373         meye.picture.whiteness = 0;
1374         meye.params.subsample = 0;
1375         meye.params.quality = 7;
1376         meye.params.sharpness = 32;
1377         meye.params.agc = 48;
1378         meye.params.picture = 0;
1379         meye.params.framerate = 0;
1380         sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS, 32);
1381         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE, 32);
1382         sonypi_camera_command(SONYPI_COMMAND_SETCAMERACOLOR, 32);
1383         sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST, 32);
1384         sonypi_camera_command(SONYPI_COMMAND_SETCAMERASHARPNESS, 32);
1385         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE, 0);
1386         sonypi_camera_command(SONYPI_COMMAND_SETCAMERAAGC, 48);
1387
1388         return 0;
1389 out6:
1390         iounmap(meye.mchip_mmregs);
1391 out5:
1392         free_irq(meye.mchip_irq, meye_irq);
1393 out4:
1394         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1395                            pci_resource_len(meye.mchip_dev, 0));
1396 out3:
1397         pci_disable_device(meye.mchip_dev);
1398 out2:
1399         video_device_release(meye.video_dev);
1400         meye.video_dev = NULL;
1401
1402         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1403 out1:
1404         return ret;
1405 }
1406
1407 static void __devexit meye_remove(struct pci_dev *pcidev) {
1408
1409         video_unregister_device(meye.video_dev);
1410
1411         mchip_hic_stop();
1412
1413         mchip_dma_free();
1414
1415         /* disable interrupts */
1416         mchip_set(MCHIP_MM_INTA, 0x0);
1417
1418         free_irq(meye.mchip_irq, meye_irq);
1419
1420         iounmap(meye.mchip_mmregs);
1421
1422         release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1423                            pci_resource_len(meye.mchip_dev, 0));
1424
1425         pci_disable_device(meye.mchip_dev);
1426
1427         if (meye.grab_fbuffer)
1428                 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1429
1430         sonypi_camera_command(SONYPI_COMMAND_SETCAMERA, 0);
1431
1432         printk(KERN_INFO "meye: removed\n");
1433 }
1434
1435 static struct pci_device_id meye_pci_tbl[] = {
1436         { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1437           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1438         { }
1439 };
1440
1441 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1442
1443 static struct pci_driver meye_driver = {
1444         .name           = "meye",
1445         .id_table       = meye_pci_tbl,
1446         .probe          = meye_probe,
1447         .remove         = __devexit_p(meye_remove),
1448 #ifdef CONFIG_PM
1449         .suspend        = meye_suspend,
1450         .resume         = meye_resume,
1451 #endif
1452 };
1453
1454 static int __init meye_init_module(void) {
1455         if (gbuffers < 2)
1456                 gbuffers = 2;
1457         if (gbuffers > MEYE_MAX_BUFNBRS)
1458                 gbuffers = MEYE_MAX_BUFNBRS;
1459         if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1460                 gbufsize = MEYE_MAX_BUFSIZE;
1461         printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1462                gbuffers, gbufsize/1024, gbuffers*gbufsize/1024);
1463         return pci_module_init(&meye_driver);
1464 }
1465
1466 static void __exit meye_cleanup_module(void) {
1467         pci_unregister_driver(&meye_driver);
1468 }
1469
1470 #ifndef MODULE
1471 static int __init meye_setup(char *str) {
1472         int ints[4];
1473
1474         str = get_options(str, ARRAY_SIZE(ints), ints);
1475         if (ints[0] <= 0)
1476                 goto out;
1477         gbuffers = ints[1];
1478         if (ints[0] == 1)
1479                 goto out;
1480         gbufsize = ints[2];
1481         if (ints[0] == 2)
1482                 goto out;
1483         video_nr = ints[3];
1484 out:
1485         return 1;
1486 }
1487
1488 __setup("meye=", meye_setup);
1489 #endif
1490
1491 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
1492 MODULE_DESCRIPTION("video4linux driver for the MotionEye camera");
1493 MODULE_LICENSE("GPL");
1494
1495 MODULE_PARM(gbuffers,"i");
1496 MODULE_PARM_DESC(gbuffers,"number of capture buffers, default is 2 (32 max)");
1497 MODULE_PARM(gbufsize,"i");
1498 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 614400");
1499 MODULE_PARM(video_nr,"i");
1500 MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
1501
1502 /* Module entry points */
1503 module_init(meye_init_module);
1504 module_exit(meye_cleanup_module);