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