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