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 /****************************************************************************/
rvmalloc(unsigned long size)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
rvfree(void * mem,unsigned long size)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 */
ptable_alloc(void)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
ptable_free(void)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 */
ptable_copy(u8 * buf,int start,int size,int pt_pages)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 */
jpeg_quantisation_tables(int * length,int quality)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 */
jpeg_huffman_tables(int * length)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 */
mchip_hsize(void)388 static inline int mchip_hsize(void)
389 {
390 return meye.params.subsample ? 320 : 640;
391 }
392
393 /* returns the vertical capture size */
mchip_vsize(void)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 */
mchip_sync(int reg)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 */
mchip_set(int reg,u32 v)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 */
mchip_read(int reg)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 */
mchip_delay(u32 reg,u32 v)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 */
mchip_subsample(void)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 */
mchip_set_framerate(void)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 */
mchip_load_tables(void)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 */
mchip_vrj_setup(u8 mode)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 */
mchip_dma_setup(dma_addr_t dma_addr)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 */
mchip_dma_alloc(void)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 */
mchip_dma_free(void)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 */
mchip_hic_stop(void)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 */
mchip_get_frame(void)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 */
mchip_free_frame(void)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 */
mchip_cont_read_frame(u32 v,u8 * buf,int size)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 */
mchip_comp_read_frame(u32 v,u8 * buf,int size)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 */
mchip_take_picture(void)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 */
mchip_get_picture(u8 * buf,int bufsize)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 */
mchip_continuous_start(void)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 */
mchip_compress_frame(u8 * buf,int bufsize)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 */
mchip_cont_compression_start(void)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
meye_irq(int irq,void * dev_id)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
meye_open(struct file * file)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
meye_release(struct file * file)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
meyeioc_g_params(struct meye_params * p)864 static int meyeioc_g_params(struct meye_params *p)
865 {
866 *p = meye.params;
867 return 0;
868 }
869
meyeioc_s_params(struct meye_params * jp)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
meyeioc_qbuf_capt(int * nb)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
meyeioc_sync(struct file * file,void * fh,int * i)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 fallthrough;
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
meyeioc_stillcapt(void)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
meyeioc_stilljcapt(int * len)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
vidioc_querycap(struct file * file,void * fh,struct v4l2_capability * cap)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 return 0;
1016 }
1017
vidioc_enum_input(struct file * file,void * fh,struct v4l2_input * i)1018 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1019 {
1020 if (i->index != 0)
1021 return -EINVAL;
1022
1023 strscpy(i->name, "Camera", sizeof(i->name));
1024 i->type = V4L2_INPUT_TYPE_CAMERA;
1025
1026 return 0;
1027 }
1028
vidioc_g_input(struct file * file,void * fh,unsigned int * i)1029 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1030 {
1031 *i = 0;
1032 return 0;
1033 }
1034
vidioc_s_input(struct file * file,void * fh,unsigned int i)1035 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
1036 {
1037 if (i != 0)
1038 return -EINVAL;
1039
1040 return 0;
1041 }
1042
meye_s_ctrl(struct v4l2_ctrl * ctrl)1043 static int meye_s_ctrl(struct v4l2_ctrl *ctrl)
1044 {
1045 mutex_lock(&meye.lock);
1046 switch (ctrl->id) {
1047 case V4L2_CID_BRIGHTNESS:
1048 sony_pic_camera_command(
1049 SONY_PIC_COMMAND_SETCAMERABRIGHTNESS, ctrl->val);
1050 meye.brightness = ctrl->val << 10;
1051 break;
1052 case V4L2_CID_HUE:
1053 sony_pic_camera_command(
1054 SONY_PIC_COMMAND_SETCAMERAHUE, ctrl->val);
1055 meye.hue = ctrl->val << 10;
1056 break;
1057 case V4L2_CID_CONTRAST:
1058 sony_pic_camera_command(
1059 SONY_PIC_COMMAND_SETCAMERACONTRAST, ctrl->val);
1060 meye.contrast = ctrl->val << 10;
1061 break;
1062 case V4L2_CID_SATURATION:
1063 sony_pic_camera_command(
1064 SONY_PIC_COMMAND_SETCAMERACOLOR, ctrl->val);
1065 meye.colour = ctrl->val << 10;
1066 break;
1067 case V4L2_CID_MEYE_AGC:
1068 sony_pic_camera_command(
1069 SONY_PIC_COMMAND_SETCAMERAAGC, ctrl->val);
1070 meye.params.agc = ctrl->val;
1071 break;
1072 case V4L2_CID_SHARPNESS:
1073 sony_pic_camera_command(
1074 SONY_PIC_COMMAND_SETCAMERASHARPNESS, ctrl->val);
1075 meye.params.sharpness = ctrl->val;
1076 break;
1077 case V4L2_CID_MEYE_PICTURE:
1078 sony_pic_camera_command(
1079 SONY_PIC_COMMAND_SETCAMERAPICTURE, ctrl->val);
1080 meye.params.picture = ctrl->val;
1081 break;
1082 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1083 meye.params.quality = ctrl->val;
1084 break;
1085 case V4L2_CID_MEYE_FRAMERATE:
1086 meye.params.framerate = ctrl->val;
1087 break;
1088 default:
1089 mutex_unlock(&meye.lock);
1090 return -EINVAL;
1091 }
1092 mutex_unlock(&meye.lock);
1093
1094 return 0;
1095 }
1096
vidioc_enum_fmt_vid_cap(struct file * file,void * fh,struct v4l2_fmtdesc * f)1097 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh,
1098 struct v4l2_fmtdesc *f)
1099 {
1100 if (f->index > 1)
1101 return -EINVAL;
1102
1103 if (f->index == 0) {
1104 /* standard YUV 422 capture */
1105 f->flags = 0;
1106 f->pixelformat = V4L2_PIX_FMT_YUYV;
1107 } else {
1108 /* compressed MJPEG capture */
1109 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1110 }
1111
1112 return 0;
1113 }
1114
vidioc_try_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * f)1115 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh,
1116 struct v4l2_format *f)
1117 {
1118 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1119 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1120 return -EINVAL;
1121
1122 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1123 f->fmt.pix.field != V4L2_FIELD_NONE)
1124 return -EINVAL;
1125
1126 f->fmt.pix.field = V4L2_FIELD_NONE;
1127
1128 if (f->fmt.pix.width <= 320) {
1129 f->fmt.pix.width = 320;
1130 f->fmt.pix.height = 240;
1131 } else {
1132 f->fmt.pix.width = 640;
1133 f->fmt.pix.height = 480;
1134 }
1135
1136 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1137 f->fmt.pix.sizeimage = f->fmt.pix.height *
1138 f->fmt.pix.bytesperline;
1139 f->fmt.pix.colorspace = 0;
1140
1141 return 0;
1142 }
1143
vidioc_g_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * f)1144 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh,
1145 struct v4l2_format *f)
1146 {
1147 switch (meye.mchip_mode) {
1148 case MCHIP_HIC_MODE_CONT_OUT:
1149 default:
1150 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
1151 break;
1152 case MCHIP_HIC_MODE_CONT_COMP:
1153 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1154 break;
1155 }
1156
1157 f->fmt.pix.field = V4L2_FIELD_NONE;
1158 f->fmt.pix.width = mchip_hsize();
1159 f->fmt.pix.height = mchip_vsize();
1160 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1161 f->fmt.pix.sizeimage = f->fmt.pix.height *
1162 f->fmt.pix.bytesperline;
1163
1164 return 0;
1165 }
1166
vidioc_s_fmt_vid_cap(struct file * file,void * fh,struct v4l2_format * f)1167 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh,
1168 struct v4l2_format *f)
1169 {
1170 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV &&
1171 f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
1172 return -EINVAL;
1173
1174 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
1175 f->fmt.pix.field != V4L2_FIELD_NONE)
1176 return -EINVAL;
1177
1178 f->fmt.pix.field = V4L2_FIELD_NONE;
1179 mutex_lock(&meye.lock);
1180
1181 if (f->fmt.pix.width <= 320) {
1182 f->fmt.pix.width = 320;
1183 f->fmt.pix.height = 240;
1184 meye.params.subsample = 1;
1185 } else {
1186 f->fmt.pix.width = 640;
1187 f->fmt.pix.height = 480;
1188 meye.params.subsample = 0;
1189 }
1190
1191 switch (f->fmt.pix.pixelformat) {
1192 case V4L2_PIX_FMT_YUYV:
1193 meye.mchip_mode = MCHIP_HIC_MODE_CONT_OUT;
1194 break;
1195 case V4L2_PIX_FMT_MJPEG:
1196 meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
1197 break;
1198 }
1199
1200 mutex_unlock(&meye.lock);
1201 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
1202 f->fmt.pix.sizeimage = f->fmt.pix.height *
1203 f->fmt.pix.bytesperline;
1204 f->fmt.pix.colorspace = 0;
1205
1206 return 0;
1207 }
1208
vidioc_reqbufs(struct file * file,void * fh,struct v4l2_requestbuffers * req)1209 static int vidioc_reqbufs(struct file *file, void *fh,
1210 struct v4l2_requestbuffers *req)
1211 {
1212 int i;
1213
1214 if (req->memory != V4L2_MEMORY_MMAP)
1215 return -EINVAL;
1216
1217 if (meye.grab_fbuffer && req->count == gbuffers) {
1218 /* already allocated, no modifications */
1219 return 0;
1220 }
1221
1222 mutex_lock(&meye.lock);
1223 if (meye.grab_fbuffer) {
1224 for (i = 0; i < gbuffers; i++)
1225 if (meye.vma_use_count[i]) {
1226 mutex_unlock(&meye.lock);
1227 return -EINVAL;
1228 }
1229 rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
1230 meye.grab_fbuffer = NULL;
1231 }
1232
1233 gbuffers = max(2, min((int)req->count, MEYE_MAX_BUFNBRS));
1234 req->count = gbuffers;
1235 meye.grab_fbuffer = rvmalloc(gbuffers * gbufsize);
1236
1237 if (!meye.grab_fbuffer) {
1238 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1239 mutex_unlock(&meye.lock);
1240 return -ENOMEM;
1241 }
1242
1243 for (i = 0; i < gbuffers; i++)
1244 meye.vma_use_count[i] = 0;
1245
1246 mutex_unlock(&meye.lock);
1247
1248 return 0;
1249 }
1250
vidioc_querybuf(struct file * file,void * fh,struct v4l2_buffer * buf)1251 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1252 {
1253 unsigned int index = buf->index;
1254
1255 if (index >= gbuffers)
1256 return -EINVAL;
1257
1258 buf->bytesused = meye.grab_buffer[index].size;
1259 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1260
1261 if (meye.grab_buffer[index].state == MEYE_BUF_USING)
1262 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1263
1264 if (meye.grab_buffer[index].state == MEYE_BUF_DONE)
1265 buf->flags |= V4L2_BUF_FLAG_DONE;
1266
1267 buf->field = V4L2_FIELD_NONE;
1268 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[index].ts);
1269 buf->sequence = meye.grab_buffer[index].sequence;
1270 buf->memory = V4L2_MEMORY_MMAP;
1271 buf->m.offset = index * gbufsize;
1272 buf->length = gbufsize;
1273
1274 return 0;
1275 }
1276
vidioc_qbuf(struct file * file,void * fh,struct v4l2_buffer * buf)1277 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1278 {
1279 if (buf->memory != V4L2_MEMORY_MMAP)
1280 return -EINVAL;
1281
1282 if (buf->index >= gbuffers)
1283 return -EINVAL;
1284
1285 if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
1286 return -EINVAL;
1287
1288 mutex_lock(&meye.lock);
1289 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1290 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1291 meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
1292 kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
1293 sizeof(int), &meye.grabq_lock);
1294 mutex_unlock(&meye.lock);
1295
1296 return 0;
1297 }
1298
vidioc_dqbuf(struct file * file,void * fh,struct v4l2_buffer * buf)1299 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1300 {
1301 int reqnr;
1302
1303 if (buf->memory != V4L2_MEMORY_MMAP)
1304 return -EINVAL;
1305
1306 mutex_lock(&meye.lock);
1307
1308 if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
1309 mutex_unlock(&meye.lock);
1310 return -EAGAIN;
1311 }
1312
1313 if (wait_event_interruptible(meye.proc_list,
1314 kfifo_len(&meye.doneq) != 0) < 0) {
1315 mutex_unlock(&meye.lock);
1316 return -EINTR;
1317 }
1318
1319 if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
1320 sizeof(int), &meye.doneq_lock)) {
1321 mutex_unlock(&meye.lock);
1322 return -EBUSY;
1323 }
1324
1325 if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
1326 mutex_unlock(&meye.lock);
1327 return -EINVAL;
1328 }
1329
1330 buf->index = reqnr;
1331 buf->bytesused = meye.grab_buffer[reqnr].size;
1332 buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1333 buf->field = V4L2_FIELD_NONE;
1334 v4l2_buffer_set_timestamp(buf, meye.grab_buffer[reqnr].ts);
1335 buf->sequence = meye.grab_buffer[reqnr].sequence;
1336 buf->memory = V4L2_MEMORY_MMAP;
1337 buf->m.offset = reqnr * gbufsize;
1338 buf->length = gbufsize;
1339 meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
1340 mutex_unlock(&meye.lock);
1341
1342 return 0;
1343 }
1344
vidioc_streamon(struct file * file,void * fh,enum v4l2_buf_type i)1345 static int vidioc_streamon(struct file *file, void *fh, enum v4l2_buf_type i)
1346 {
1347 mutex_lock(&meye.lock);
1348
1349 switch (meye.mchip_mode) {
1350 case MCHIP_HIC_MODE_CONT_OUT:
1351 mchip_continuous_start();
1352 break;
1353 case MCHIP_HIC_MODE_CONT_COMP:
1354 mchip_cont_compression_start();
1355 break;
1356 default:
1357 mutex_unlock(&meye.lock);
1358 return -EINVAL;
1359 }
1360
1361 mutex_unlock(&meye.lock);
1362
1363 return 0;
1364 }
1365
vidioc_streamoff(struct file * file,void * fh,enum v4l2_buf_type i)1366 static int vidioc_streamoff(struct file *file, void *fh, enum v4l2_buf_type i)
1367 {
1368 mutex_lock(&meye.lock);
1369 mchip_hic_stop();
1370 kfifo_reset(&meye.grabq);
1371 kfifo_reset(&meye.doneq);
1372
1373 for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
1374 meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
1375
1376 mutex_unlock(&meye.lock);
1377 return 0;
1378 }
1379
vidioc_default(struct file * file,void * fh,bool valid_prio,unsigned int cmd,void * arg)1380 static long vidioc_default(struct file *file, void *fh, bool valid_prio,
1381 unsigned int cmd, void *arg)
1382 {
1383 switch (cmd) {
1384 case MEYEIOC_G_PARAMS:
1385 return meyeioc_g_params((struct meye_params *) arg);
1386
1387 case MEYEIOC_S_PARAMS:
1388 return meyeioc_s_params((struct meye_params *) arg);
1389
1390 case MEYEIOC_QBUF_CAPT:
1391 return meyeioc_qbuf_capt((int *) arg);
1392
1393 case MEYEIOC_SYNC:
1394 return meyeioc_sync(file, fh, (int *) arg);
1395
1396 case MEYEIOC_STILLCAPT:
1397 return meyeioc_stillcapt();
1398
1399 case MEYEIOC_STILLJCAPT:
1400 return meyeioc_stilljcapt((int *) arg);
1401
1402 default:
1403 return -ENOTTY;
1404 }
1405
1406 }
1407
meye_poll(struct file * file,poll_table * wait)1408 static __poll_t meye_poll(struct file *file, poll_table *wait)
1409 {
1410 __poll_t res = v4l2_ctrl_poll(file, wait);
1411
1412 mutex_lock(&meye.lock);
1413 poll_wait(file, &meye.proc_list, wait);
1414 if (kfifo_len(&meye.doneq))
1415 res |= EPOLLIN | EPOLLRDNORM;
1416 mutex_unlock(&meye.lock);
1417 return res;
1418 }
1419
meye_vm_open(struct vm_area_struct * vma)1420 static void meye_vm_open(struct vm_area_struct *vma)
1421 {
1422 long idx = (long)vma->vm_private_data;
1423 meye.vma_use_count[idx]++;
1424 }
1425
meye_vm_close(struct vm_area_struct * vma)1426 static void meye_vm_close(struct vm_area_struct *vma)
1427 {
1428 long idx = (long)vma->vm_private_data;
1429 meye.vma_use_count[idx]--;
1430 }
1431
1432 static const struct vm_operations_struct meye_vm_ops = {
1433 .open = meye_vm_open,
1434 .close = meye_vm_close,
1435 };
1436
meye_mmap(struct file * file,struct vm_area_struct * vma)1437 static int meye_mmap(struct file *file, struct vm_area_struct *vma)
1438 {
1439 unsigned long start = vma->vm_start;
1440 unsigned long size = vma->vm_end - vma->vm_start;
1441 unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
1442 unsigned long page, pos;
1443
1444 mutex_lock(&meye.lock);
1445 if (size > gbuffers * gbufsize || offset > gbuffers * gbufsize - size) {
1446 mutex_unlock(&meye.lock);
1447 return -EINVAL;
1448 }
1449 if (!meye.grab_fbuffer) {
1450 int i;
1451
1452 /* lazy allocation */
1453 meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
1454 if (!meye.grab_fbuffer) {
1455 printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
1456 mutex_unlock(&meye.lock);
1457 return -ENOMEM;
1458 }
1459 for (i = 0; i < gbuffers; i++)
1460 meye.vma_use_count[i] = 0;
1461 }
1462 pos = (unsigned long)meye.grab_fbuffer + offset;
1463
1464 while (size > 0) {
1465 page = vmalloc_to_pfn((void *)pos);
1466 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1467 mutex_unlock(&meye.lock);
1468 return -EAGAIN;
1469 }
1470 start += PAGE_SIZE;
1471 pos += PAGE_SIZE;
1472 if (size > PAGE_SIZE)
1473 size -= PAGE_SIZE;
1474 else
1475 size = 0;
1476 }
1477
1478 vma->vm_ops = &meye_vm_ops;
1479 /* not I/O memory */
1480 vm_flags_mod(vma, VM_DONTEXPAND | VM_DONTDUMP, VM_IO);
1481 vma->vm_private_data = (void *) (offset / gbufsize);
1482 meye_vm_open(vma);
1483
1484 mutex_unlock(&meye.lock);
1485 return 0;
1486 }
1487
1488 static const struct v4l2_file_operations meye_fops = {
1489 .owner = THIS_MODULE,
1490 .open = meye_open,
1491 .release = meye_release,
1492 .mmap = meye_mmap,
1493 .unlocked_ioctl = video_ioctl2,
1494 .poll = meye_poll,
1495 };
1496
1497 static const struct v4l2_ioctl_ops meye_ioctl_ops = {
1498 .vidioc_querycap = vidioc_querycap,
1499 .vidioc_enum_input = vidioc_enum_input,
1500 .vidioc_g_input = vidioc_g_input,
1501 .vidioc_s_input = vidioc_s_input,
1502 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1503 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1504 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1505 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1506 .vidioc_reqbufs = vidioc_reqbufs,
1507 .vidioc_querybuf = vidioc_querybuf,
1508 .vidioc_qbuf = vidioc_qbuf,
1509 .vidioc_dqbuf = vidioc_dqbuf,
1510 .vidioc_streamon = vidioc_streamon,
1511 .vidioc_streamoff = vidioc_streamoff,
1512 .vidioc_log_status = v4l2_ctrl_log_status,
1513 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1514 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1515 .vidioc_default = vidioc_default,
1516 };
1517
1518 static const struct video_device meye_template = {
1519 .name = "meye",
1520 .fops = &meye_fops,
1521 .ioctl_ops = &meye_ioctl_ops,
1522 .release = video_device_release_empty,
1523 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING,
1524 };
1525
1526 static const struct v4l2_ctrl_ops meye_ctrl_ops = {
1527 .s_ctrl = meye_s_ctrl,
1528 };
1529
meye_suspend(struct device * dev)1530 static int __maybe_unused meye_suspend(struct device *dev)
1531 {
1532 meye.pm_mchip_mode = meye.mchip_mode;
1533 mchip_hic_stop();
1534 mchip_set(MCHIP_MM_INTA, 0x0);
1535 return 0;
1536 }
1537
meye_resume(struct device * dev)1538 static int __maybe_unused meye_resume(struct device *dev)
1539 {
1540 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1541
1542 mchip_delay(MCHIP_HIC_CMD, 0);
1543 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1544 msleep(1);
1545 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1546 msleep(1);
1547 mchip_set(MCHIP_MM_PCI_MODE, 5);
1548 msleep(1);
1549 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1550
1551 switch (meye.pm_mchip_mode) {
1552 case MCHIP_HIC_MODE_CONT_OUT:
1553 mchip_continuous_start();
1554 break;
1555 case MCHIP_HIC_MODE_CONT_COMP:
1556 mchip_cont_compression_start();
1557 break;
1558 }
1559 return 0;
1560 }
1561
meye_probe(struct pci_dev * pcidev,const struct pci_device_id * ent)1562 static int meye_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
1563 {
1564 static const struct v4l2_ctrl_config ctrl_agc = {
1565 .id = V4L2_CID_MEYE_AGC,
1566 .type = V4L2_CTRL_TYPE_INTEGER,
1567 .ops = &meye_ctrl_ops,
1568 .name = "AGC",
1569 .max = 63,
1570 .step = 1,
1571 .def = 48,
1572 .flags = V4L2_CTRL_FLAG_SLIDER,
1573 };
1574 static const struct v4l2_ctrl_config ctrl_picture = {
1575 .id = V4L2_CID_MEYE_PICTURE,
1576 .type = V4L2_CTRL_TYPE_INTEGER,
1577 .ops = &meye_ctrl_ops,
1578 .name = "Picture",
1579 .max = 63,
1580 .step = 1,
1581 };
1582 static const struct v4l2_ctrl_config ctrl_framerate = {
1583 .id = V4L2_CID_MEYE_FRAMERATE,
1584 .type = V4L2_CTRL_TYPE_INTEGER,
1585 .ops = &meye_ctrl_ops,
1586 .name = "Framerate",
1587 .max = 31,
1588 .step = 1,
1589 };
1590 struct v4l2_device *v4l2_dev = &meye.v4l2_dev;
1591 int ret = -EBUSY;
1592 unsigned long mchip_adr;
1593
1594 if (meye.mchip_dev != NULL) {
1595 printk(KERN_ERR "meye: only one device allowed!\n");
1596 return ret;
1597 }
1598
1599 ret = v4l2_device_register(&pcidev->dev, v4l2_dev);
1600 if (ret < 0) {
1601 v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
1602 return ret;
1603 }
1604 ret = -ENOMEM;
1605 meye.mchip_dev = pcidev;
1606
1607 meye.grab_temp = vmalloc(array_size(PAGE_SIZE, MCHIP_NB_PAGES_MJPEG));
1608 if (!meye.grab_temp)
1609 goto outvmalloc;
1610
1611 spin_lock_init(&meye.grabq_lock);
1612 if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
1613 GFP_KERNEL))
1614 goto outkfifoalloc1;
1615
1616 spin_lock_init(&meye.doneq_lock);
1617 if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
1618 GFP_KERNEL))
1619 goto outkfifoalloc2;
1620
1621 meye.vdev = meye_template;
1622 meye.vdev.v4l2_dev = &meye.v4l2_dev;
1623
1624 ret = sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 1);
1625 if (ret) {
1626 v4l2_err(v4l2_dev, "meye: unable to power on the camera\n");
1627 v4l2_err(v4l2_dev, "meye: did you enable the camera in sonypi using the module options ?\n");
1628 goto outsonypienable;
1629 }
1630
1631 ret = pci_enable_device(meye.mchip_dev);
1632 if (ret) {
1633 v4l2_err(v4l2_dev, "meye: pci_enable_device failed\n");
1634 goto outenabledev;
1635 }
1636
1637 ret = -EIO;
1638 mchip_adr = pci_resource_start(meye.mchip_dev,0);
1639 if (!mchip_adr) {
1640 v4l2_err(v4l2_dev, "meye: mchip has no device base address\n");
1641 goto outregions;
1642 }
1643 if (!request_mem_region(pci_resource_start(meye.mchip_dev, 0),
1644 pci_resource_len(meye.mchip_dev, 0),
1645 "meye")) {
1646 v4l2_err(v4l2_dev, "meye: request_mem_region failed\n");
1647 goto outregions;
1648 }
1649 meye.mchip_mmregs = ioremap(mchip_adr, MCHIP_MM_REGS);
1650 if (!meye.mchip_mmregs) {
1651 v4l2_err(v4l2_dev, "meye: ioremap failed\n");
1652 goto outremap;
1653 }
1654
1655 meye.mchip_irq = pcidev->irq;
1656 if (request_irq(meye.mchip_irq, meye_irq,
1657 IRQF_SHARED, "meye", meye_irq)) {
1658 v4l2_err(v4l2_dev, "request_irq failed\n");
1659 goto outreqirq;
1660 }
1661
1662 pci_write_config_byte(meye.mchip_dev, PCI_CACHE_LINE_SIZE, 8);
1663 pci_write_config_byte(meye.mchip_dev, PCI_LATENCY_TIMER, 64);
1664
1665 pci_set_master(meye.mchip_dev);
1666
1667 /* Ask the camera to perform a soft reset. */
1668 pci_write_config_word(meye.mchip_dev, MCHIP_PCI_SOFTRESET_SET, 1);
1669
1670 mchip_delay(MCHIP_HIC_CMD, 0);
1671 mchip_delay(MCHIP_HIC_STATUS, MCHIP_HIC_STATUS_IDLE);
1672
1673 msleep(1);
1674 mchip_set(MCHIP_VRJ_SOFT_RESET, 1);
1675
1676 msleep(1);
1677 mchip_set(MCHIP_MM_PCI_MODE, 5);
1678
1679 msleep(1);
1680 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1681
1682 mutex_init(&meye.lock);
1683 init_waitqueue_head(&meye.proc_list);
1684
1685 v4l2_ctrl_handler_init(&meye.hdl, 3);
1686 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1687 V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
1688 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1689 V4L2_CID_HUE, 0, 63, 1, 32);
1690 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1691 V4L2_CID_CONTRAST, 0, 63, 1, 32);
1692 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1693 V4L2_CID_SATURATION, 0, 63, 1, 32);
1694 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_agc, NULL);
1695 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1696 V4L2_CID_SHARPNESS, 0, 63, 1, 32);
1697 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_picture, NULL);
1698 v4l2_ctrl_new_std(&meye.hdl, &meye_ctrl_ops,
1699 V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, 10, 1, 8);
1700 v4l2_ctrl_new_custom(&meye.hdl, &ctrl_framerate, NULL);
1701 if (meye.hdl.error) {
1702 v4l2_err(v4l2_dev, "couldn't register controls\n");
1703 goto outvideoreg;
1704 }
1705
1706 v4l2_ctrl_handler_setup(&meye.hdl);
1707 meye.vdev.ctrl_handler = &meye.hdl;
1708
1709 if (video_register_device(&meye.vdev, VFL_TYPE_VIDEO,
1710 video_nr) < 0) {
1711 v4l2_err(v4l2_dev, "video_register_device failed\n");
1712 goto outvideoreg;
1713 }
1714
1715 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1716 MEYE_DRIVER_VERSION);
1717 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
1718 meye.mchip_dev->revision, mchip_adr, meye.mchip_irq);
1719
1720 return 0;
1721
1722 outvideoreg:
1723 v4l2_ctrl_handler_free(&meye.hdl);
1724 free_irq(meye.mchip_irq, meye_irq);
1725 outreqirq:
1726 iounmap(meye.mchip_mmregs);
1727 outremap:
1728 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1729 pci_resource_len(meye.mchip_dev, 0));
1730 outregions:
1731 pci_disable_device(meye.mchip_dev);
1732 outenabledev:
1733 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1734 outsonypienable:
1735 kfifo_free(&meye.doneq);
1736 outkfifoalloc2:
1737 kfifo_free(&meye.grabq);
1738 outkfifoalloc1:
1739 vfree(meye.grab_temp);
1740 outvmalloc:
1741 return ret;
1742 }
1743
meye_remove(struct pci_dev * pcidev)1744 static void meye_remove(struct pci_dev *pcidev)
1745 {
1746 video_unregister_device(&meye.vdev);
1747
1748 mchip_hic_stop();
1749
1750 mchip_dma_free();
1751
1752 /* disable interrupts */
1753 mchip_set(MCHIP_MM_INTA, 0x0);
1754
1755 free_irq(meye.mchip_irq, meye_irq);
1756
1757 iounmap(meye.mchip_mmregs);
1758
1759 release_mem_region(pci_resource_start(meye.mchip_dev, 0),
1760 pci_resource_len(meye.mchip_dev, 0));
1761
1762 pci_disable_device(meye.mchip_dev);
1763
1764 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
1765
1766 kfifo_free(&meye.doneq);
1767 kfifo_free(&meye.grabq);
1768
1769 vfree(meye.grab_temp);
1770
1771 if (meye.grab_fbuffer) {
1772 rvfree(meye.grab_fbuffer, gbuffers*gbufsize);
1773 meye.grab_fbuffer = NULL;
1774 }
1775
1776 printk(KERN_INFO "meye: removed\n");
1777 }
1778
1779 static const struct pci_device_id meye_pci_tbl[] = {
1780 { PCI_VDEVICE(KAWASAKI, PCI_DEVICE_ID_MCHIP_KL5A72002), 0 },
1781 { }
1782 };
1783
1784 MODULE_DEVICE_TABLE(pci, meye_pci_tbl);
1785
1786 static SIMPLE_DEV_PM_OPS(meye_pm_ops, meye_suspend, meye_resume);
1787
1788 static struct pci_driver meye_driver = {
1789 .name = "meye",
1790 .id_table = meye_pci_tbl,
1791 .probe = meye_probe,
1792 .remove = meye_remove,
1793 .driver.pm = &meye_pm_ops,
1794 };
1795
meye_init(void)1796 static int __init meye_init(void)
1797 {
1798 gbuffers = max(2, min((int)gbuffers, MEYE_MAX_BUFNBRS));
1799 if (gbufsize > MEYE_MAX_BUFSIZE)
1800 gbufsize = MEYE_MAX_BUFSIZE;
1801 gbufsize = PAGE_ALIGN(gbufsize);
1802 printk(KERN_INFO "meye: using %d buffers with %dk (%dk total) for capture\n",
1803 gbuffers,
1804 gbufsize / 1024, gbuffers * gbufsize / 1024);
1805 return pci_register_driver(&meye_driver);
1806 }
1807
meye_exit(void)1808 static void __exit meye_exit(void)
1809 {
1810 pci_unregister_driver(&meye_driver);
1811 }
1812
1813 module_init(meye_init);
1814 module_exit(meye_exit);
1815