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