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