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