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 <linux/uaccess.h>
42 #include <linux/delay.h>
43 #include <linux/interrupt.h>
44 #include <linux/vmalloc.h>
45 #include <linux/dma-mapping.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 (will be rounded up to a page multiple)");
65 /* /dev/videoX registration number */
66 static int video_nr = -1;
67 module_param(video_nr, int, 0444);
68 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
70 /* driver structure - only one possible */
71 static struct meye meye;
73 /****************************************************************************/
74 /* Memory allocation routines (stolen from bttv-driver.c) */
75 /****************************************************************************/
76 static void *rvmalloc(unsigned long size)
81 size = PAGE_ALIGN(size);
82 mem = vmalloc_32(size);
85 adr = (unsigned long) mem;
87 SetPageReserved(vmalloc_to_page((void *)adr));
95 static void rvfree(void * mem, unsigned long size)
100 adr = (unsigned long) mem;
101 while ((long) size > 0) {
102 ClearPageReserved(vmalloc_to_page((void *)adr));
111 * return a page table pointing to N pages of locked memory
113 * NOTE: The meye device expects DMA addresses on 32 bits, we build
114 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
116 static int ptable_alloc(void)
121 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
123 /* give only 32 bit DMA addresses */
124 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
127 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
129 &meye.mchip_dmahandle,
131 if (!meye.mchip_ptable_toc) {
132 meye.mchip_dmahandle = 0;
136 pt = meye.mchip_ptable_toc;
137 for (i = 0; i < MCHIP_NB_PAGES; i++) {
139 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
143 if (!meye.mchip_ptable[i]) {
145 pt = meye.mchip_ptable_toc;
146 for (j = 0; j < i; ++j) {
147 dma = (dma_addr_t) *pt;
148 dma_free_coherent(&meye.mchip_dev->dev,
150 meye.mchip_ptable[j], dma);
153 dma_free_coherent(&meye.mchip_dev->dev,
155 meye.mchip_ptable_toc,
156 meye.mchip_dmahandle);
157 meye.mchip_ptable_toc = NULL;
158 meye.mchip_dmahandle = 0;
167 static void ptable_free(void)
172 pt = meye.mchip_ptable_toc;
173 for (i = 0; i < MCHIP_NB_PAGES; i++) {
174 dma_addr_t dma = (dma_addr_t) *pt;
175 if (meye.mchip_ptable[i])
176 dma_free_coherent(&meye.mchip_dev->dev,
178 meye.mchip_ptable[i], dma);
182 if (meye.mchip_ptable_toc)
183 dma_free_coherent(&meye.mchip_dev->dev,
185 meye.mchip_ptable_toc,
186 meye.mchip_dmahandle);
188 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
189 meye.mchip_ptable_toc = NULL;
190 meye.mchip_dmahandle = 0;
193 /* copy data from ptable into buf */
194 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
198 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
199 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
200 if (start >= pt_pages)
203 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
206 /****************************************************************************/
207 /* JPEG tables at different qualities to load into the VRJ chip */
208 /****************************************************************************/
210 /* return a set of quantisation tables based on a quality from 1 to 10 */
211 static u16 *jpeg_quantisation_tables(int *length, int quality)
213 static u16 jpeg_tables[][70] = { {
214 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
215 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
218 0xffff, 0xffff, 0xffff,
219 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
223 0xffff, 0xffff, 0xffff,
226 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
227 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
228 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
229 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
230 0xffff, 0xffff, 0xffff,
231 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
232 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
233 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
234 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
235 0xffff, 0xffff, 0xffff,
238 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
239 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
240 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
241 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
242 0xe6ff, 0xfffd, 0xfff8,
243 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
244 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
245 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
246 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
247 0xf8f8, 0xf8f8, 0xfff8,
250 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
251 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
252 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
253 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
254 0x99c7, 0xaba8, 0xffa4,
255 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
256 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
257 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
258 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
259 0xa4a4, 0xa4a4, 0xffa4,
262 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
263 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
264 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
265 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
266 0x7396, 0x817e, 0xff7c,
267 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
268 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
269 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
270 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
271 0x7c7c, 0x7c7c, 0xff7c,
274 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
275 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
276 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
277 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
278 0x5c78, 0x6765, 0xff63,
279 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
280 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
281 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
282 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
283 0x6363, 0x6363, 0xff63,
286 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
287 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
288 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
289 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
290 0x4a60, 0x5251, 0xff4f,
291 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
292 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
293 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
294 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
295 0x4f4f, 0x4f4f, 0xff4f,
298 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
299 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
300 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
301 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
302 0x3748, 0x3e3d, 0xff3b,
303 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
304 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
305 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
306 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
307 0x3b3b, 0x3b3b, 0xff3b,
310 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
311 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
312 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
313 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
314 0x2530, 0x2928, 0xff28,
315 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
316 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
317 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
318 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
319 0x2828, 0x2828, 0xff28,
322 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
323 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
324 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
325 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
326 0x1218, 0x1514, 0xff14,
327 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
328 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
329 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
330 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
331 0x1414, 0x1414, 0xff14,
334 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
335 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
336 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
337 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
338 0x0101, 0x0101, 0xff01,
339 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
340 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
341 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
342 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
343 0x0101, 0x0101, 0xff01,
346 if (quality < 0 || quality > 10) {
348 "meye: invalid quality level %d - using 8\n", quality);
352 *length = ARRAY_SIZE(jpeg_tables[quality]);
353 return jpeg_tables[quality];
356 /* return a generic set of huffman tables */
357 static u16 *jpeg_huffman_tables(int *length)
359 static u16 tables[] = {
360 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
361 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
362 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
363 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
364 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
365 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
366 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
367 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
368 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
369 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
370 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
371 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
372 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
373 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
374 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
375 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
376 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
377 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
378 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
379 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
380 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
381 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
382 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
383 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
384 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
385 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
387 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
388 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
392 *length = ARRAY_SIZE(tables);
396 /****************************************************************************/
397 /* MCHIP low-level functions */
398 /****************************************************************************/
400 /* returns the horizontal capture size */
401 static inline int mchip_hsize(void)
403 return meye.params.subsample ? 320 : 640;
406 /* returns the vertical capture size */
407 static inline int mchip_vsize(void)
409 return meye.params.subsample ? 240 : 480;
412 /* waits for a register to be available */
413 static void mchip_sync(int reg)
418 if (reg == MCHIP_MM_FIFO_DATA) {
419 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
420 status = readl(meye.mchip_mmregs +
421 MCHIP_MM_FIFO_STATUS);
422 if (!(status & MCHIP_MM_FIFO_WAIT)) {
423 printk(KERN_WARNING "meye: fifo not ready\n");
426 if (status & MCHIP_MM_FIFO_READY)
430 } else if (reg > 0x80) {
431 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
432 : MCHIP_HIC_STATUS_VRJ_RDY;
433 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
434 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
442 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
446 /* sets a value into the register */
447 static inline void mchip_set(int reg, u32 v)
450 writel(v, meye.mchip_mmregs + reg);
453 /* get the register value */
454 static inline u32 mchip_read(int reg)
457 return readl(meye.mchip_mmregs + reg);
460 /* wait for a register to become a particular value */
461 static inline int mchip_delay(u32 reg, u32 v)
464 while (--n && mchip_read(reg) != v)
469 /* setup subsampling */
470 static void mchip_subsample(void)
472 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
473 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
474 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
475 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
476 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
477 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
480 /* set the framerate into the mchip */
481 static void mchip_set_framerate(void)
483 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
486 /* load some huffman and quantisation tables into the VRJ chip ready
487 for JPEG compression */
488 static void mchip_load_tables(void)
494 tables = jpeg_huffman_tables(&length);
495 for (i = 0; i < length; i++)
496 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
498 tables = jpeg_quantisation_tables(&length, meye.params.quality);
499 for (i = 0; i < length; i++)
500 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
503 /* setup the VRJ parameters in the chip */
504 static void mchip_vrj_setup(u8 mode)
506 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
507 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
508 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
509 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
510 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
511 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
512 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
513 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
514 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
515 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
516 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
517 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
518 mchip_set(MCHIP_VRJ_SOF1, 0x601);
519 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
520 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
521 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
522 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
527 /* sets the DMA parameters into the chip */
528 static void mchip_dma_setup(dma_addr_t dma_addr)
532 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
533 for (i = 0; i < 4; i++)
534 mchip_set(MCHIP_MM_FIR(i), 0);
538 /* setup for DMA transfers - also zeros the framebuffer */
539 static int mchip_dma_alloc(void)
541 if (!meye.mchip_dmahandle)
547 /* frees the DMA buffer */
548 static void mchip_dma_free(void)
550 if (meye.mchip_dmahandle) {
556 /* stop any existing HIC action and wait for any dma to complete then
557 reset the dma engine */
558 static void mchip_hic_stop(void)
562 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
563 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
565 for (i = 0; i < 20; ++i) {
566 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
567 mchip_delay(MCHIP_HIC_CMD, 0);
568 for (j = 0; j < 100; ++j) {
569 if (mchip_delay(MCHIP_HIC_STATUS,
570 MCHIP_HIC_STATUS_IDLE))
574 printk(KERN_ERR "meye: need to reset HIC!\n");
576 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
579 printk(KERN_ERR "meye: resetting HIC hanged!\n");
582 /****************************************************************************/
583 /* MCHIP frame processing functions */
584 /****************************************************************************/
586 /* get the next ready frame from the dma engine */
587 static u32 mchip_get_frame(void)
589 return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
592 /* frees the current frame from the dma engine */
593 static void mchip_free_frame(void)
595 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
597 meye.mchip_fnum %= 4;
600 /* read one frame from the framebuffer assuming it was captured using
601 a uncompressed transfer */
602 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
606 pt_id = (v >> 17) & 0x3FF;
608 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
611 /* read a compressed frame from the framebuffer */
612 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
614 int pt_start, pt_end, trailer;
618 pt_start = (v >> 19) & 0xFF;
619 pt_end = (v >> 11) & 0xFF;
620 trailer = (v >> 1) & 0x3FF;
622 if (pt_end < pt_start)
623 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
624 pt_end * PAGE_SIZE + trailer * 4;
626 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
629 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
634 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
636 #ifdef MEYE_JPEG_CORRECTION
638 /* Some mchip generated jpeg frames are incorrect. In most
639 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
640 * is not present at the end of the frame.
642 * Since adding the final marker is not enough to restore
643 * the jpeg integrity, we drop the frame.
646 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
648 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
656 /* take a picture into SDRAM */
657 static void mchip_take_picture(void)
663 mchip_dma_setup(meye.mchip_dmahandle);
665 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
666 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
668 mchip_delay(MCHIP_HIC_CMD, 0);
670 for (i = 0; i < 100; ++i) {
671 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
677 /* dma a previously taken picture into a buffer */
678 static void mchip_get_picture(u8 *buf, int bufsize)
683 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
684 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
686 mchip_delay(MCHIP_HIC_CMD, 0);
687 for (i = 0; i < 100; ++i) {
688 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
692 for (i = 0; i < 4; ++i) {
693 v = mchip_get_frame();
694 if (v & MCHIP_MM_FIR_RDY) {
695 mchip_cont_read_frame(v, buf, bufsize);
702 /* start continuous dma capture */
703 static void mchip_continuous_start(void)
707 mchip_set_framerate();
708 mchip_dma_setup(meye.mchip_dmahandle);
710 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
712 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
713 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
715 mchip_delay(MCHIP_HIC_CMD, 0);
718 /* compress one frame into a buffer */
719 static int mchip_compress_frame(u8 *buf, int bufsize)
724 mchip_vrj_setup(0x3f);
727 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
728 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
730 mchip_delay(MCHIP_HIC_CMD, 0);
731 for (i = 0; i < 100; ++i) {
732 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
737 for (i = 0; i < 4; ++i) {
738 v = mchip_get_frame();
739 if (v & MCHIP_MM_FIR_RDY) {
740 len = mchip_comp_read_frame(v, buf, bufsize);
749 /* uncompress one image into a buffer */
750 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
752 mchip_vrj_setup(0x3f);
755 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
756 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
758 mchip_delay(MCHIP_HIC_CMD, 0);
760 return mchip_comp_read_frame(buf, bufsize);
764 /* start continuous compressed capture */
765 static void mchip_cont_compression_start(void)
768 mchip_vrj_setup(0x3f);
770 mchip_set_framerate();
771 mchip_dma_setup(meye.mchip_dmahandle);
773 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
775 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
776 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
778 mchip_delay(MCHIP_HIC_CMD, 0);
781 /****************************************************************************/
782 /* Interrupt handling */
783 /****************************************************************************/
785 static irqreturn_t meye_irq(int irq, void *dev_id)
791 v = mchip_read(MCHIP_MM_INTA);
793 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
794 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
798 v = mchip_get_frame();
799 if (!(v & MCHIP_MM_FIR_RDY))
802 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
803 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
804 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
808 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
809 mchip_hsize() * mchip_vsize() * 2);
810 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
811 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
812 v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
813 meye.grab_buffer[reqnr].sequence = sequence++;
814 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
815 sizeof(int), &meye.doneq_lock);
816 wake_up_interruptible(&meye.proc_list);
819 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
824 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
825 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
829 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
831 meye.grab_buffer[reqnr].size = size;
832 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
833 v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
834 meye.grab_buffer[reqnr].sequence = sequence++;
835 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
836 sizeof(int), &meye.doneq_lock);
837 wake_up_interruptible(&meye.proc_list);
843 /****************************************************************************/
844 /* video4linux integration */
845 /****************************************************************************/
847 static int meye_open(struct file *file)
851 if (test_and_set_bit(0, &meye.in_use))
856 if (mchip_dma_alloc()) {
857 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
858 clear_bit(0, &meye.in_use);
862 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
863 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
864 kfifo_reset(&meye.grabq);
865 kfifo_reset(&meye.doneq);
866 return v4l2_fh_open(file);
869 static int meye_release(struct file *file)
873 clear_bit(0, &meye.in_use);
874 return v4l2_fh_release(file);
877 static int meyeioc_g_params(struct meye_params *p)
883 static int meyeioc_s_params(struct meye_params *jp)
885 if (jp->subsample > 1)
888 if (jp->quality > 10)
891 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
894 if (jp->framerate > 31)
897 mutex_lock(&meye.lock);
899 if (meye.params.subsample != jp->subsample ||
900 meye.params.quality != jp->quality)
901 mchip_hic_stop(); /* need restart */
904 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
905 meye.params.sharpness);
906 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
908 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
909 meye.params.picture);
910 mutex_unlock(&meye.lock);
915 static int meyeioc_qbuf_capt(int *nb)
917 if (!meye.grab_fbuffer)
929 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
932 mutex_lock(&meye.lock);
934 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
935 mchip_cont_compression_start();
937 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
938 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
940 mutex_unlock(&meye.lock);
945 static int meyeioc_sync(struct file *file, void *fh, int *i)
949 if (*i < 0 || *i >= gbuffers)
952 mutex_lock(&meye.lock);
953 switch (meye.grab_buffer[*i].state) {
955 case MEYE_BUF_UNUSED:
956 mutex_unlock(&meye.lock);
959 if (file->f_flags & O_NONBLOCK) {
960 mutex_unlock(&meye.lock);
963 if (wait_event_interruptible(meye.proc_list,
964 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
965 mutex_unlock(&meye.lock);
970 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
971 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
972 sizeof(int), &meye.doneq_lock) != sizeof(int))
975 *i = meye.grab_buffer[*i].size;
976 mutex_unlock(&meye.lock);
980 static int meyeioc_stillcapt(void)
982 if (!meye.grab_fbuffer)
985 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
988 mutex_lock(&meye.lock);
989 meye.grab_buffer[0].state = MEYE_BUF_USING;
990 mchip_take_picture();
992 mchip_get_picture(meye.grab_fbuffer,
993 mchip_hsize() * mchip_vsize() * 2);
995 meye.grab_buffer[0].state = MEYE_BUF_DONE;
996 mutex_unlock(&meye.lock);
1001 static int meyeioc_stilljcapt(int *len)
1003 if (!meye.grab_fbuffer)
1006 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1009 mutex_lock(&meye.lock);
1010 meye.grab_buffer[0].state = MEYE_BUF_USING;
1013 while (*len == -1) {
1014 mchip_take_picture();
1015 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1018 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1019 mutex_unlock(&meye.lock);
1023 static int vidioc_querycap(struct file *file, void *fh,
1024 struct v4l2_capability *cap)
1026 strcpy(cap->driver, "meye");
1027 strcpy(cap->card, "meye");
1028 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1030 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
1032 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1037 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1042 strcpy(i->name, "Camera");
1043 i->type = V4L2_INPUT_TYPE_CAMERA;
1048 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1054 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1062 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1064 mutex_lock(&meye.lock);
1066 case V4L2_CID_BRIGHTNESS:
1067 sony_pic_camera_command(
1068 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1069 meye.brightness = ctrl->val << 10;
1072 sony_pic_camera_command(
1073 SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1074 meye.hue = ctrl->val << 10;
1076 case V4L2_CID_CONTRAST:
1077 sony_pic_camera_command(
1078 SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1079 meye.contrast = ctrl->val << 10;
1081 case V4L2_CID_SATURATION:
1082 sony_pic_camera_command(
1083 SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1084 meye.colour = ctrl->val << 10;
1086 case V4L2_CID_MEYE_AGC:
1087 sony_pic_camera_command(
1088 SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1089 meye.params.agc = ctrl->val;
1091 case V4L2_CID_SHARPNESS:
1092 sony_pic_camera_command(
1093 SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1094 meye.params.sharpness = ctrl->val;
1096 case V4L2_CID_MEYE_PICTURE:
1097 sony_pic_camera_command(
1098 SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1099 meye.params.picture = ctrl->val;
1101 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1102 meye.params.quality = ctrl->val;
1104 case V4L2_CID_MEYE_FRAMERATE:
1105 meye.params.framerate = ctrl->val;
1108 mutex_unlock(&meye.lock);
1111 mutex_unlock(&meye.lock);
1116 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1117 struct v4l2_fmtdesc *f)
1122 if (f->index == 0) {
1123 /* standard YUV 422 capture */
1125 strcpy(f->description, "YUV422");
1126 f->pixelformat = V4L2_PIX_FMT_YUYV;
1128 /* compressed MJPEG capture */
1129 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1130 strcpy(f->description, "MJPEG");
1131 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1137 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1138 struct v4l2_format *f)
1140 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1141 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1144 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1145 f->fmt.pix.field != V4L2_FIELD_NONE)
1148 f->fmt.pix.field = V4L2_FIELD_NONE;
1150 if (f->fmt.pix.width <= 320) {
1151 f->fmt.pix.width = 320;
1152 f->fmt.pix.height = 240;
1154 f->fmt.pix.width = 640;
1155 f->fmt.pix.height = 480;
1158 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1159 f->fmt.pix.sizeimage = f->fmt.pix.height *
1160 f->fmt.pix.bytesperline;
1161 f->fmt.pix.colorspace = 0;
1166 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1167 struct v4l2_format *f)
1169 switch (meye.mchip_mode) {
1170 case MCHIP_HIC_MODE_CONT_OUT:
1172 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1174 case MCHIP_HIC_MODE_CONT_COMP:
1175 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1179 f->fmt.pix.field = V4L2_FIELD_NONE;
1180 f->fmt.pix.width = mchip_hsize();
1181 f->fmt.pix.height = mchip_vsize();
1182 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1183 f->fmt.pix.sizeimage = f->fmt.pix.height *
1184 f->fmt.pix.bytesperline;
1189 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1190 struct v4l2_format *f)
1192 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1193 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1196 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1197 f->fmt.pix.field != V4L2_FIELD_NONE)
1200 f->fmt.pix.field = V4L2_FIELD_NONE;
1201 mutex_lock(&meye.lock);
1203 if (f->fmt.pix.width <= 320) {
1204 f->fmt.pix.width = 320;
1205 f->fmt.pix.height = 240;
1206 meye.params.subsample = 1;
1208 f->fmt.pix.width = 640;
1209 f->fmt.pix.height = 480;
1210 meye.params.subsample = 0;
1213 switch (f->fmt.pix.pixelformat) {
1214 case V4L2_PIX_FMT_YUYV:
1215 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1217 case V4L2_PIX_FMT_MJPEG:
1218 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1222 mutex_unlock(&meye.lock);
1223 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1224 f->fmt.pix.sizeimage = f->fmt.pix.height *
1225 f->fmt.pix.bytesperline;
1226 f->fmt.pix.colorspace = 0;
1231 static int vidioc_reqbufs(struct file *file, void *fh,
1232 struct v4l2_requestbuffers *req)
1236 if (req->memory != V4L2_MEMORY_MMAP)
1239 if (meye.grab_fbuffer && req->count == gbuffers) {
1240 /* already allocated, no modifications */
1244 mutex_lock(&meye.lock);
1245 if (meye.grab_fbuffer) {
1246 for (i = 0; i < gbuffers; i++)
1247 if (meye.vma_use_count[i]) {
1248 mutex_unlock(&meye.lock);
1251 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1252 meye.grab_fbuffer = NULL;
1255 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1256 req->count = gbuffers;
1257 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1259 if (!meye.grab_fbuffer) {
1260 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1261 mutex_unlock(&meye.lock);
1265 for (i = 0; i < gbuffers; i++)
1266 meye.vma_use_count[i] = 0;
1268 mutex_unlock(&meye.lock);
1273 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1275 unsigned int index = buf->index;
1277 if (index >= gbuffers)
1280 buf->bytesused = meye.grab_buffer[index].size;
1281 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1283 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1284 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1286 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1287 buf->flags |= V4L2_BUF_FLAG_DONE;
1289 buf->field = V4L2_FIELD_NONE;
1290 buf->timestamp = meye.grab_buffer[index].timestamp;
1291 buf->sequence = meye.grab_buffer[index].sequence;
1292 buf->memory = V4L2_MEMORY_MMAP;
1293 buf->m.offset = index * gbufsize;
1294 buf->length = gbufsize;
1299 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1301 if (buf->memory != V4L2_MEMORY_MMAP)
1304 if (buf->index >= gbuffers)
1307 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1310 mutex_lock(&meye.lock);
1311 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1312 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1313 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1314 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1315 sizeof(int), &meye.grabq_lock);
1316 mutex_unlock(&meye.lock);
1321 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1325 if (buf->memory != V4L2_MEMORY_MMAP)
1328 mutex_lock(&meye.lock);
1330 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1331 mutex_unlock(&meye.lock);
1335 if (wait_event_interruptible(meye.proc_list,
1336 kfifo_len(&meye.doneq) != 0) < 0) {
1337 mutex_unlock(&meye.lock);
1341 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1342 sizeof(int), &meye.doneq_lock)) {
1343 mutex_unlock(&meye.lock);
1347 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1348 mutex_unlock(&meye.lock);
1353 buf->bytesused = meye.grab_buffer[reqnr].size;
1354 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1355 buf->field = V4L2_FIELD_NONE;
1356 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1357 buf->sequence = meye.grab_buffer[reqnr].sequence;
1358 buf->memory = V4L2_MEMORY_MMAP;
1359 buf->m.offset = reqnr * gbufsize;
1360 buf->length = gbufsize;
1361 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1362 mutex_unlock(&meye.lock);
1367 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1369 mutex_lock(&meye.lock);
1371 switch (meye.mchip_mode) {
1372 case MCHIP_HIC_MODE_CONT_OUT:
1373 mchip_continuous_start();
1375 case MCHIP_HIC_MODE_CONT_COMP:
1376 mchip_cont_compression_start();
1379 mutex_unlock(&meye.lock);
1383 mutex_unlock(&meye.lock);
1388 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1390 mutex_lock(&meye.lock);
1392 kfifo_reset(&meye.grabq);
1393 kfifo_reset(&meye.doneq);
1395 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1396 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1398 mutex_unlock(&meye.lock);
1402 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1403 unsigned int cmd, void *arg)
1406 case MEYEIOC_G_PARAMS:
1407 return meyeioc_g_params((struct meye_params *) arg);
1409 case MEYEIOC_S_PARAMS:
1410 return meyeioc_s_params((struct meye_params *) arg);
1412 case MEYEIOC_QBUF_CAPT:
1413 return meyeioc_qbuf_capt((int *) arg);
1416 return meyeioc_sync(file, fh, (int *) arg);
1418 case MEYEIOC_STILLCAPT:
1419 return meyeioc_stillcapt();
1421 case MEYEIOC_STILLJCAPT:
1422 return meyeioc_stilljcapt((int *) arg);
1430 static unsigned int meye_poll(struct file *file, poll_table *wait)
1432 unsigned int res = v4l2_ctrl_poll(file, wait);
1434 mutex_lock(&meye.lock);
1435 poll_wait(file, &meye.proc_list, wait);
1436 if (kfifo_len(&meye.doneq))
1437 res |= POLLIN | POLLRDNORM;
1438 mutex_unlock(&meye.lock);
1442 static void meye_vm_open(struct vm_area_struct *vma)
1444 long idx = (long)vma->vm_private_data;
1445 meye.vma_use_count[idx]++;
1448 static void meye_vm_close(struct vm_area_struct *vma)
1450 long idx = (long)vma->vm_private_data;
1451 meye.vma_use_count[idx]--;
1454 static const struct vm_operations_struct meye_vm_ops = {
1455 .open = meye_vm_open,
1456 .close = meye_vm_close,
1459 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1461 unsigned long start = vma->vm_start;
1462 unsigned long size = vma->vm_end - vma->vm_start;
1463 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1464 unsigned long page, pos;
1466 mutex_lock(&meye.lock);
1467 if (size > gbuffers * gbufsize) {
1468 mutex_unlock(&meye.lock);
1471 if (!meye.grab_fbuffer) {
1474 /* lazy allocation */
1475 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1476 if (!meye.grab_fbuffer) {
1477 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1478 mutex_unlock(&meye.lock);
1481 for (i = 0; i < gbuffers; i++)
1482 meye.vma_use_count[i] = 0;
1484 pos = (unsigned long)meye.grab_fbuffer + offset;
1487 page = vmalloc_to_pfn((void *)pos);
1488 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1489 mutex_unlock(&meye.lock);
1494 if (size > PAGE_SIZE)
1500 vma->vm_ops = &meye_vm_ops;
1501 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1502 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1503 vma->vm_private_data = (void *) (offset / gbufsize);
1506 mutex_unlock(&meye.lock);
1510 static const struct v4l2_file_operations meye_fops = {
1511 .owner = THIS_MODULE,
1513 .release = meye_release,
1515 .unlocked_ioctl = video_ioctl2,
1519 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1520 .vidioc_querycap = vidioc_querycap,
1521 .vidioc_enum_input = vidioc_enum_input,
1522 .vidioc_g_input = vidioc_g_input,
1523 .vidioc_s_input = vidioc_s_input,
1524 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1525 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1526 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1527 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1528 .vidioc_reqbufs = vidioc_reqbufs,
1529 .vidioc_querybuf = vidioc_querybuf,
1530 .vidioc_qbuf = vidioc_qbuf,
1531 .vidioc_dqbuf = vidioc_dqbuf,
1532 .vidioc_streamon = vidioc_streamon,
1533 .vidioc_streamoff = vidioc_streamoff,
1534 .vidioc_log_status = v4l2_ctrl_log_status,
1535 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1536 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1537 .vidioc_default = vidioc_default,
1540 static struct video_device meye_template = {
1543 .ioctl_ops = &meye_ioctl_ops,
1544 .release = video_device_release_empty,
1547 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1548 .s_ctrl = meye_s_ctrl,
1552 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1554 pci_save_state(pdev);
1555 meye.pm_mchip_mode = meye.mchip_mode;
1557 mchip_set(MCHIP_MM_INTA, 0x0);
1561 static int meye_resume(struct pci_dev *pdev)
1563 pci_restore_state(pdev);
1564 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1566 mchip_delay(MCHIP_HIC_CMD, 0);
1567 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1569 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1571 mchip_set(MCHIP_MM_PCI_MODE, 5);
1573 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1575 switch (meye.pm_mchip_mode) {
1576 case MCHIP_HIC_MODE_CONT_OUT:
1577 mchip_continuous_start();
1579 case MCHIP_HIC_MODE_CONT_COMP:
1580 mchip_cont_compression_start();
1587 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1589 static const struct v4l2_ctrl_config ctrl_agc = {
1590 .id = V4L2_CID_MEYE_AGC,
1591 .type = V4L2_CTRL_TYPE_INTEGER,
1592 .ops = &meye_ctrl_ops,
1597 .flags = V4L2_CTRL_FLAG_SLIDER,
1599 static const struct v4l2_ctrl_config ctrl_picture = {
1600 .id = V4L2_CID_MEYE_PICTURE,
1601 .type = V4L2_CTRL_TYPE_INTEGER,
1602 .ops = &meye_ctrl_ops,
1607 static const struct v4l2_ctrl_config ctrl_framerate = {
1608 .id = V4L2_CID_MEYE_FRAMERATE,
1609 .type = V4L2_CTRL_TYPE_INTEGER,
1610 .ops = &meye_ctrl_ops,
1611 .name = "Framerate",
1615 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1617 unsigned long mchip_adr;
1619 if (meye.mchip_dev != NULL) {
1620 printk(KERN_ERR "meye: only one device allowed!\n");
1624 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1626 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1630 meye.mchip_dev = pcidev;
1632 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1633 if (!meye.grab_temp) {
1634 v4l2_err(v4l2_dev, "grab buffer allocation failed\n");
1638 spin_lock_init(&meye.grabq_lock);
1639 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1641 v4l2_err(v4l2_dev, "fifo allocation failed\n");
1642 goto outkfifoalloc1;
1644 spin_lock_init(&meye.doneq_lock);
1645 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1647 v4l2_err(v4l2_dev, "fifo allocation failed\n");
1648 goto outkfifoalloc2;
1651 meye.vdev = meye_template;
1652 meye.vdev.v4l2_dev = &meye.v4l2_dev;
1655 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1656 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1657 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1658 goto outsonypienable;
1661 if ((ret = pci_enable_device(meye.mchip_dev))) {
1662 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1666 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1668 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1671 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1672 pci_resource_len(meye.mchip_dev, 0),
1674 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1677 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1678 if (!meye.mchip_mmregs) {
1679 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1683 meye.mchip_irq = pcidev->irq;
1684 if (request_irq(meye.mchip_irq, meye_irq,
1685 IRQF_SHARED, "meye", meye_irq)) {
1686 v4l2_err(v4l2_dev, "request_irq failed\n");
1690 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1691 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1693 pci_set_master(meye.mchip_dev);
1695 /* Ask the camera to perform a soft reset. */
1696 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1698 mchip_delay(MCHIP_HIC_CMD, 0);
1699 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1702 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1705 mchip_set(MCHIP_MM_PCI_MODE, 5);
1708 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1710 mutex_init(&meye.lock);
1711 init_waitqueue_head(&meye.proc_list);
1713 v4l2_ctrl_handler_init(&meye.hdl, 3);
1714 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1715 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1716 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1717 V4L2_CID_HUE, 0, 63, 1, 32);
1718 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1719 V4L2_CID_CONTRAST, 0, 63, 1, 32);
1720 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1721 V4L2_CID_SATURATION, 0, 63, 1, 32);
1722 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1723 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1724 V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1725 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1726 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1727 V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1728 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1729 if (meye.hdl.error) {
1730 v4l2_err(v4l2_dev, "couldn't register controls\n");
1734 v4l2_ctrl_handler_setup(&meye.hdl);
1735 meye.vdev.ctrl_handler = &meye.hdl;
1737 if (video_register_device(&meye.vdev, VFL_TYPE_GRABBER,
1739 v4l2_err(v4l2_dev, "video_register_device failed\n");
1743 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1744 MEYE_DRIVER_VERSION);
1745 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1746 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1751 v4l2_ctrl_handler_free(&meye.hdl);
1752 free_irq(meye.mchip_irq, meye_irq);
1754 iounmap(meye.mchip_mmregs);
1756 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1757 pci_resource_len(meye.mchip_dev, 0));
1759 pci_disable_device(meye.mchip_dev);
1761 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1763 kfifo_free(&meye.doneq);
1765 kfifo_free(&meye.grabq);
1767 vfree(meye.grab_temp);
1772 static void meye_remove(struct pci_dev *pcidev)
1774 video_unregister_device(&meye.vdev);
1780 /* disable interrupts */
1781 mchip_set(MCHIP_MM_INTA, 0x0);
1783 free_irq(meye.mchip_irq, meye_irq);
1785 iounmap(meye.mchip_mmregs);
1787 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1788 pci_resource_len(meye.mchip_dev, 0));
1790 pci_disable_device(meye.mchip_dev);
1792 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1794 kfifo_free(&meye.doneq);
1795 kfifo_free(&meye.grabq);
1797 vfree(meye.grab_temp);
1799 if (meye.grab_fbuffer) {
1800 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1801 meye.grab_fbuffer = NULL;
1804 printk(KERN_INFO "meye: removed\n");
1807 static struct pci_device_id meye_pci_tbl[] = {
1808 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1812 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1814 static struct pci_driver meye_driver = {
1816 .id_table = meye_pci_tbl,
1817 .probe = meye_probe,
1818 .remove = meye_remove,
1820 .suspend = meye_suspend,
1821 .resume = meye_resume,
1825 static int __init meye_init(void)
1827 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1828 if (gbufsize > MEYE_MAX_BUFSIZE)
1829 gbufsize = MEYE_MAX_BUFSIZE;
1830 gbufsize = PAGE_ALIGN(gbufsize);
1831 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1833 gbufsize / 1024, gbuffers * gbufsize / 1024);
1834 return pci_register_driver(&meye_driver);
1837 static void __exit meye_exit(void)
1839 pci_unregister_driver(&meye_driver);
1842 module_init(meye_init);
1843 module_exit(meye_exit);