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