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