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