1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Motion Eye video4linux driver for Sony Vaio PictureBook
5 * Copyright (C) 2001-2004 Stelian Pop <stelian@popies.net>
7 * Copyright (C) 2001-2002 AlcĂ´ve <www.alcove.com>
9 * Copyright (C) 2000 Andrew Tridgell <tridge@valinux.com>
11 * Earlier work by Werner Almesberger, Paul `Rusty' Russell and Paul Mackerras.
13 * Some parts borrowed from various video4linux drivers, especially
14 * bttv-driver.c and zoran.c, see original files for credits.
16 #include <linux/module.h>
17 #include <linux/pci.h>
18 #include <linux/sched.h>
19 #include <linux/init.h>
20 #include <linux/gfp.h>
21 #include <linux/videodev2.h>
22 #include <media/v4l2-common.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-fh.h>
26 #include <media/v4l2-event.h>
27 #include <linux/uaccess.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/vmalloc.h>
32 #include <linux/dma-mapping.h>
35 #include <linux/meye.h>
37 MODULE_AUTHOR("Stelian Pop <stelian@popies.net>");
38 MODULE_DESCRIPTION("v4l2 driver for the MotionEye camera");
39 MODULE_LICENSE("GPL");
40 MODULE_VERSION(MEYE_DRIVER_VERSION);
42 /* number of grab buffers */
43 static unsigned int gbuffers = 2;
44 module_param(gbuffers, int, 0444);
45 MODULE_PARM_DESC(gbuffers, "number of capture buffers, default is 2 (32 max)");
47 /* size of a grab buffer */
48 static unsigned int gbufsize = MEYE_MAX_BUFSIZE;
49 module_param(gbufsize, int, 0444);
50 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 614400 (will be rounded up to a page multiple)");
52 /* /dev/videoX registration number */
53 static int video_nr = -1;
54 module_param(video_nr, int, 0444);
55 MODULE_PARM_DESC(video_nr, "video device to register (0=/dev/video0, etc)");
57 /* driver structure - only one possible */
58 static struct meye meye;
60 /****************************************************************************/
61 /* Memory allocation routines (stolen from bttv-driver.c) */
62 /****************************************************************************/
63 static void *rvmalloc(unsigned long size)
68 size = PAGE_ALIGN(size);
69 mem = vmalloc_32(size);
72 adr = (unsigned long) mem;
74 SetPageReserved(vmalloc_to_page((void *)adr));
82 static void rvfree(void * mem, unsigned long size)
87 adr = (unsigned long) mem;
88 while ((long) size > 0) {
89 ClearPageReserved(vmalloc_to_page((void *)adr));
98 * return a page table pointing to N pages of locked memory
100 * NOTE: The meye device expects DMA addresses on 32 bits, we build
101 * a table of 1024 entries = 4 bytes * 1024 = 4096 bytes.
103 static int ptable_alloc(void)
108 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
110 /* give only 32 bit DMA addresses */
111 if (dma_set_mask(&meye.mchip_dev->dev, DMA_BIT_MASK(32)))
114 meye.mchip_ptable_toc = dma_alloc_coherent(&meye.mchip_dev->dev,
116 &meye.mchip_dmahandle,
118 if (!meye.mchip_ptable_toc) {
119 meye.mchip_dmahandle = 0;
123 pt = meye.mchip_ptable_toc;
124 for (i = 0; i < MCHIP_NB_PAGES; i++) {
126 meye.mchip_ptable[i] = dma_alloc_coherent(&meye.mchip_dev->dev,
130 if (!meye.mchip_ptable[i]) {
132 pt = meye.mchip_ptable_toc;
133 for (j = 0; j < i; ++j) {
134 dma = (dma_addr_t) *pt;
135 dma_free_coherent(&meye.mchip_dev->dev,
137 meye.mchip_ptable[j], dma);
140 dma_free_coherent(&meye.mchip_dev->dev,
142 meye.mchip_ptable_toc,
143 meye.mchip_dmahandle);
144 meye.mchip_ptable_toc = NULL;
145 meye.mchip_dmahandle = 0;
154 static void ptable_free(void)
159 pt = meye.mchip_ptable_toc;
160 for (i = 0; i < MCHIP_NB_PAGES; i++) {
161 dma_addr_t dma = (dma_addr_t) *pt;
162 if (meye.mchip_ptable[i])
163 dma_free_coherent(&meye.mchip_dev->dev,
165 meye.mchip_ptable[i], dma);
169 if (meye.mchip_ptable_toc)
170 dma_free_coherent(&meye.mchip_dev->dev,
172 meye.mchip_ptable_toc,
173 meye.mchip_dmahandle);
175 memset(meye.mchip_ptable, 0, sizeof(meye.mchip_ptable));
176 meye.mchip_ptable_toc = NULL;
177 meye.mchip_dmahandle = 0;
180 /* copy data from ptable into buf */
181 static void ptable_copy(u8 *buf, int start, int size, int pt_pages)
185 for (i = 0; i < (size / PAGE_SIZE) * PAGE_SIZE; i += PAGE_SIZE) {
186 memcpy(buf + i, meye.mchip_ptable[start++], PAGE_SIZE);
187 if (start >= pt_pages)
190 memcpy(buf + i, meye.mchip_ptable[start], size % PAGE_SIZE);
193 /****************************************************************************/
194 /* JPEG tables at different qualities to load into the VRJ chip */
195 /****************************************************************************/
197 /* return a set of quantisation tables based on a quality from 1 to 10 */
198 static u16 *jpeg_quantisation_tables(int *length, int quality)
200 static u16 jpeg_tables[][70] = { {
201 0xdbff, 0x4300, 0xff00, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
202 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
203 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
204 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
205 0xffff, 0xffff, 0xffff,
206 0xdbff, 0x4300, 0xff01, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
207 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
208 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
209 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
210 0xffff, 0xffff, 0xffff,
213 0xdbff, 0x4300, 0x5000, 0x3c37, 0x3c46, 0x5032, 0x4146, 0x5a46,
214 0x5055, 0x785f, 0x82c8, 0x6e78, 0x786e, 0xaff5, 0x91b9, 0xffc8,
215 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
216 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
217 0xffff, 0xffff, 0xffff,
218 0xdbff, 0x4300, 0x5501, 0x5a5a, 0x6978, 0xeb78, 0x8282, 0xffeb,
219 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
220 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
221 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
222 0xffff, 0xffff, 0xffff,
225 0xdbff, 0x4300, 0x2800, 0x1e1c, 0x1e23, 0x2819, 0x2123, 0x2d23,
226 0x282b, 0x3c30, 0x4164, 0x373c, 0x3c37, 0x587b, 0x495d, 0x9164,
227 0x9980, 0x8f96, 0x8c80, 0xa08a, 0xe6b4, 0xa0c3, 0xdaaa, 0x8aad,
228 0xc88c, 0xcbff, 0xeeda, 0xfff5, 0xffff, 0xc19b, 0xffff, 0xfaff,
229 0xe6ff, 0xfffd, 0xfff8,
230 0xdbff, 0x4300, 0x2b01, 0x2d2d, 0x353c, 0x763c, 0x4141, 0xf876,
231 0x8ca5, 0xf8a5, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
232 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
233 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8, 0xf8f8,
234 0xf8f8, 0xf8f8, 0xfff8,
237 0xdbff, 0x4300, 0x1b00, 0x1412, 0x1417, 0x1b11, 0x1617, 0x1e17,
238 0x1b1c, 0x2820, 0x2b42, 0x2528, 0x2825, 0x3a51, 0x303d, 0x6042,
239 0x6555, 0x5f64, 0x5d55, 0x6a5b, 0x9978, 0x6a81, 0x9071, 0x5b73,
240 0x855d, 0x86b5, 0x9e90, 0xaba3, 0xabad, 0x8067, 0xc9bc, 0xa6ba,
241 0x99c7, 0xaba8, 0xffa4,
242 0xdbff, 0x4300, 0x1c01, 0x1e1e, 0x2328, 0x4e28, 0x2b2b, 0xa44e,
243 0x5d6e, 0xa46e, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
244 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
245 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4, 0xa4a4,
246 0xa4a4, 0xa4a4, 0xffa4,
249 0xdbff, 0x4300, 0x1400, 0x0f0e, 0x0f12, 0x140d, 0x1012, 0x1712,
250 0x1415, 0x1e18, 0x2132, 0x1c1e, 0x1e1c, 0x2c3d, 0x242e, 0x4932,
251 0x4c40, 0x474b, 0x4640, 0x5045, 0x735a, 0x5062, 0x6d55, 0x4556,
252 0x6446, 0x6588, 0x776d, 0x817b, 0x8182, 0x604e, 0x978d, 0x7d8c,
253 0x7396, 0x817e, 0xff7c,
254 0xdbff, 0x4300, 0x1501, 0x1717, 0x1a1e, 0x3b1e, 0x2121, 0x7c3b,
255 0x4653, 0x7c53, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
256 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
257 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c, 0x7c7c,
258 0x7c7c, 0x7c7c, 0xff7c,
261 0xdbff, 0x4300, 0x1000, 0x0c0b, 0x0c0e, 0x100a, 0x0d0e, 0x120e,
262 0x1011, 0x1813, 0x1a28, 0x1618, 0x1816, 0x2331, 0x1d25, 0x3a28,
263 0x3d33, 0x393c, 0x3833, 0x4037, 0x5c48, 0x404e, 0x5744, 0x3745,
264 0x5038, 0x516d, 0x5f57, 0x6762, 0x6768, 0x4d3e, 0x7971, 0x6470,
265 0x5c78, 0x6765, 0xff63,
266 0xdbff, 0x4300, 0x1101, 0x1212, 0x1518, 0x2f18, 0x1a1a, 0x632f,
267 0x3842, 0x6342, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
268 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
269 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363, 0x6363,
270 0x6363, 0x6363, 0xff63,
273 0xdbff, 0x4300, 0x0d00, 0x0a09, 0x0a0b, 0x0d08, 0x0a0b, 0x0e0b,
274 0x0d0e, 0x130f, 0x1520, 0x1213, 0x1312, 0x1c27, 0x171e, 0x2e20,
275 0x3129, 0x2e30, 0x2d29, 0x332c, 0x4a3a, 0x333e, 0x4636, 0x2c37,
276 0x402d, 0x4157, 0x4c46, 0x524e, 0x5253, 0x3e32, 0x615a, 0x505a,
277 0x4a60, 0x5251, 0xff4f,
278 0xdbff, 0x4300, 0x0e01, 0x0e0e, 0x1113, 0x2613, 0x1515, 0x4f26,
279 0x2d35, 0x4f35, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
280 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
281 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f, 0x4f4f,
282 0x4f4f, 0x4f4f, 0xff4f,
285 0xdbff, 0x4300, 0x0a00, 0x0707, 0x0708, 0x0a06, 0x0808, 0x0b08,
286 0x0a0a, 0x0e0b, 0x1018, 0x0d0e, 0x0e0d, 0x151d, 0x1116, 0x2318,
287 0x251f, 0x2224, 0x221f, 0x2621, 0x372b, 0x262f, 0x3429, 0x2129,
288 0x3022, 0x3141, 0x3934, 0x3e3b, 0x3e3e, 0x2e25, 0x4944, 0x3c43,
289 0x3748, 0x3e3d, 0xff3b,
290 0xdbff, 0x4300, 0x0a01, 0x0b0b, 0x0d0e, 0x1c0e, 0x1010, 0x3b1c,
291 0x2228, 0x3b28, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
292 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
293 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b, 0x3b3b,
294 0x3b3b, 0x3b3b, 0xff3b,
297 0xdbff, 0x4300, 0x0600, 0x0504, 0x0506, 0x0604, 0x0506, 0x0706,
298 0x0607, 0x0a08, 0x0a10, 0x090a, 0x0a09, 0x0e14, 0x0c0f, 0x1710,
299 0x1814, 0x1718, 0x1614, 0x1a16, 0x251d, 0x1a1f, 0x231b, 0x161c,
300 0x2016, 0x202c, 0x2623, 0x2927, 0x292a, 0x1f19, 0x302d, 0x282d,
301 0x2530, 0x2928, 0xff28,
302 0xdbff, 0x4300, 0x0701, 0x0707, 0x080a, 0x130a, 0x0a0a, 0x2813,
303 0x161a, 0x281a, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
304 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
305 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828, 0x2828,
306 0x2828, 0x2828, 0xff28,
309 0xdbff, 0x4300, 0x0300, 0x0202, 0x0203, 0x0302, 0x0303, 0x0403,
310 0x0303, 0x0504, 0x0508, 0x0405, 0x0504, 0x070a, 0x0607, 0x0c08,
311 0x0c0a, 0x0b0c, 0x0b0a, 0x0d0b, 0x120e, 0x0d10, 0x110e, 0x0b0e,
312 0x100b, 0x1016, 0x1311, 0x1514, 0x1515, 0x0f0c, 0x1817, 0x1416,
313 0x1218, 0x1514, 0xff14,
314 0xdbff, 0x4300, 0x0301, 0x0404, 0x0405, 0x0905, 0x0505, 0x1409,
315 0x0b0d, 0x140d, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
316 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
317 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414, 0x1414,
318 0x1414, 0x1414, 0xff14,
321 0xdbff, 0x4300, 0x0100, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
322 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
323 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
324 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
325 0x0101, 0x0101, 0xff01,
326 0xdbff, 0x4300, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
327 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
328 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
329 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
330 0x0101, 0x0101, 0xff01,
333 if (quality < 0 || quality > 10) {
335 "meye: invalid quality level %d - using 8\n", quality);
339 *length = ARRAY_SIZE(jpeg_tables[quality]);
340 return jpeg_tables[quality];
343 /* return a generic set of huffman tables */
344 static u16 *jpeg_huffman_tables(int *length)
346 static u16 tables[] = {
347 0xC4FF, 0xB500, 0x0010, 0x0102, 0x0303, 0x0402, 0x0503, 0x0405,
348 0x0004, 0x0100, 0x017D, 0x0302, 0x0400, 0x0511, 0x2112, 0x4131,
349 0x1306, 0x6151, 0x2207, 0x1471, 0x8132, 0xA191, 0x2308, 0xB142,
350 0x15C1, 0xD152, 0x24F0, 0x6233, 0x8272, 0x0A09, 0x1716, 0x1918,
351 0x251A, 0x2726, 0x2928, 0x342A, 0x3635, 0x3837, 0x3A39, 0x4443,
352 0x4645, 0x4847, 0x4A49, 0x5453, 0x5655, 0x5857, 0x5A59, 0x6463,
353 0x6665, 0x6867, 0x6A69, 0x7473, 0x7675, 0x7877, 0x7A79, 0x8483,
354 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998, 0xA29A,
355 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6, 0xB9B8,
356 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4, 0xD7D6,
357 0xD9D8, 0xE1DA, 0xE3E2, 0xE5E4, 0xE7E6, 0xE9E8, 0xF1EA, 0xF3F2,
358 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
359 0xC4FF, 0xB500, 0x0011, 0x0102, 0x0402, 0x0304, 0x0704, 0x0405,
360 0x0004, 0x0201, 0x0077, 0x0201, 0x1103, 0x0504, 0x3121, 0x1206,
361 0x5141, 0x6107, 0x1371, 0x3222, 0x0881, 0x4214, 0xA191, 0xC1B1,
362 0x2309, 0x5233, 0x15F0, 0x7262, 0x0AD1, 0x2416, 0xE134, 0xF125,
363 0x1817, 0x1A19, 0x2726, 0x2928, 0x352A, 0x3736, 0x3938, 0x433A,
364 0x4544, 0x4746, 0x4948, 0x534A, 0x5554, 0x5756, 0x5958, 0x635A,
365 0x6564, 0x6766, 0x6968, 0x736A, 0x7574, 0x7776, 0x7978, 0x827A,
366 0x8483, 0x8685, 0x8887, 0x8A89, 0x9392, 0x9594, 0x9796, 0x9998,
367 0xA29A, 0xA4A3, 0xA6A5, 0xA8A7, 0xAAA9, 0xB3B2, 0xB5B4, 0xB7B6,
368 0xB9B8, 0xC2BA, 0xC4C3, 0xC6C5, 0xC8C7, 0xCAC9, 0xD3D2, 0xD5D4,
369 0xD7D6, 0xD9D8, 0xE2DA, 0xE4E3, 0xE6E5, 0xE8E7, 0xEAE9, 0xF3F2,
370 0xF5F4, 0xF7F6, 0xF9F8, 0xFFFA,
371 0xC4FF, 0x1F00, 0x0000, 0x0501, 0x0101, 0x0101, 0x0101, 0x0000,
372 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
374 0xC4FF, 0x1F00, 0x0001, 0x0103, 0x0101, 0x0101, 0x0101, 0x0101,
375 0x0000, 0x0000, 0x0000, 0x0201, 0x0403, 0x0605, 0x0807, 0x0A09,
379 *length = ARRAY_SIZE(tables);
383 /****************************************************************************/
384 /* MCHIP low-level functions */
385 /****************************************************************************/
387 /* returns the horizontal capture size */
388 static inline int mchip_hsize(void)
390 return meye.params.subsample ? 320 : 640;
393 /* returns the vertical capture size */
394 static inline int mchip_vsize(void)
396 return meye.params.subsample ? 240 : 480;
399 /* waits for a register to be available */
400 static void mchip_sync(int reg)
405 if (reg == MCHIP_MM_FIFO_DATA) {
406 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
407 status = readl(meye.mchip_mmregs +
408 MCHIP_MM_FIFO_STATUS);
409 if (!(status & MCHIP_MM_FIFO_WAIT)) {
410 printk(KERN_WARNING "meye: fifo not ready\n");
413 if (status & MCHIP_MM_FIFO_READY)
417 } else if (reg > 0x80) {
418 u32 mask = (reg < 0x100) ? MCHIP_HIC_STATUS_MCC_RDY
419 : MCHIP_HIC_STATUS_VRJ_RDY;
420 for (i = 0; i < MCHIP_REG_TIMEOUT; i++) {
421 status = readl(meye.mchip_mmregs + MCHIP_HIC_STATUS);
429 "meye: mchip_sync() timeout on reg 0x%x status=0x%x\n",
433 /* sets a value into the register */
434 static inline void mchip_set(int reg, u32 v)
437 writel(v, meye.mchip_mmregs + reg);
440 /* get the register value */
441 static inline u32 mchip_read(int reg)
444 return readl(meye.mchip_mmregs + reg);
447 /* wait for a register to become a particular value */
448 static inline int mchip_delay(u32 reg, u32 v)
451 while (--n && mchip_read(reg) != v)
456 /* setup subsampling */
457 static void mchip_subsample(void)
459 mchip_set(MCHIP_MCC_R_SAMPLING, meye.params.subsample);
460 mchip_set(MCHIP_MCC_R_XRANGE, mchip_hsize());
461 mchip_set(MCHIP_MCC_R_YRANGE, mchip_vsize());
462 mchip_set(MCHIP_MCC_B_XRANGE, mchip_hsize());
463 mchip_set(MCHIP_MCC_B_YRANGE, mchip_vsize());
464 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
467 /* set the framerate into the mchip */
468 static void mchip_set_framerate(void)
470 mchip_set(MCHIP_HIC_S_RATE, meye.params.framerate);
473 /* load some huffman and quantisation tables into the VRJ chip ready
474 for JPEG compression */
475 static void mchip_load_tables(void)
481 tables = jpeg_huffman_tables(&length);
482 for (i = 0; i < length; i++)
483 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
485 tables = jpeg_quantisation_tables(&length, meye.params.quality);
486 for (i = 0; i < length; i++)
487 writel(tables[i], meye.mchip_mmregs + MCHIP_VRJ_TABLE_DATA);
490 /* setup the VRJ parameters in the chip */
491 static void mchip_vrj_setup(u8 mode)
493 mchip_set(MCHIP_VRJ_BUS_MODE, 5);
494 mchip_set(MCHIP_VRJ_SIGNAL_ACTIVE_LEVEL, 0x1f);
495 mchip_set(MCHIP_VRJ_PDAT_USE, 1);
496 mchip_set(MCHIP_VRJ_IRQ_FLAG, 0xa0);
497 mchip_set(MCHIP_VRJ_MODE_SPECIFY, mode);
498 mchip_set(MCHIP_VRJ_NUM_LINES, mchip_vsize());
499 mchip_set(MCHIP_VRJ_NUM_PIXELS, mchip_hsize());
500 mchip_set(MCHIP_VRJ_NUM_COMPONENTS, 0x1b);
501 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_LO, 0xFFFF);
502 mchip_set(MCHIP_VRJ_LIMIT_COMPRESSED_HI, 0xFFFF);
503 mchip_set(MCHIP_VRJ_COMP_DATA_FORMAT, 0xC);
504 mchip_set(MCHIP_VRJ_RESTART_INTERVAL, 0);
505 mchip_set(MCHIP_VRJ_SOF1, 0x601);
506 mchip_set(MCHIP_VRJ_SOF2, 0x1502);
507 mchip_set(MCHIP_VRJ_SOF3, 0x1503);
508 mchip_set(MCHIP_VRJ_SOF4, 0x1596);
509 mchip_set(MCHIP_VRJ_SOS, 0x0ed0);
514 /* sets the DMA parameters into the chip */
515 static void mchip_dma_setup(dma_addr_t dma_addr)
519 mchip_set(MCHIP_MM_PT_ADDR, (u32)dma_addr);
520 for (i = 0; i < 4; i++)
521 mchip_set(MCHIP_MM_FIR(i), 0);
525 /* setup for DMA transfers - also zeros the framebuffer */
526 static int mchip_dma_alloc(void)
528 if (!meye.mchip_dmahandle)
534 /* frees the DMA buffer */
535 static void mchip_dma_free(void)
537 if (meye.mchip_dmahandle) {
543 /* stop any existing HIC action and wait for any dma to complete then
544 reset the dma engine */
545 static void mchip_hic_stop(void)
549 meye.mchip_mode = MCHIP_HIC_MODE_NOOP;
550 if (!(mchip_read(MCHIP_HIC_STATUS) & MCHIP_HIC_STATUS_BUSY))
552 for (i = 0; i < 20; ++i) {
553 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_STOP);
554 mchip_delay(MCHIP_HIC_CMD, 0);
555 for (j = 0; j < 100; ++j) {
556 if (mchip_delay(MCHIP_HIC_STATUS,
557 MCHIP_HIC_STATUS_IDLE))
561 printk(KERN_ERR "meye: need to reset HIC!\n");
563 mchip_set(MCHIP_HIC_CTL, MCHIP_HIC_CTL_SOFT_RESET);
566 printk(KERN_ERR "meye: resetting HIC hanged!\n");
569 /****************************************************************************/
570 /* MCHIP frame processing functions */
571 /****************************************************************************/
573 /* get the next ready frame from the dma engine */
574 static u32 mchip_get_frame(void)
576 return mchip_read(MCHIP_MM_FIR(meye.mchip_fnum));
579 /* frees the current frame from the dma engine */
580 static void mchip_free_frame(void)
582 mchip_set(MCHIP_MM_FIR(meye.mchip_fnum), 0);
584 meye.mchip_fnum %= 4;
587 /* read one frame from the framebuffer assuming it was captured using
588 a uncompressed transfer */
589 static void mchip_cont_read_frame(u32 v, u8 *buf, int size)
593 pt_id = (v >> 17) & 0x3FF;
595 ptable_copy(buf, pt_id, size, MCHIP_NB_PAGES);
598 /* read a compressed frame from the framebuffer */
599 static int mchip_comp_read_frame(u32 v, u8 *buf, int size)
601 int pt_start, pt_end, trailer;
605 pt_start = (v >> 19) & 0xFF;
606 pt_end = (v >> 11) & 0xFF;
607 trailer = (v >> 1) & 0x3FF;
609 if (pt_end < pt_start)
610 fsize = (MCHIP_NB_PAGES_MJPEG - pt_start) * PAGE_SIZE +
611 pt_end * PAGE_SIZE + trailer * 4;
613 fsize = (pt_end - pt_start) * PAGE_SIZE + trailer * 4;
616 printk(KERN_WARNING "meye: oversized compressed frame %d\n",
621 ptable_copy(buf, pt_start, fsize, MCHIP_NB_PAGES_MJPEG);
623 #ifdef MEYE_JPEG_CORRECTION
625 /* Some mchip generated jpeg frames are incorrect. In most
626 * (all ?) of those cases, the final EOI (0xff 0xd9) marker
627 * is not present at the end of the frame.
629 * Since adding the final marker is not enough to restore
630 * the jpeg integrity, we drop the frame.
633 for (i = fsize - 1; i > 0 && buf[i] == 0xff; i--) ;
635 if (i < 2 || buf[i - 1] != 0xff || buf[i] != 0xd9)
643 /* take a picture into SDRAM */
644 static void mchip_take_picture(void)
650 mchip_dma_setup(meye.mchip_dmahandle);
652 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_CAP);
653 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
655 mchip_delay(MCHIP_HIC_CMD, 0);
657 for (i = 0; i < 100; ++i) {
658 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
664 /* dma a previously taken picture into a buffer */
665 static void mchip_get_picture(u8 *buf, int bufsize)
670 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_OUT);
671 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
673 mchip_delay(MCHIP_HIC_CMD, 0);
674 for (i = 0; i < 100; ++i) {
675 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
679 for (i = 0; i < 4; ++i) {
680 v = mchip_get_frame();
681 if (v & MCHIP_MM_FIR_RDY) {
682 mchip_cont_read_frame(v, buf, bufsize);
689 /* start continuous dma capture */
690 static void mchip_continuous_start(void)
694 mchip_set_framerate();
695 mchip_dma_setup(meye.mchip_dmahandle);
697 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
699 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_OUT);
700 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
702 mchip_delay(MCHIP_HIC_CMD, 0);
705 /* compress one frame into a buffer */
706 static int mchip_compress_frame(u8 *buf, int bufsize)
711 mchip_vrj_setup(0x3f);
714 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_COMP);
715 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
717 mchip_delay(MCHIP_HIC_CMD, 0);
718 for (i = 0; i < 100; ++i) {
719 if (mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE))
724 for (i = 0; i < 4; ++i) {
725 v = mchip_get_frame();
726 if (v & MCHIP_MM_FIR_RDY) {
727 len = mchip_comp_read_frame(v, buf, bufsize);
736 /* uncompress one image into a buffer */
737 static int mchip_uncompress_frame(u8 *img, int imgsize, u8 *buf, int bufsize)
739 mchip_vrj_setup(0x3f);
742 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_STILL_DECOMP);
743 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
745 mchip_delay(MCHIP_HIC_CMD, 0);
747 return mchip_comp_read_frame(buf, bufsize);
751 /* start continuous compressed capture */
752 static void mchip_cont_compression_start(void)
755 mchip_vrj_setup(0x3f);
757 mchip_set_framerate();
758 mchip_dma_setup(meye.mchip_dmahandle);
760 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
762 mchip_set(MCHIP_HIC_MODE, MCHIP_HIC_MODE_CONT_COMP);
763 mchip_set(MCHIP_HIC_CMD, MCHIP_HIC_CMD_START);
765 mchip_delay(MCHIP_HIC_CMD, 0);
768 /****************************************************************************/
769 /* Interrupt handling */
770 /****************************************************************************/
772 static irqreturn_t meye_irq(int irq, void *dev_id)
778 v = mchip_read(MCHIP_MM_INTA);
780 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_OUT &&
781 meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
785 v = mchip_get_frame();
786 if (!(v & MCHIP_MM_FIR_RDY))
789 if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
790 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
791 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
795 mchip_cont_read_frame(v, meye.grab_fbuffer + gbufsize * reqnr,
796 mchip_hsize() * mchip_vsize() * 2);
797 meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
798 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
799 meye.grab_buffer[reqnr].ts = ktime_get_ns();
800 meye.grab_buffer[reqnr].sequence = sequence++;
801 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
802 sizeof(int), &meye.doneq_lock);
803 wake_up_interruptible(&meye.proc_list);
806 size = mchip_comp_read_frame(v, meye.grab_temp, gbufsize);
811 if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
812 sizeof(int), &meye.grabq_lock) != sizeof(int)) {
816 memcpy(meye.grab_fbuffer + gbufsize * reqnr, meye.grab_temp,
818 meye.grab_buffer[reqnr].size = size;
819 meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
820 meye.grab_buffer[reqnr].ts = ktime_get_ns();
821 meye.grab_buffer[reqnr].sequence = sequence++;
822 kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
823 sizeof(int), &meye.doneq_lock);
824 wake_up_interruptible(&meye.proc_list);
830 /****************************************************************************/
831 /* video4linux integration */
832 /****************************************************************************/
834 static int meye_open(struct file *file)
838 if (test_and_set_bit(0, &meye.in_use))
843 if (mchip_dma_alloc()) {
844 printk(KERN_ERR "meye: mchip framebuffer allocation failed\n");
845 clear_bit(0, &meye.in_use);
849 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
850 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
851 kfifo_reset(&meye.grabq);
852 kfifo_reset(&meye.doneq);
853 return v4l2_fh_open(file);
856 static int meye_release(struct file *file)
860 clear_bit(0, &meye.in_use);
861 return v4l2_fh_release(file);
864 static int meyeioc_g_params(struct meye_params *p)
870 static int meyeioc_s_params(struct meye_params *jp)
872 if (jp->subsample > 1)
875 if (jp->quality > 10)
878 if (jp->sharpness > 63 || jp->agc > 63 || jp->picture > 63)
881 if (jp->framerate > 31)
884 mutex_lock(&meye.lock);
886 if (meye.params.subsample != jp->subsample ||
887 meye.params.quality != jp->quality)
888 mchip_hic_stop(); /* need restart */
891 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS,
892 meye.params.sharpness);
893 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC,
895 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE,
896 meye.params.picture);
897 mutex_unlock(&meye.lock);
902 static int meyeioc_qbuf_capt(int *nb)
904 if (!meye.grab_fbuffer)
916 if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
919 mutex_lock(&meye.lock);
921 if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
922 mchip_cont_compression_start();
924 meye.grab_buffer[*nb].state = MEYE_BUF_USING;
925 kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
927 mutex_unlock(&meye.lock);
932 static int meyeioc_sync(struct file *file, void *fh, int *i)
936 if (*i < 0 || *i >= gbuffers)
939 mutex_lock(&meye.lock);
940 switch (meye.grab_buffer[*i].state) {
942 case MEYE_BUF_UNUSED:
943 mutex_unlock(&meye.lock);
946 if (file->f_flags & O_NONBLOCK) {
947 mutex_unlock(&meye.lock);
950 if (wait_event_interruptible(meye.proc_list,
951 (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
952 mutex_unlock(&meye.lock);
957 meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
958 if (kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
959 sizeof(int), &meye.doneq_lock) != sizeof(int))
962 *i = meye.grab_buffer[*i].size;
963 mutex_unlock(&meye.lock);
967 static int meyeioc_stillcapt(void)
969 if (!meye.grab_fbuffer)
972 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
975 mutex_lock(&meye.lock);
976 meye.grab_buffer[0].state = MEYE_BUF_USING;
977 mchip_take_picture();
979 mchip_get_picture(meye.grab_fbuffer,
980 mchip_hsize() * mchip_vsize() * 2);
982 meye.grab_buffer[0].state = MEYE_BUF_DONE;
983 mutex_unlock(&meye.lock);
988 static int meyeioc_stilljcapt(int *len)
990 if (!meye.grab_fbuffer)
993 if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
996 mutex_lock(&meye.lock);
997 meye.grab_buffer[0].state = MEYE_BUF_USING;
1000 while (*len == -1) {
1001 mchip_take_picture();
1002 *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
1005 meye.grab_buffer[0].state = MEYE_BUF_DONE;
1006 mutex_unlock(&meye.lock);
1010 static int vidioc_querycap(struct file *file, void *fh,
1011 struct v4l2_capability *cap)
1013 strscpy(cap->driver, "meye", sizeof(cap->driver));
1014 strscpy(cap->card, "meye", sizeof(cap->card));
1018 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1023 strscpy(i->name, "Camera", sizeof(i->name));
1024 i->type = V4L2_INPUT_TYPE_CAMERA;
1029 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1035 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1043 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1045 mutex_lock(&meye.lock);
1047 case V4L2_CID_BRIGHTNESS:
1048 sony_pic_camera_command(
1049 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1050 meye.brightness = ctrl->val << 10;
1053 sony_pic_camera_command(
1054 SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1055 meye.hue = ctrl->val << 10;
1057 case V4L2_CID_CONTRAST:
1058 sony_pic_camera_command(
1059 SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1060 meye.contrast = ctrl->val << 10;
1062 case V4L2_CID_SATURATION:
1063 sony_pic_camera_command(
1064 SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1065 meye.colour = ctrl->val << 10;
1067 case V4L2_CID_MEYE_AGC:
1068 sony_pic_camera_command(
1069 SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1070 meye.params.agc = ctrl->val;
1072 case V4L2_CID_SHARPNESS:
1073 sony_pic_camera_command(
1074 SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1075 meye.params.sharpness = ctrl->val;
1077 case V4L2_CID_MEYE_PICTURE:
1078 sony_pic_camera_command(
1079 SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1080 meye.params.picture = ctrl->val;
1082 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1083 meye.params.quality = ctrl->val;
1085 case V4L2_CID_MEYE_FRAMERATE:
1086 meye.params.framerate = ctrl->val;
1089 mutex_unlock(&meye.lock);
1092 mutex_unlock(&meye.lock);
1097 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1098 struct v4l2_fmtdesc *f)
1103 if (f->index == 0) {
1104 /* standard YUV 422 capture */
1106 f->pixelformat = V4L2_PIX_FMT_YUYV;
1108 /* compressed MJPEG capture */
1109 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1115 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1116 struct v4l2_format *f)
1118 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1119 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1122 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1123 f->fmt.pix.field != V4L2_FIELD_NONE)
1126 f->fmt.pix.field = V4L2_FIELD_NONE;
1128 if (f->fmt.pix.width <= 320) {
1129 f->fmt.pix.width = 320;
1130 f->fmt.pix.height = 240;
1132 f->fmt.pix.width = 640;
1133 f->fmt.pix.height = 480;
1136 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1137 f->fmt.pix.sizeimage = f->fmt.pix.height *
1138 f->fmt.pix.bytesperline;
1139 f->fmt.pix.colorspace = 0;
1144 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1145 struct v4l2_format *f)
1147 switch (meye.mchip_mode) {
1148 case MCHIP_HIC_MODE_CONT_OUT:
1150 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1152 case MCHIP_HIC_MODE_CONT_COMP:
1153 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1157 f->fmt.pix.field = V4L2_FIELD_NONE;
1158 f->fmt.pix.width = mchip_hsize();
1159 f->fmt.pix.height = mchip_vsize();
1160 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1161 f->fmt.pix.sizeimage = f->fmt.pix.height *
1162 f->fmt.pix.bytesperline;
1167 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1168 struct v4l2_format *f)
1170 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1171 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1174 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1175 f->fmt.pix.field != V4L2_FIELD_NONE)
1178 f->fmt.pix.field = V4L2_FIELD_NONE;
1179 mutex_lock(&meye.lock);
1181 if (f->fmt.pix.width <= 320) {
1182 f->fmt.pix.width = 320;
1183 f->fmt.pix.height = 240;
1184 meye.params.subsample = 1;
1186 f->fmt.pix.width = 640;
1187 f->fmt.pix.height = 480;
1188 meye.params.subsample = 0;
1191 switch (f->fmt.pix.pixelformat) {
1192 case V4L2_PIX_FMT_YUYV:
1193 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1195 case V4L2_PIX_FMT_MJPEG:
1196 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1200 mutex_unlock(&meye.lock);
1201 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1202 f->fmt.pix.sizeimage = f->fmt.pix.height *
1203 f->fmt.pix.bytesperline;
1204 f->fmt.pix.colorspace = 0;
1209 static int vidioc_reqbufs(struct file *file, void *fh,
1210 struct v4l2_requestbuffers *req)
1214 if (req->memory != V4L2_MEMORY_MMAP)
1217 if (meye.grab_fbuffer && req->count == gbuffers) {
1218 /* already allocated, no modifications */
1222 mutex_lock(&meye.lock);
1223 if (meye.grab_fbuffer) {
1224 for (i = 0; i < gbuffers; i++)
1225 if (meye.vma_use_count[i]) {
1226 mutex_unlock(&meye.lock);
1229 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1230 meye.grab_fbuffer = NULL;
1233 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1234 req->count = gbuffers;
1235 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1237 if (!meye.grab_fbuffer) {
1238 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1239 mutex_unlock(&meye.lock);
1243 for (i = 0; i < gbuffers; i++)
1244 meye.vma_use_count[i] = 0;
1246 mutex_unlock(&meye.lock);
1251 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1253 unsigned int index = buf->index;
1255 if (index >= gbuffers)
1258 buf->bytesused = meye.grab_buffer[index].size;
1259 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1261 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1262 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1264 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1265 buf->flags |= V4L2_BUF_FLAG_DONE;
1267 buf->field = V4L2_FIELD_NONE;
1268 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[index].ts);
1269 buf->sequence = meye.grab_buffer[index].sequence;
1270 buf->memory = V4L2_MEMORY_MMAP;
1271 buf->m.offset = index * gbufsize;
1272 buf->length = gbufsize;
1277 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1279 if (buf->memory != V4L2_MEMORY_MMAP)
1282 if (buf->index >= gbuffers)
1285 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1288 mutex_lock(&meye.lock);
1289 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1290 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1291 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1292 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1293 sizeof(int), &meye.grabq_lock);
1294 mutex_unlock(&meye.lock);
1299 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1303 if (buf->memory != V4L2_MEMORY_MMAP)
1306 mutex_lock(&meye.lock);
1308 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1309 mutex_unlock(&meye.lock);
1313 if (wait_event_interruptible(meye.proc_list,
1314 kfifo_len(&meye.doneq) != 0) < 0) {
1315 mutex_unlock(&meye.lock);
1319 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1320 sizeof(int), &meye.doneq_lock)) {
1321 mutex_unlock(&meye.lock);
1325 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1326 mutex_unlock(&meye.lock);
1331 buf->bytesused = meye.grab_buffer[reqnr].size;
1332 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1333 buf->field = V4L2_FIELD_NONE;
1334 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[reqnr].ts);
1335 buf->sequence = meye.grab_buffer[reqnr].sequence;
1336 buf->memory = V4L2_MEMORY_MMAP;
1337 buf->m.offset = reqnr * gbufsize;
1338 buf->length = gbufsize;
1339 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1340 mutex_unlock(&meye.lock);
1345 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1347 mutex_lock(&meye.lock);
1349 switch (meye.mchip_mode) {
1350 case MCHIP_HIC_MODE_CONT_OUT:
1351 mchip_continuous_start();
1353 case MCHIP_HIC_MODE_CONT_COMP:
1354 mchip_cont_compression_start();
1357 mutex_unlock(&meye.lock);
1361 mutex_unlock(&meye.lock);
1366 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1368 mutex_lock(&meye.lock);
1370 kfifo_reset(&meye.grabq);
1371 kfifo_reset(&meye.doneq);
1373 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1374 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1376 mutex_unlock(&meye.lock);
1380 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1381 unsigned int cmd, void *arg)
1384 case MEYEIOC_G_PARAMS:
1385 return meyeioc_g_params((struct meye_params *) arg);
1387 case MEYEIOC_S_PARAMS:
1388 return meyeioc_s_params((struct meye_params *) arg);
1390 case MEYEIOC_QBUF_CAPT:
1391 return meyeioc_qbuf_capt((int *) arg);
1394 return meyeioc_sync(file, fh, (int *) arg);
1396 case MEYEIOC_STILLCAPT:
1397 return meyeioc_stillcapt();
1399 case MEYEIOC_STILLJCAPT:
1400 return meyeioc_stilljcapt((int *) arg);
1408 static __poll_t meye_poll(struct file *file, poll_table *wait)
1410 __poll_t res = v4l2_ctrl_poll(file, wait);
1412 mutex_lock(&meye.lock);
1413 poll_wait(file, &meye.proc_list, wait);
1414 if (kfifo_len(&meye.doneq))
1415 res |= EPOLLIN | EPOLLRDNORM;
1416 mutex_unlock(&meye.lock);
1420 static void meye_vm_open(struct vm_area_struct *vma)
1422 long idx = (long)vma->vm_private_data;
1423 meye.vma_use_count[idx]++;
1426 static void meye_vm_close(struct vm_area_struct *vma)
1428 long idx = (long)vma->vm_private_data;
1429 meye.vma_use_count[idx]--;
1432 static const struct vm_operations_struct meye_vm_ops = {
1433 .open = meye_vm_open,
1434 .close = meye_vm_close,
1437 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1439 unsigned long start = vma->vm_start;
1440 unsigned long size = vma->vm_end - vma->vm_start;
1441 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1442 unsigned long page, pos;
1444 mutex_lock(&meye.lock);
1445 if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
1446 mutex_unlock(&meye.lock);
1449 if (!meye.grab_fbuffer) {
1452 /* lazy allocation */
1453 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1454 if (!meye.grab_fbuffer) {
1455 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1456 mutex_unlock(&meye.lock);
1459 for (i = 0; i < gbuffers; i++)
1460 meye.vma_use_count[i] = 0;
1462 pos = (unsigned long)meye.grab_fbuffer + offset;
1465 page = vmalloc_to_pfn((void *)pos);
1466 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1467 mutex_unlock(&meye.lock);
1472 if (size > PAGE_SIZE)
1478 vma->vm_ops = &meye_vm_ops;
1479 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1480 vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
1481 vma->vm_private_data = (void *) (offset / gbufsize);
1484 mutex_unlock(&meye.lock);
1488 static const struct v4l2_file_operations meye_fops = {
1489 .owner = THIS_MODULE,
1491 .release = meye_release,
1493 .unlocked_ioctl = video_ioctl2,
1497 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1498 .vidioc_querycap = vidioc_querycap,
1499 .vidioc_enum_input = vidioc_enum_input,
1500 .vidioc_g_input = vidioc_g_input,
1501 .vidioc_s_input = vidioc_s_input,
1502 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1503 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1504 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1505 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1506 .vidioc_reqbufs = vidioc_reqbufs,
1507 .vidioc_querybuf = vidioc_querybuf,
1508 .vidioc_qbuf = vidioc_qbuf,
1509 .vidioc_dqbuf = vidioc_dqbuf,
1510 .vidioc_streamon = vidioc_streamon,
1511 .vidioc_streamoff = vidioc_streamoff,
1512 .vidioc_log_status = v4l2_ctrl_log_status,
1513 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1514 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1515 .vidioc_default = vidioc_default,
1518 static const struct video_device meye_template = {
1521 .ioctl_ops = &meye_ioctl_ops,
1522 .release = video_device_release_empty,
1523 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
1526 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1527 .s_ctrl = meye_s_ctrl,
1530 static int __maybe_unused meye_suspend(struct device *dev)
1532 meye.pm_mchip_mode = meye.mchip_mode;
1534 mchip_set(MCHIP_MM_INTA, 0x0);
1538 static int __maybe_unused meye_resume(struct device *dev)
1540 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1542 mchip_delay(MCHIP_HIC_CMD, 0);
1543 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1545 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1547 mchip_set(MCHIP_MM_PCI_MODE, 5);
1549 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1551 switch (meye.pm_mchip_mode) {
1552 case MCHIP_HIC_MODE_CONT_OUT:
1553 mchip_continuous_start();
1555 case MCHIP_HIC_MODE_CONT_COMP:
1556 mchip_cont_compression_start();
1562 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1564 static const struct v4l2_ctrl_config ctrl_agc = {
1565 .id = V4L2_CID_MEYE_AGC,
1566 .type = V4L2_CTRL_TYPE_INTEGER,
1567 .ops = &meye_ctrl_ops,
1572 .flags = V4L2_CTRL_FLAG_SLIDER,
1574 static const struct v4l2_ctrl_config ctrl_picture = {
1575 .id = V4L2_CID_MEYE_PICTURE,
1576 .type = V4L2_CTRL_TYPE_INTEGER,
1577 .ops = &meye_ctrl_ops,
1582 static const struct v4l2_ctrl_config ctrl_framerate = {
1583 .id = V4L2_CID_MEYE_FRAMERATE,
1584 .type = V4L2_CTRL_TYPE_INTEGER,
1585 .ops = &meye_ctrl_ops,
1586 .name = "Framerate",
1590 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1592 unsigned long mchip_adr;
1594 if (meye.mchip_dev != NULL) {
1595 printk(KERN_ERR "meye: only one device allowed!\n");
1599 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1601 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1605 meye.mchip_dev = pcidev;
1607 meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
1608 if (!meye.grab_temp)
1611 spin_lock_init(&meye.grabq_lock);
1612 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1614 goto outkfifoalloc1;
1616 spin_lock_init(&meye.doneq_lock);
1617 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1619 goto outkfifoalloc2;
1621 meye.vdev = meye_template;
1622 meye.vdev.v4l2_dev = &meye.v4l2_dev;
1624 ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1626 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1627 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1628 goto outsonypienable;
1631 ret = pci_enable_device(meye.mchip_dev);
1633 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1638 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1640 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1643 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1644 pci_resource_len(meye.mchip_dev, 0),
1646 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1649 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1650 if (!meye.mchip_mmregs) {
1651 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1655 meye.mchip_irq = pcidev->irq;
1656 if (request_irq(meye.mchip_irq, meye_irq,
1657 IRQF_SHARED, "meye", meye_irq)) {
1658 v4l2_err(v4l2_dev, "request_irq failed\n");
1662 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1663 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1665 pci_set_master(meye.mchip_dev);
1667 /* Ask the camera to perform a soft reset. */
1668 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1670 mchip_delay(MCHIP_HIC_CMD, 0);
1671 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1674 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1677 mchip_set(MCHIP_MM_PCI_MODE, 5);
1680 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1682 mutex_init(&meye.lock);
1683 init_waitqueue_head(&meye.proc_list);
1685 v4l2_ctrl_handler_init(&meye.hdl, 3);
1686 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1687 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1688 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1689 V4L2_CID_HUE, 0, 63, 1, 32);
1690 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1691 V4L2_CID_CONTRAST, 0, 63, 1, 32);
1692 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1693 V4L2_CID_SATURATION, 0, 63, 1, 32);
1694 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1695 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1696 V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1697 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1698 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1699 V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1700 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1701 if (meye.hdl.error) {
1702 v4l2_err(v4l2_dev, "couldn't register controls\n");
1706 v4l2_ctrl_handler_setup(&meye.hdl);
1707 meye.vdev.ctrl_handler = &meye.hdl;
1709 if (video_register_device(&meye.vdev, VFL_TYPE_VIDEO,
1711 v4l2_err(v4l2_dev, "video_register_device failed\n");
1715 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1716 MEYE_DRIVER_VERSION);
1717 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1718 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1723 v4l2_ctrl_handler_free(&meye.hdl);
1724 free_irq(meye.mchip_irq, meye_irq);
1726 iounmap(meye.mchip_mmregs);
1728 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1729 pci_resource_len(meye.mchip_dev, 0));
1731 pci_disable_device(meye.mchip_dev);
1733 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1735 kfifo_free(&meye.doneq);
1737 kfifo_free(&meye.grabq);
1739 vfree(meye.grab_temp);
1744 static void meye_remove(struct pci_dev *pcidev)
1746 video_unregister_device(&meye.vdev);
1752 /* disable interrupts */
1753 mchip_set(MCHIP_MM_INTA, 0x0);
1755 free_irq(meye.mchip_irq, meye_irq);
1757 iounmap(meye.mchip_mmregs);
1759 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1760 pci_resource_len(meye.mchip_dev, 0));
1762 pci_disable_device(meye.mchip_dev);
1764 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1766 kfifo_free(&meye.doneq);
1767 kfifo_free(&meye.grabq);
1769 vfree(meye.grab_temp);
1771 if (meye.grab_fbuffer) {
1772 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1773 meye.grab_fbuffer = NULL;
1776 printk(KERN_INFO "meye: removed\n");
1779 static const struct pci_device_id meye_pci_tbl[] = {
1780 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1784 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1786 static SIMPLE_DEV_PM_OPS(meye_pm_ops, meye_suspend, meye_resume);
1788 static struct pci_driver meye_driver = {
1790 .id_table = meye_pci_tbl,
1791 .probe = meye_probe,
1792 .remove = meye_remove,
1793 .driver.pm = &meye_pm_ops,
1796 static int __init meye_init(void)
1798 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1799 if (gbufsize > MEYE_MAX_BUFSIZE)
1800 gbufsize = MEYE_MAX_BUFSIZE;
1801 gbufsize = PAGE_ALIGN(gbufsize);
1802 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1804 gbufsize / 1024, gbuffers * gbufsize / 1024);
1805 return pci_register_driver(&meye_driver);
1808 static void __exit meye_exit(void)
1810 pci_unregister_driver(&meye_driver);
1813 module_init(meye_init);
1814 module_exit(meye_exit);