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/init.h>
32 #include <linux/videodev.h>
33 #include <media/v4l2-common.h>
34 #include <asm/uaccess.h>
36 #include <linux/delay.h>
37 #include <linux/interrupt.h>
38 #include <linux/vmalloc.h>
39 #include <linux/dma-mapping.h>
42 #include <linux/meye.h>
44 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
45 MODULE_DESCRIPTION("v4l/v4l2 driver for the MotionEye camera");
46 MODULE_LICENSE("GPL");
47 MODULE_VERSION(MEYE_DRIVER_VERSION);
49 /* force usage of V4L1 API */
50 static int forcev4l1; /* = 0 */
51 module_param(forcev4l1, int, 0644);
52 MODULE_PARM_DESC(forcev4l1, "force use of V4L1 instead of V4L2");
54 /* number of grab buffers */
55 static unsigned int gbuffers = 2;
56 module_param(gbuffers, int, 0444);
57 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
59 /* size of a grab buffer */
60 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
61 module_param(gbufsize, int, 0444);
62 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400"
63 " (will be rounded up to a page multiple)");
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_32BIT_MASK))
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)
591 v = mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
595 /* frees the current frame from the dma engine */
596 static void mchip_free_frame(void)
598 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
600 meye.mchip_fnum %= 4;
603 /* read one frame from the framebuffer assuming it was captured using
604 a uncompressed transfer */
605 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
609 pt_id = (v >> 17) & 0x3FF;
611 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
614 /* read a compressed frame from the framebuffer */
615 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
617 int pt_start, pt_end, trailer;
621 pt_start = (v >> 19) & 0xFF;
622 pt_end = (v >> 11) & 0xFF;
623 trailer = (v >> 1) & 0x3FF;
625 if (pt_end < pt_start)
626 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
627 pt_end * PAGE_SIZE + trailer * 4;
629 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
632 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
637 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
639 #ifdef MEYE_JPEG_CORRECTION
641 /* Some mchip generated jpeg frames are incorrect. In most
642 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
643 * is not present at the end of the frame.
645 * Since adding the final marker is not enough to restore
646 * the jpeg integrity, we drop the frame.
649 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
651 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
659 /* take a picture into SDRAM */
660 static void mchip_take_picture(void)
666 mchip_dma_setup(meye.mchip_dmahandle);
668 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
669 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
671 mchip_delay(MCHIP_HIC_CMD, 0);
673 for (i = 0; i < 100; ++i) {
674 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
680 /* dma a previously taken picture into a buffer */
681 static void mchip_get_picture(u8 *buf, int bufsize)
686 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
687 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
689 mchip_delay(MCHIP_HIC_CMD, 0);
690 for (i = 0; i < 100; ++i) {
691 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
695 for (i = 0; i < 4; ++i) {
696 v = mchip_get_frame();
697 if (v & MCHIP_MM_FIR_RDY) {
698 mchip_cont_read_frame(v, buf, bufsize);
705 /* start continuous dma capture */
706 static void mchip_continuous_start(void)
710 mchip_set_framerate();
711 mchip_dma_setup(meye.mchip_dmahandle);
713 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
715 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
716 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
718 mchip_delay(MCHIP_HIC_CMD, 0);
721 /* compress one frame into a buffer */
722 static int mchip_compress_frame(u8 *buf, int bufsize)
727 mchip_vrj_setup(0x3f);
730 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
731 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
733 mchip_delay(MCHIP_HIC_CMD, 0);
734 for (i = 0; i < 100; ++i) {
735 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
740 for (i = 0; i < 4; ++i) {
741 v = mchip_get_frame();
742 if (v & MCHIP_MM_FIR_RDY) {
743 len = mchip_comp_read_frame(v, buf, bufsize);
752 /* uncompress one image into a buffer */
753 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
755 mchip_vrj_setup(0x3f);
758 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
759 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
761 mchip_delay(MCHIP_HIC_CMD, 0);
763 return mchip_comp_read_frame(buf, bufsize);
767 /* start continuous compressed capture */
768 static void mchip_cont_compression_start(void)
771 mchip_vrj_setup(0x3f);
773 mchip_set_framerate();
774 mchip_dma_setup(meye.mchip_dmahandle);
776 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
778 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
779 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
781 mchip_delay(MCHIP_HIC_CMD, 0);
784 /****************************************************************************/
785 /* Interrupt handling */
786 /****************************************************************************/
788 static irqreturn_t meye_irq(int irq, void *dev_id)
792 static int sequence = 0;
794 v = mchip_read(MCHIP_MM_INTA);
796 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
797 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
801 v = mchip_get_frame();
802 if (!(v & MCHIP_MM_FIR_RDY))
805 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
806 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
807 sizeof(int)) != sizeof(int)) {
811 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
812 mchip_hsize() * mchip_vsize() * 2);
813 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
814 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
815 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
816 meye.grab_buffer[reqnr].sequence = sequence++;
817 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
818 wake_up_interruptible(&meye.proc_list);
821 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
826 if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
827 sizeof(int)) != sizeof(int)) {
831 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
833 meye.grab_buffer[reqnr].size = size;
834 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
835 do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
836 meye.grab_buffer[reqnr].sequence = sequence++;
837 kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
838 wake_up_interruptible(&meye.proc_list);
844 /****************************************************************************/
845 /* video4linux integration */
846 /****************************************************************************/
848 static int meye_open(struct inode *inode, struct file *file)
852 err = video_exclusive_open(inode, file);
858 if (mchip_dma_alloc()) {
859 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
860 video_exclusive_release(inode, file);
864 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
865 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
866 kfifo_reset(meye.grabq);
867 kfifo_reset(meye.doneq);
871 static int meye_release(struct inode *inode, struct file *file)
875 video_exclusive_release(inode, file);
879 static int meye_do_ioctl(struct inode *inode, struct file *file,
880 unsigned int cmd, void *arg)
885 struct video_capability *b = arg;
886 strcpy(b->name,meye.video_dev->name);
887 b->type = VID_TYPE_CAPTURE;
898 struct video_channel *v = arg;
901 v->type = VIDEO_TYPE_CAMERA;
904 strcpy(v->name,"Camera");
909 struct video_channel *v = arg;
916 struct video_picture *p = arg;
922 struct video_picture *p = arg;
925 if (p->palette != VIDEO_PALETTE_YUV422 && p->palette != VIDEO_PALETTE_YUYV)
927 mutex_lock(&meye.lock);
928 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS,
929 p->brightness >> 10);
930 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE,
932 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR,
934 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST,
937 mutex_unlock(&meye.lock);
945 if (*i < 0 || *i >= gbuffers)
948 mutex_lock(&meye.lock);
950 switch (meye.grab_buffer[*i].state) {
952 case MEYE_BUF_UNUSED:
953 mutex_unlock(&meye.lock);
956 if (file->f_flags & O_NONBLOCK) {
957 mutex_unlock(&meye.lock);
960 if (wait_event_interruptible(meye.proc_list,
961 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
962 mutex_unlock(&meye.lock);
967 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
968 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
970 mutex_unlock(&meye.lock);
974 case VIDIOCMCAPTURE: {
975 struct video_mmap *vm = arg;
978 if (vm->frame >= gbuffers || vm->frame < 0)
980 if (vm->format != VIDEO_PALETTE_YUV422 && vm->format != VIDEO_PALETTE_YUYV)
982 if (vm->height * vm->width * 2 > gbufsize)
984 if (!meye.grab_fbuffer)
986 if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
989 mutex_lock(&meye.lock);
990 if (vm->width == 640 && vm->height == 480) {
991 if (meye.params.subsample) {
992 meye.params.subsample = 0;
995 } else if (vm->width == 320 && vm->height == 240) {
996 if (!meye.params.subsample) {
997 meye.params.subsample = 1;
1001 mutex_unlock(&meye.lock);
1005 if (restart || meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT)
1006 mchip_continuous_start();
1007 meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
1008 kfifo_put(meye.grabq, (unsigned char *)&vm->frame, sizeof(int));
1009 mutex_unlock(&meye.lock);
1014 struct video_mbuf *vm = arg;
1017 memset(vm, 0 , sizeof(*vm));
1018 vm->size = gbufsize * gbuffers;
1019 vm->frames = gbuffers;
1020 for (i = 0; i < gbuffers; i++)
1021 vm->offsets[i] = i * gbufsize;
1025 case MEYEIOC_G_PARAMS: {
1026 struct meye_params *p = arg;
1031 case MEYEIOC_S_PARAMS: {
1032 struct meye_params *jp = arg;
1033 if (jp->subsample > 1)
1035 if (jp->quality > 10)
1037 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
1039 if (jp->framerate > 31)
1041 mutex_lock(&meye.lock);
1042 if (meye.params.subsample != jp->subsample ||
1043 meye.params.quality != jp->quality)
1044 mchip_hic_stop(); /* need restart */
1046 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
1047 meye.params.sharpness);
1048 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
1050 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
1051 meye.params.picture);
1052 mutex_unlock(&meye.lock);
1056 case MEYEIOC_QBUF_CAPT: {
1059 if (!meye.grab_fbuffer)
1061 if (*nb >= gbuffers)
1068 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
1070 mutex_lock(&meye.lock);
1071 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
1072 mchip_cont_compression_start();
1073 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
1074 kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
1075 mutex_unlock(&meye.lock);
1079 case MEYEIOC_SYNC: {
1083 if (*i < 0 || *i >= gbuffers)
1086 mutex_lock(&meye.lock);
1087 switch (meye.grab_buffer[*i].state) {
1089 case MEYE_BUF_UNUSED:
1090 mutex_unlock(&meye.lock);
1092 case MEYE_BUF_USING:
1093 if (file->f_flags & O_NONBLOCK) {
1094 mutex_unlock(&meye.lock);
1097 if (wait_event_interruptible(meye.proc_list,
1098 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
1099 mutex_unlock(&meye.lock);
1104 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
1105 kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
1107 *i = meye.grab_buffer[*i].size;
1108 mutex_unlock(&meye.lock);
1112 case MEYEIOC_STILLCAPT: {
1114 if (!meye.grab_fbuffer)
1116 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1118 mutex_lock(&meye.lock);
1119 meye.grab_buffer[0].state = MEYE_BUF_USING;
1120 mchip_take_picture();
1123 mchip_hsize() * mchip_vsize() * 2);
1124 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1125 mutex_unlock(&meye.lock);
1129 case MEYEIOC_STILLJCAPT: {
1132 if (!meye.grab_fbuffer)
1134 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
1136 mutex_lock(&meye.lock);
1137 meye.grab_buffer[0].state = MEYE_BUF_USING;
1139 while (*len == -1) {
1140 mchip_take_picture();
1141 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1143 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1144 mutex_unlock(&meye.lock);
1148 case VIDIOC_QUERYCAP: {
1149 struct v4l2_capability *cap = arg;
1154 memset(cap, 0, sizeof(*cap));
1155 strcpy(cap->driver, "meye");
1156 strcpy(cap->card, "meye");
1157 sprintf(cap->bus_info, "PCI:%s", pci_name(meye.mchip_dev));
1158 cap->version = (MEYE_DRIVER_MAJORVERSION << 8) +
1159 MEYE_DRIVER_MINORVERSION;
1160 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
1165 case VIDIOC_ENUMINPUT: {
1166 struct v4l2_input *i = arg;
1170 memset(i, 0, sizeof(*i));
1172 strcpy(i->name, "Camera");
1173 i->type = V4L2_INPUT_TYPE_CAMERA;
1177 case VIDIOC_G_INPUT: {
1184 case VIDIOC_S_INPUT: {
1192 case VIDIOC_QUERYCTRL: {
1193 struct v4l2_queryctrl *c = arg;
1197 case V4L2_CID_BRIGHTNESS:
1198 c->type = V4L2_CTRL_TYPE_INTEGER;
1199 strcpy(c->name, "Brightness");
1203 c->default_value = 32;
1207 c->type = V4L2_CTRL_TYPE_INTEGER;
1208 strcpy(c->name, "Hue");
1212 c->default_value = 32;
1215 case V4L2_CID_CONTRAST:
1216 c->type = V4L2_CTRL_TYPE_INTEGER;
1217 strcpy(c->name, "Contrast");
1221 c->default_value = 32;
1224 case V4L2_CID_SATURATION:
1225 c->type = V4L2_CTRL_TYPE_INTEGER;
1226 strcpy(c->name, "Saturation");
1230 c->default_value = 32;
1234 c->type = V4L2_CTRL_TYPE_INTEGER;
1235 strcpy(c->name, "Agc");
1239 c->default_value = 48;
1242 case V4L2_CID_SHARPNESS:
1243 c->type = V4L2_CTRL_TYPE_INTEGER;
1244 strcpy(c->name, "Sharpness");
1248 c->default_value = 32;
1251 case V4L2_CID_PICTURE:
1252 c->type = V4L2_CTRL_TYPE_INTEGER;
1253 strcpy(c->name, "Picture");
1257 c->default_value = 0;
1260 case V4L2_CID_JPEGQUAL:
1261 c->type = V4L2_CTRL_TYPE_INTEGER;
1262 strcpy(c->name, "JPEG quality");
1266 c->default_value = 8;
1269 case V4L2_CID_FRAMERATE:
1270 c->type = V4L2_CTRL_TYPE_INTEGER;
1271 strcpy(c->name, "Framerate");
1275 c->default_value = 0;
1284 case VIDIOC_S_CTRL: {
1285 struct v4l2_control *c = arg;
1287 mutex_lock(&meye.lock);
1289 case V4L2_CID_BRIGHTNESS:
1290 sony_pic_camera_command(
1291 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, c->value);
1292 meye.picture.brightness = c->value << 10;
1295 sony_pic_camera_command(
1296 SONY_PIC_COMMAND_SETCAMERAHUE, c->value);
1297 meye.picture.hue = c->value << 10;
1299 case V4L2_CID_CONTRAST:
1300 sony_pic_camera_command(
1301 SONY_PIC_COMMAND_SETCAMERACONTRAST, c->value);
1302 meye.picture.contrast = c->value << 10;
1304 case V4L2_CID_SATURATION:
1305 sony_pic_camera_command(
1306 SONY_PIC_COMMAND_SETCAMERACOLOR, c->value);
1307 meye.picture.colour = c->value << 10;
1310 sony_pic_camera_command(
1311 SONY_PIC_COMMAND_SETCAMERAAGC, c->value);
1312 meye.params.agc = c->value;
1314 case V4L2_CID_SHARPNESS:
1315 sony_pic_camera_command(
1316 SONY_PIC_COMMAND_SETCAMERASHARPNESS, c->value);
1317 meye.params.sharpness = c->value;
1319 case V4L2_CID_PICTURE:
1320 sony_pic_camera_command(
1321 SONY_PIC_COMMAND_SETCAMERAPICTURE, c->value);
1322 meye.params.picture = c->value;
1324 case V4L2_CID_JPEGQUAL:
1325 meye.params.quality = c->value;
1327 case V4L2_CID_FRAMERATE:
1328 meye.params.framerate = c->value;
1331 mutex_unlock(&meye.lock);
1334 mutex_unlock(&meye.lock);
1338 case VIDIOC_G_CTRL: {
1339 struct v4l2_control *c = arg;
1341 mutex_lock(&meye.lock);
1343 case V4L2_CID_BRIGHTNESS:
1344 c->value = meye.picture.brightness >> 10;
1347 c->value = meye.picture.hue >> 10;
1349 case V4L2_CID_CONTRAST:
1350 c->value = meye.picture.contrast >> 10;
1352 case V4L2_CID_SATURATION:
1353 c->value = meye.picture.colour >> 10;
1356 c->value = meye.params.agc;
1358 case V4L2_CID_SHARPNESS:
1359 c->value = meye.params.sharpness;
1361 case V4L2_CID_PICTURE:
1362 c->value = meye.params.picture;
1364 case V4L2_CID_JPEGQUAL:
1365 c->value = meye.params.quality;
1367 case V4L2_CID_FRAMERATE:
1368 c->value = meye.params.framerate;
1371 mutex_unlock(&meye.lock);
1374 mutex_unlock(&meye.lock);
1378 case VIDIOC_ENUM_FMT: {
1379 struct v4l2_fmtdesc *f = arg;
1383 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1385 if (f->index == 0) {
1386 /* standard YUV 422 capture */
1387 memset(f, 0, sizeof(*f));
1389 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1391 strcpy(f->description, "YUV422");
1392 f->pixelformat = V4L2_PIX_FMT_YUYV;
1394 /* compressed MJPEG capture */
1395 memset(f, 0, sizeof(*f));
1397 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1398 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1399 strcpy(f->description, "MJPEG");
1400 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1405 case VIDIOC_TRY_FMT: {
1406 struct v4l2_format *f = arg;
1408 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1410 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1411 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1413 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1414 f->fmt.pix.field != V4L2_FIELD_NONE)
1416 f->fmt.pix.field = V4L2_FIELD_NONE;
1417 if (f->fmt.pix.width <= 320) {
1418 f->fmt.pix.width = 320;
1419 f->fmt.pix.height = 240;
1421 f->fmt.pix.width = 640;
1422 f->fmt.pix.height = 480;
1424 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1425 f->fmt.pix.sizeimage = f->fmt.pix.height *
1426 f->fmt.pix.bytesperline;
1427 f->fmt.pix.colorspace = 0;
1428 f->fmt.pix.priv = 0;
1432 case VIDIOC_G_FMT: {
1433 struct v4l2_format *f = arg;
1435 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1437 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
1438 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1439 switch (meye.mchip_mode) {
1440 case MCHIP_HIC_MODE_CONT_OUT:
1442 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1444 case MCHIP_HIC_MODE_CONT_COMP:
1445 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1448 f->fmt.pix.field = V4L2_FIELD_NONE;
1449 f->fmt.pix.width = mchip_hsize();
1450 f->fmt.pix.height = mchip_vsize();
1451 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1452 f->fmt.pix.sizeimage = f->fmt.pix.height *
1453 f->fmt.pix.bytesperline;
1454 f->fmt.pix.colorspace = 0;
1455 f->fmt.pix.priv = 0;
1459 case VIDIOC_S_FMT: {
1460 struct v4l2_format *f = arg;
1462 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1464 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1465 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1467 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1468 f->fmt.pix.field != V4L2_FIELD_NONE)
1470 f->fmt.pix.field = V4L2_FIELD_NONE;
1471 mutex_lock(&meye.lock);
1472 if (f->fmt.pix.width <= 320) {
1473 f->fmt.pix.width = 320;
1474 f->fmt.pix.height = 240;
1475 meye.params.subsample = 1;
1477 f->fmt.pix.width = 640;
1478 f->fmt.pix.height = 480;
1479 meye.params.subsample = 0;
1481 switch (f->fmt.pix.pixelformat) {
1482 case V4L2_PIX_FMT_YUYV:
1483 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1485 case V4L2_PIX_FMT_MJPEG:
1486 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1489 mutex_unlock(&meye.lock);
1490 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1491 f->fmt.pix.sizeimage = f->fmt.pix.height *
1492 f->fmt.pix.bytesperline;
1493 f->fmt.pix.colorspace = 0;
1494 f->fmt.pix.priv = 0;
1499 case VIDIOC_REQBUFS: {
1500 struct v4l2_requestbuffers *req = arg;
1503 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1505 if (req->memory != V4L2_MEMORY_MMAP)
1507 if (meye.grab_fbuffer && req->count == gbuffers) {
1508 /* already allocated, no modifications */
1511 mutex_lock(&meye.lock);
1512 if (meye.grab_fbuffer) {
1513 for (i = 0; i < gbuffers; i++)
1514 if (meye.vma_use_count[i]) {
1515 mutex_unlock(&meye.lock);
1518 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1519 meye.grab_fbuffer = NULL;
1521 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1522 req->count = gbuffers;
1523 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1524 if (!meye.grab_fbuffer) {
1525 printk(KERN_ERR "meye: v4l framebuffer allocation"
1527 mutex_unlock(&meye.lock);
1530 for (i = 0; i < gbuffers; i++)
1531 meye.vma_use_count[i] = 0;
1532 mutex_unlock(&meye.lock);
1536 case VIDIOC_QUERYBUF: {
1537 struct v4l2_buffer *buf = arg;
1538 int index = buf->index;
1540 if (index < 0 || index >= gbuffers)
1542 memset(buf, 0, sizeof(*buf));
1543 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1545 buf->bytesused = meye.grab_buffer[index].size;
1546 buf->flags = V4L2_BUF_FLAG_MAPPED;
1547 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1548 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1549 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1550 buf->flags |= V4L2_BUF_FLAG_DONE;
1551 buf->field = V4L2_FIELD_NONE;
1552 buf->timestamp = meye.grab_buffer[index].timestamp;
1553 buf->sequence = meye.grab_buffer[index].sequence;
1554 buf->memory = V4L2_MEMORY_MMAP;
1555 buf->m.offset = index * gbufsize;
1556 buf->length = gbufsize;
1561 struct v4l2_buffer *buf = arg;
1563 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1565 if (buf->memory != V4L2_MEMORY_MMAP)
1567 if (buf->index < 0 || buf->index >= gbuffers)
1569 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1571 mutex_lock(&meye.lock);
1572 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1573 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1574 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1575 kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1576 mutex_unlock(&meye.lock);
1580 case VIDIOC_DQBUF: {
1581 struct v4l2_buffer *buf = arg;
1584 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1586 if (buf->memory != V4L2_MEMORY_MMAP)
1589 mutex_lock(&meye.lock);
1590 if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1591 mutex_unlock(&meye.lock);
1594 if (wait_event_interruptible(meye.proc_list,
1595 kfifo_len(meye.doneq) != 0) < 0) {
1596 mutex_unlock(&meye.lock);
1599 if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1601 mutex_unlock(&meye.lock);
1604 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1605 mutex_unlock(&meye.lock);
1609 buf->bytesused = meye.grab_buffer[reqnr].size;
1610 buf->flags = V4L2_BUF_FLAG_MAPPED;
1611 buf->field = V4L2_FIELD_NONE;
1612 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1613 buf->sequence = meye.grab_buffer[reqnr].sequence;
1614 buf->memory = V4L2_MEMORY_MMAP;
1615 buf->m.offset = reqnr * gbufsize;
1616 buf->length = gbufsize;
1617 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1618 mutex_unlock(&meye.lock);
1622 case VIDIOC_STREAMON: {
1623 mutex_lock(&meye.lock);
1624 switch (meye.mchip_mode) {
1625 case MCHIP_HIC_MODE_CONT_OUT:
1626 mchip_continuous_start();
1628 case MCHIP_HIC_MODE_CONT_COMP:
1629 mchip_cont_compression_start();
1632 mutex_unlock(&meye.lock);
1635 mutex_unlock(&meye.lock);
1639 case VIDIOC_STREAMOFF: {
1642 mutex_lock(&meye.lock);
1644 kfifo_reset(meye.grabq);
1645 kfifo_reset(meye.doneq);
1646 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1647 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1648 mutex_unlock(&meye.lock);
1653 * XXX what about private snapshot ioctls ?
1654 * Do they need to be converted to V4L2 ?
1658 return -ENOIOCTLCMD;
1664 static int meye_ioctl(struct inode *inode, struct file *file,
1665 unsigned int cmd, unsigned long arg)
1667 return video_usercopy(inode, file, cmd, arg, meye_do_ioctl);
1670 static unsigned int meye_poll(struct file *file, poll_table *wait)
1672 unsigned int res = 0;
1674 mutex_lock(&meye.lock);
1675 poll_wait(file, &meye.proc_list, wait);
1676 if (kfifo_len(meye.doneq))
1677 res = POLLIN | POLLRDNORM;
1678 mutex_unlock(&meye.lock);
1682 static void meye_vm_open(struct vm_area_struct *vma)
1684 long idx = (long)vma->vm_private_data;
1685 meye.vma_use_count[idx]++;
1688 static void meye_vm_close(struct vm_area_struct *vma)
1690 long idx = (long)vma->vm_private_data;
1691 meye.vma_use_count[idx]--;
1694 static struct vm_operations_struct meye_vm_ops = {
1695 .open = meye_vm_open,
1696 .close = meye_vm_close,
1699 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1701 unsigned long start = vma->vm_start;
1702 unsigned long size = vma->vm_end - vma->vm_start;
1703 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1704 unsigned long page, pos;
1706 mutex_lock(&meye.lock);
1707 if (size > gbuffers * gbufsize) {
1708 mutex_unlock(&meye.lock);
1711 if (!meye.grab_fbuffer) {
1714 /* lazy allocation */
1715 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1716 if (!meye.grab_fbuffer) {
1717 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1718 mutex_unlock(&meye.lock);
1721 for (i = 0; i < gbuffers; i++)
1722 meye.vma_use_count[i] = 0;
1724 pos = (unsigned long)meye.grab_fbuffer + offset;
1727 page = vmalloc_to_pfn((void *)pos);
1728 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1729 mutex_unlock(&meye.lock);
1734 if (size > PAGE_SIZE)
1740 vma->vm_ops = &meye_vm_ops;
1741 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1742 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1743 vma->vm_private_data = (void *) (offset / gbufsize);
1746 mutex_unlock(&meye.lock);
1750 static const struct file_operations meye_fops = {
1751 .owner = THIS_MODULE,
1753 .release = meye_release,
1755 .ioctl = meye_ioctl,
1756 .compat_ioctl = v4l_compat_ioctl32,
1758 .llseek = no_llseek,
1761 static struct video_device meye_template = {
1762 .owner = THIS_MODULE,
1764 .type = VID_TYPE_CAPTURE,
1765 .hardware = VID_HARDWARE_MEYE,
1767 .release = video_device_release,
1772 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1774 pci_save_state(pdev);
1775 meye.pm_mchip_mode = meye.mchip_mode;
1777 mchip_set(MCHIP_MM_INTA, 0x0);
1781 static int meye_resume(struct pci_dev *pdev)
1783 pci_restore_state(pdev);
1784 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1786 mchip_delay(MCHIP_HIC_CMD, 0);
1787 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1789 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1791 mchip_set(MCHIP_MM_PCI_MODE, 5);
1793 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1795 switch (meye.pm_mchip_mode) {
1796 case MCHIP_HIC_MODE_CONT_OUT:
1797 mchip_continuous_start();
1799 case MCHIP_HIC_MODE_CONT_COMP:
1800 mchip_cont_compression_start();
1807 static int __devinit meye_probe(struct pci_dev *pcidev,
1808 const struct pci_device_id *ent)
1811 unsigned long mchip_adr;
1813 if (meye.mchip_dev != NULL) {
1814 printk(KERN_ERR "meye: only one device allowed!\n");
1818 meye.mchip_dev = pcidev;
1819 meye.video_dev = video_device_alloc();
1820 if (!meye.video_dev) {
1821 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1826 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1827 if (!meye.grab_temp) {
1828 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1832 spin_lock_init(&meye.grabq_lock);
1833 meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1835 if (IS_ERR(meye.grabq)) {
1836 printk(KERN_ERR "meye: fifo allocation failed\n");
1837 goto outkfifoalloc1;
1839 spin_lock_init(&meye.doneq_lock);
1840 meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1842 if (IS_ERR(meye.doneq)) {
1843 printk(KERN_ERR "meye: fifo allocation failed\n");
1844 goto outkfifoalloc2;
1847 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1848 meye.video_dev->dev = &meye.mchip_dev->dev;
1850 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1851 printk(KERN_ERR "meye: unable to power on the camera\n");
1852 printk(KERN_ERR "meye: did you enable the camera in "
1853 "sonypi using the module options ?\n");
1854 goto outsonypienable;
1858 if ((ret = pci_enable_device(meye.mchip_dev))) {
1859 printk(KERN_ERR "meye: pci_enable_device failed\n");
1863 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1865 printk(KERN_ERR "meye: mchip has no device base address\n");
1868 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1869 pci_resource_len(meye.mchip_dev, 0),
1871 printk(KERN_ERR "meye: request_mem_region failed\n");
1874 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1875 if (!meye.mchip_mmregs) {
1876 printk(KERN_ERR "meye: ioremap failed\n");
1880 meye.mchip_irq = pcidev->irq;
1881 if (request_irq(meye.mchip_irq, meye_irq,
1882 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1883 printk(KERN_ERR "meye: request_irq failed\n");
1887 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1888 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1890 pci_set_master(meye.mchip_dev);
1892 /* Ask the camera to perform a soft reset. */
1893 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1895 mchip_delay(MCHIP_HIC_CMD, 0);
1896 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1899 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1902 mchip_set(MCHIP_MM_PCI_MODE, 5);
1905 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1907 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1909 printk(KERN_ERR "meye: video_register_device failed\n");
1913 mutex_init(&meye.lock);
1914 init_waitqueue_head(&meye.proc_list);
1915 meye.picture.depth = 16;
1916 meye.picture.palette = VIDEO_PALETTE_YUV422;
1917 meye.picture.brightness = 32 << 10;
1918 meye.picture.hue = 32 << 10;
1919 meye.picture.colour = 32 << 10;
1920 meye.picture.contrast = 32 << 10;
1921 meye.picture.whiteness = 0;
1922 meye.params.subsample = 0;
1923 meye.params.quality = 8;
1924 meye.params.sharpness = 32;
1925 meye.params.agc = 48;
1926 meye.params.picture = 0;
1927 meye.params.framerate = 0;
1929 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1930 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1931 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1932 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1933 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1934 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1935 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1937 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1938 MEYE_DRIVER_VERSION);
1939 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1940 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1945 free_irq(meye.mchip_irq, meye_irq);
1947 iounmap(meye.mchip_mmregs);
1949 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1950 pci_resource_len(meye.mchip_dev, 0));
1952 pci_disable_device(meye.mchip_dev);
1954 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1956 kfifo_free(meye.doneq);
1958 kfifo_free(meye.grabq);
1960 vfree(meye.grab_temp);
1962 video_device_release(meye.video_dev);
1967 static void __devexit meye_remove(struct pci_dev *pcidev)
1969 video_unregister_device(meye.video_dev);
1975 /* disable interrupts */
1976 mchip_set(MCHIP_MM_INTA, 0x0);
1978 free_irq(meye.mchip_irq, meye_irq);
1980 iounmap(meye.mchip_mmregs);
1982 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1983 pci_resource_len(meye.mchip_dev, 0));
1985 pci_disable_device(meye.mchip_dev);
1987 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1989 kfifo_free(meye.doneq);
1990 kfifo_free(meye.grabq);
1992 vfree(meye.grab_temp);
1994 if (meye.grab_fbuffer) {
1995 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1996 meye.grab_fbuffer = NULL;
1999 printk(KERN_INFO "meye: removed\n");
2002 static struct pci_device_id meye_pci_tbl[] = {
2003 { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
2004 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
2008 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
2010 static struct pci_driver meye_driver = {
2012 .id_table = meye_pci_tbl,
2013 .probe = meye_probe,
2014 .remove = __devexit_p(meye_remove),
2016 .suspend = meye_suspend,
2017 .resume = meye_resume,
2021 static int __init meye_init(void)
2023 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
2024 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
2025 gbufsize = MEYE_MAX_BUFSIZE;
2026 gbufsize = PAGE_ALIGN(gbufsize);
2027 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total)"
2030 gbufsize / 1024, gbuffers * gbufsize / 1024);
2031 return pci_register_driver(&meye_driver);
2034 static void __exit meye_exit(void)
2036 pci_unregister_driver(&meye_driver);
2039 module_init(meye_init);
2040 module_exit(meye_exit);