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