?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
get_signal_to_deliver: use the cached ->signal/sighand values
[linux-2.6/mini2440.git] / drivers / media / video / meye.c
blobe7ccbc895d7abe4fc37b84ae805d6d504d37dbde
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_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_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_cap(struct file *file, void *fh, struct v4l2_format *f)
1320 {
1321 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1322 return -EINVAL;
1323
1324 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
1325 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1326
1327 switch (meye.mchip_mode) {
1328 case MCHIP_HIC_MODE_CONT_OUT:
1329 default:
1330 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1331 break;
1332 case MCHIP_HIC_MODE_CONT_COMP:
1333 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1334 break;
1335 }
1336
1337 f->fmt.pix.field = V4L2_FIELD_NONE;
1338 f->fmt.pix.width = mchip_hsize();
1339 f->fmt.pix.height = mchip_vsize();
1340 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1341 f->fmt.pix.sizeimage = f->fmt.pix.height *
1342 f->fmt.pix.bytesperline;
1343 f->fmt.pix.colorspace = 0;
1344 f->fmt.pix.priv = 0;
1345
1346 return 0;
1347 }
1348
1349 static int vidioc_s_fmt_cap(struct file *file, void *fh, struct v4l2_format *f)
1350 {
1351 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1352 return -EINVAL;
1353
1354 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1355 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1356 return -EINVAL;
1357
1358 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1359 f->fmt.pix.field != V4L2_FIELD_NONE)
1360 return -EINVAL;
1361
1362 f->fmt.pix.field = V4L2_FIELD_NONE;
1363 mutex_lock(&meye.lock);
1364
1365 if (f->fmt.pix.width <= 320) {
1366 f->fmt.pix.width = 320;
1367 f->fmt.pix.height = 240;
1368 meye.params.subsample = 1;
1369 } else {
1370 f->fmt.pix.width = 640;
1371 f->fmt.pix.height = 480;
1372 meye.params.subsample = 0;
1373 }
1374
1375 switch (f->fmt.pix.pixelformat) {
1376 case V4L2_PIX_FMT_YUYV:
1377 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1378 break;
1379 case V4L2_PIX_FMT_MJPEG:
1380 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1381 break;
1382 }
1383
1384 mutex_unlock(&meye.lock);
1385 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1386 f->fmt.pix.sizeimage = f->fmt.pix.height *
1387 f->fmt.pix.bytesperline;
1388 f->fmt.pix.colorspace = 0;
1389 f->fmt.pix.priv = 0;
1390
1391 return 0;
1392 }
1393
1394 static int vidioc_reqbufs(struct file *file, void *fh,
1395 struct v4l2_requestbuffers *req)
1396 {
1397 int i;
1398
1399 if (req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1400 return -EINVAL;
1401
1402 if (req->memory != V4L2_MEMORY_MMAP)
1403 return -EINVAL;
1404
1405 if (meye.grab_fbuffer && req->count == gbuffers) {
1406 /* already allocated, no modifications */
1407 return 0;
1408 }
1409
1410 mutex_lock(&meye.lock);
1411 if (meye.grab_fbuffer) {
1412 for (i = 0; i < gbuffers; i++)
1413 if (meye.vma_use_count[i]) {
1414 mutex_unlock(&meye.lock);
1415 return -EINVAL;
1416 }
1417 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1418 meye.grab_fbuffer = NULL;
1419 }
1420
1421 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1422 req->count = gbuffers;
1423 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1424
1425 if (!meye.grab_fbuffer) {
1426 printk(KERN_ERR "meye: v4l framebuffer allocation"
1427 " failed\n");
1428 mutex_unlock(&meye.lock);
1429 return -ENOMEM;
1430 }
1431
1432 for (i = 0; i < gbuffers; i++)
1433 meye.vma_use_count[i] = 0;
1434
1435 mutex_unlock(&meye.lock);
1436
1437 return 0;
1438 }
1439
1440 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1441 {
1442 int index = buf->index;
1443
1444 if (index < 0 || index >= gbuffers)
1445 return -EINVAL;
1446
1447 memset(buf, 0, sizeof(*buf));
1448
1449 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1450 buf->index = index;
1451 buf->bytesused = meye.grab_buffer[index].size;
1452 buf->flags = V4L2_BUF_FLAG_MAPPED;
1453
1454 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1455 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1456
1457 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1458 buf->flags |= V4L2_BUF_FLAG_DONE;
1459
1460 buf->field = V4L2_FIELD_NONE;
1461 buf->timestamp = meye.grab_buffer[index].timestamp;
1462 buf->sequence = meye.grab_buffer[index].sequence;
1463 buf->memory = V4L2_MEMORY_MMAP;
1464 buf->m.offset = index * gbufsize;
1465 buf->length = gbufsize;
1466
1467 return 0;
1468 }
1469
1470 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1471 {
1472 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1473 return -EINVAL;
1474
1475 if (buf->memory != V4L2_MEMORY_MMAP)
1476 return -EINVAL;
1477
1478 if (buf->index < 0 || buf->index >= gbuffers)
1479 return -EINVAL;
1480
1481 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1482 return -EINVAL;
1483
1484 mutex_lock(&meye.lock);
1485 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1486 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1487 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1488 kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
1489 mutex_unlock(&meye.lock);
1490
1491 return 0;
1492 }
1493
1494 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1495 {
1496 int reqnr;
1497
1498 if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1499 return -EINVAL;
1500
1501 if (buf->memory != V4L2_MEMORY_MMAP)
1502 return -EINVAL;
1503
1504 mutex_lock(&meye.lock);
1505
1506 if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1507 mutex_unlock(&meye.lock);
1508 return -EAGAIN;
1509 }
1510
1511 if (wait_event_interruptible(meye.proc_list,
1512 kfifo_len(meye.doneq) != 0) < 0) {
1513 mutex_unlock(&meye.lock);
1514 return -EINTR;
1515 }
1516
1517 if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
1518 sizeof(int))) {
1519 mutex_unlock(&meye.lock);
1520 return -EBUSY;
1521 }
1522
1523 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1524 mutex_unlock(&meye.lock);
1525 return -EINVAL;
1526 }
1527
1528 buf->index = reqnr;
1529 buf->bytesused = meye.grab_buffer[reqnr].size;
1530 buf->flags = V4L2_BUF_FLAG_MAPPED;
1531 buf->field = V4L2_FIELD_NONE;
1532 buf->timestamp = meye.grab_buffer[reqnr].timestamp;
1533 buf->sequence = meye.grab_buffer[reqnr].sequence;
1534 buf->memory = V4L2_MEMORY_MMAP;
1535 buf->m.offset = reqnr * gbufsize;
1536 buf->length = gbufsize;
1537 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1538 mutex_unlock(&meye.lock);
1539
1540 return 0;
1541 }
1542
1543 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1544 {
1545 mutex_lock(&meye.lock);
1546
1547 switch (meye.mchip_mode) {
1548 case MCHIP_HIC_MODE_CONT_OUT:
1549 mchip_continuous_start();
1550 break;
1551 case MCHIP_HIC_MODE_CONT_COMP:
1552 mchip_cont_compression_start();
1553 break;
1554 default:
1555 mutex_unlock(&meye.lock);
1556 return -EINVAL;
1557 }
1558
1559 mutex_unlock(&meye.lock);
1560
1561 return 0;
1562 }
1563
1564 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1565 {
1566 mutex_lock(&meye.lock);
1567 mchip_hic_stop();
1568 kfifo_reset(meye.grabq);
1569 kfifo_reset(meye.doneq);
1570
1571 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1572 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1573
1574 mutex_unlock(&meye.lock);
1575 return 0;
1576 }
1577
1578 static int vidioc_default(struct file *file, void *fh, int cmd, void *arg)
1579 {
1580 switch (cmd) {
1581 case MEYEIOC_G_PARAMS:
1582 return meyeioc_g_params((struct meye_params *) arg);
1583
1584 case MEYEIOC_S_PARAMS:
1585 return meyeioc_s_params((struct meye_params *) arg);
1586
1587 case MEYEIOC_QBUF_CAPT:
1588 return meyeioc_qbuf_capt((int *) arg);
1589
1590 case MEYEIOC_SYNC:
1591 return meyeioc_sync(file, fh, (int *) arg);
1592
1593 case MEYEIOC_STILLCAPT:
1594 return meyeioc_stillcapt();
1595
1596 case MEYEIOC_STILLJCAPT:
1597 return meyeioc_stilljcapt((int *) arg);
1598
1599 default:
1600 return -EINVAL;
1601 }
1602
1603 }
1604
1605 static unsigned int meye_poll(struct file *file, poll_table *wait)
1606 {
1607 unsigned int res = 0;
1608
1609 mutex_lock(&meye.lock);
1610 poll_wait(file, &meye.proc_list, wait);
1611 if (kfifo_len(meye.doneq))
1612 res = POLLIN | POLLRDNORM;
1613 mutex_unlock(&meye.lock);
1614 return res;
1615 }
1616
1617 static void meye_vm_open(struct vm_area_struct *vma)
1618 {
1619 long idx = (long)vma->vm_private_data;
1620 meye.vma_use_count[idx]++;
1621 }
1622
1623 static void meye_vm_close(struct vm_area_struct *vma)
1624 {
1625 long idx = (long)vma->vm_private_data;
1626 meye.vma_use_count[idx]--;
1627 }
1628
1629 static struct vm_operations_struct meye_vm_ops = {
1630 .open = meye_vm_open,
1631 .close = meye_vm_close,
1632 };
1633
1634 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1635 {
1636 unsigned long start = vma->vm_start;
1637 unsigned long size = vma->vm_end - vma->vm_start;
1638 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1639 unsigned long page, pos;
1640
1641 mutex_lock(&meye.lock);
1642 if (size > gbuffers * gbufsize) {
1643 mutex_unlock(&meye.lock);
1644 return -EINVAL;
1645 }
1646 if (!meye.grab_fbuffer) {
1647 int i;
1648
1649 /* lazy allocation */
1650 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1651 if (!meye.grab_fbuffer) {
1652 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1653 mutex_unlock(&meye.lock);
1654 return -ENOMEM;
1655 }
1656 for (i = 0; i < gbuffers; i++)
1657 meye.vma_use_count[i] = 0;
1658 }
1659 pos = (unsigned long)meye.grab_fbuffer + offset;
1660
1661 while (size > 0) {
1662 page = vmalloc_to_pfn((void *)pos);
1663 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1664 mutex_unlock(&meye.lock);
1665 return -EAGAIN;
1666 }
1667 start += PAGE_SIZE;
1668 pos += PAGE_SIZE;
1669 if (size > PAGE_SIZE)
1670 size -= PAGE_SIZE;
1671 else
1672 size = 0;
1673 }
1674
1675 vma->vm_ops = &meye_vm_ops;
1676 vma->vm_flags &= ~VM_IO; /* not I/O memory */
1677 vma->vm_flags |= VM_RESERVED; /* avoid to swap out this VMA */
1678 vma->vm_private_data = (void *) (offset / gbufsize);
1679 meye_vm_open(vma);
1680
1681 mutex_unlock(&meye.lock);
1682 return 0;
1683 }
1684
1685 static const struct file_operations meye_fops = {
1686 .owner = THIS_MODULE,
1687 .open = meye_open,
1688 .release = meye_release,
1689 .mmap = meye_mmap,
1690 .ioctl = video_ioctl2,
1691 #ifdef CONFIG_COMPAT
1692 .compat_ioctl = v4l_compat_ioctl32,
1693 #endif
1694 .poll = meye_poll,
1695 .llseek = no_llseek,
1696 };
1697
1698 static struct video_device meye_template = {
1699 .owner = THIS_MODULE,
1700 .name = "meye",
1701 .type = VID_TYPE_CAPTURE,
1702 .fops = &meye_fops,
1703 .release = video_device_release,
1704 .minor = -1,
1705 .vidioc_querycap = vidioc_querycap,
1706 .vidioc_enum_input = vidioc_enum_input,
1707 .vidioc_g_input = vidioc_g_input,
1708 .vidioc_s_input = vidioc_s_input,
1709 .vidioc_queryctrl = vidioc_queryctrl,
1710 .vidioc_s_ctrl = vidioc_s_ctrl,
1711 .vidioc_g_ctrl = vidioc_g_ctrl,
1712 .vidioc_enum_fmt_cap = vidioc_enum_fmt_cap,
1713 .vidioc_try_fmt_cap = vidioc_try_fmt_cap,
1714 .vidioc_g_fmt_cap = vidioc_g_fmt_cap,
1715 .vidioc_s_fmt_cap = vidioc_s_fmt_cap,
1716 .vidioc_reqbufs = vidioc_reqbufs,
1717 .vidioc_querybuf = vidioc_querybuf,
1718 .vidioc_qbuf = vidioc_qbuf,
1719 .vidioc_dqbuf = vidioc_dqbuf,
1720 .vidioc_streamon = vidioc_streamon,
1721 .vidioc_streamoff = vidioc_streamoff,
1722 .vidioc_default = vidioc_default,
1723 };
1724
1725 #ifdef CONFIG_PM
1726 static int meye_suspend(struct pci_dev *pdev, pm_message_t state)
1727 {
1728 pci_save_state(pdev);
1729 meye.pm_mchip_mode = meye.mchip_mode;
1730 mchip_hic_stop();
1731 mchip_set(MCHIP_MM_INTA, 0x0);
1732 return 0;
1733 }
1734
1735 static int meye_resume(struct pci_dev *pdev)
1736 {
1737 pci_restore_state(pdev);
1738 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1739
1740 mchip_delay(MCHIP_HIC_CMD, 0);
1741 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1742 msleep(1);
1743 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1744 msleep(1);
1745 mchip_set(MCHIP_MM_PCI_MODE, 5);
1746 msleep(1);
1747 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1748
1749 switch (meye.pm_mchip_mode) {
1750 case MCHIP_HIC_MODE_CONT_OUT:
1751 mchip_continuous_start();
1752 break;
1753 case MCHIP_HIC_MODE_CONT_COMP:
1754 mchip_cont_compression_start();
1755 break;
1756 }
1757 return 0;
1758 }
1759 #endif
1760
1761 static int __devinit meye_probe(struct pci_dev *pcidev,
1762 const struct pci_device_id *ent)
1763 {
1764 int ret = -EBUSY;
1765 unsigned long mchip_adr;
1766
1767 if (meye.mchip_dev != NULL) {
1768 printk(KERN_ERR "meye: only one device allowed!\n");
1769 goto outnotdev;
1770 }
1771
1772 meye.mchip_dev = pcidev;
1773 meye.video_dev = video_device_alloc();
1774 if (!meye.video_dev) {
1775 printk(KERN_ERR "meye: video_device_alloc() failed!\n");
1776 goto outnotdev;
1777 }
1778
1779 ret = -ENOMEM;
1780 meye.grab_temp = vmalloc(MCHIP_NB_PAGES_MJPEG * PAGE_SIZE);
1781 if (!meye.grab_temp) {
1782 printk(KERN_ERR "meye: grab buffer allocation failed\n");
1783 goto outvmalloc;
1784 }
1785
1786 spin_lock_init(&meye.grabq_lock);
1787 meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1788 &meye.grabq_lock);
1789 if (IS_ERR(meye.grabq)) {
1790 printk(KERN_ERR "meye: fifo allocation failed\n");
1791 goto outkfifoalloc1;
1792 }
1793 spin_lock_init(&meye.doneq_lock);
1794 meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
1795 &meye.doneq_lock);
1796 if (IS_ERR(meye.doneq)) {
1797 printk(KERN_ERR "meye: fifo allocation failed\n");
1798 goto outkfifoalloc2;
1799 }
1800
1801 memcpy(meye.video_dev, &meye_template, sizeof(meye_template));
1802 meye.video_dev->dev = &meye.mchip_dev->dev;
1803
1804 if ((ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1))) {
1805 printk(KERN_ERR "meye: unable to power on the camera\n");
1806 printk(KERN_ERR "meye: did you enable the camera in "
1807 "sonypi using the module options ?\n");
1808 goto outsonypienable;
1809 }
1810
1811 ret = -EIO;
1812 if ((ret = pci_enable_device(meye.mchip_dev))) {
1813 printk(KERN_ERR "meye: pci_enable_device failed\n");
1814 goto outenabledev;
1815 }
1816
1817 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1818 if (!mchip_adr) {
1819 printk(KERN_ERR "meye: mchip has no device base address\n");
1820 goto outregions;
1821 }
1822 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1823 pci_resource_len(meye.mchip_dev, 0),
1824 "meye")) {
1825 printk(KERN_ERR "meye: request_mem_region failed\n");
1826 goto outregions;
1827 }
1828 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1829 if (!meye.mchip_mmregs) {
1830 printk(KERN_ERR "meye: ioremap failed\n");
1831 goto outremap;
1832 }
1833
1834 meye.mchip_irq = pcidev->irq;
1835 if (request_irq(meye.mchip_irq, meye_irq,
1836 IRQF_DISABLED | IRQF_SHARED, "meye", meye_irq)) {
1837 printk(KERN_ERR "meye: request_irq failed\n");
1838 goto outreqirq;
1839 }
1840
1841 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1842 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1843
1844 pci_set_master(meye.mchip_dev);
1845
1846 /* Ask the camera to perform a soft reset. */
1847 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1848
1849 mchip_delay(MCHIP_HIC_CMD, 0);
1850 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1851
1852 msleep(1);
1853 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1854
1855 msleep(1);
1856 mchip_set(MCHIP_MM_PCI_MODE, 5);
1857
1858 msleep(1);
1859 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1860
1861 if (video_register_device(meye.video_dev, VFL_TYPE_GRABBER,
1862 video_nr) < 0) {
1863 printk(KERN_ERR "meye: video_register_device failed\n");
1864 goto outvideoreg;
1865 }
1866
1867 mutex_init(&meye.lock);
1868 init_waitqueue_head(&meye.proc_list);
1869 meye.picture.depth = 16;
1870 meye.picture.palette = VIDEO_PALETTE_YUV422;
1871 meye.picture.brightness = 32 << 10;
1872 meye.picture.hue = 32 << 10;
1873 meye.picture.colour = 32 << 10;
1874 meye.picture.contrast = 32 << 10;
1875 meye.picture.whiteness = 0;
1876 meye.params.subsample = 0;
1877 meye.params.quality = 8;
1878 meye.params.sharpness = 32;
1879 meye.params.agc = 48;
1880 meye.params.picture = 0;
1881 meye.params.framerate = 0;
1882
1883 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, 32);
1884 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAHUE, 32);
1885 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACOLOR, 32);
1886 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERACONTRAST, 32);
1887 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERASHARPNESS, 32);
1888 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1889 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1890
1891 printk(KERN_INFO "meye: Motion Eye Camera Driver v%s.\n",
1892 MEYE_DRIVER_VERSION);
1893 printk(KERN_INFO "meye: mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1894 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1895
1896 return 0;
1897
1898 outvideoreg:
1899 free_irq(meye.mchip_irq, meye_irq);
1900 outreqirq:
1901 iounmap(meye.mchip_mmregs);
1902 outremap:
1903 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1904 pci_resource_len(meye.mchip_dev, 0));
1905 outregions:
1906 pci_disable_device(meye.mchip_dev);
1907 outenabledev:
1908 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1909 outsonypienable:
1910 kfifo_free(meye.doneq);
1911 outkfifoalloc2:
1912 kfifo_free(meye.grabq);
1913 outkfifoalloc1:
1914 vfree(meye.grab_temp);
1915 outvmalloc:
1916 video_device_release(meye.video_dev);
1917 outnotdev:
1918 return ret;
1919 }
1920
1921 static void __devexit meye_remove(struct pci_dev *pcidev)
1922 {
1923 video_unregister_device(meye.video_dev);
1924
1925 mchip_hic_stop();
1926
1927 mchip_dma_free();
1928
1929 /* disable interrupts */
1930 mchip_set(MCHIP_MM_INTA, 0x0);
1931
1932 free_irq(meye.mchip_irq, meye_irq);
1933
1934 iounmap(meye.mchip_mmregs);
1935
1936 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1937 pci_resource_len(meye.mchip_dev, 0));
1938
1939 pci_disable_device(meye.mchip_dev);
1940
1941 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1942
1943 kfifo_free(meye.doneq);
1944 kfifo_free(meye.grabq);
1945
1946 vfree(meye.grab_temp);
1947
1948 if (meye.grab_fbuffer) {
1949 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1950 meye.grab_fbuffer = NULL;
1951 }
1952
1953 printk(KERN_INFO "meye: removed\n");
1954 }
1955
1956 static struct pci_device_id meye_pci_tbl[] = {
1957 { PCI_VENDOR_ID_KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002,
1958 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
1959 { }
1960 };
1961
1962 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1963
1964 static struct pci_driver meye_driver = {
1965 .name = "meye",
1966 .id_table = meye_pci_tbl,
1967 .probe = meye_probe,
1968 .remove = __devexit_p(meye_remove),
1969 #ifdef CONFIG_PM
1970 .suspend = meye_suspend,
1971 .resume = meye_resume,
1972 #endif
1973 };
1974
1975 static int __init meye_init(void)
1976 {
1977 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1978 if (gbufsize < 0 || gbufsize > MEYE_MAX_BUFSIZE)
1979 gbufsize = MEYE_MAX_BUFSIZE;
1980 gbufsize = PAGE_ALIGN(gbufsize);
1981 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) "
1982 "for capture\n",
1983 gbuffers,
1984 gbufsize / 1024, gbuffers * gbufsize / 1024);
1985 return pci_register_driver(&meye_driver);
1986 }
1987
1988 static void __exit meye_exit(void)
1989 {
1990 pci_unregister_driver(&meye_driver);
1991 }
1992
1993 module_init(meye_init);
1994 module_exit(meye_exit);
Support for the Chinese Samsung S3C2440 based development boards